1 // nacl.h -- Native Client support for gold -*- C++ -*-
2
3 // Copyright (C) 2012-2023 Free Software Foundation, Inc.
4
5 // This file is part of gold.
6
7 // This program is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation; either version 3 of the License, or
10 // (at your option) any later version.
11
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 // MA 02110-1301, USA.
21
22 #include "elfcpp_file.h"
23 #include "fileread.h"
24 #include "layout.h"
25 #include "target-select.h"
26 #include "target.h"
27
28 #ifndef GOLD_NACL_H
29 #define GOLD_NACL_H
30
31 namespace gold
32 {
33
34 class Sniff_file
35 {
36 public:
37 Sniff_file(Input_file* input_file, off_t offset)
38 : file_(input_file->file()), offset_(offset)
39 { }
40
41 class Location
42 {
43 public:
44 Location(off_t file_offset, off_t data_size)
45 : offset_(file_offset), size_(data_size)
46 { }
47
48 inline off_t offset() const
49 { return this->offset_; }
50
51 inline section_size_type size() const
52 { return this->size_; }
53
54 private:
55 off_t offset_;
56 section_size_type size_;
57 };
58
59 class View
60 {
61 public:
62 View(File_read& file, off_t file_offset, off_t data_size)
63 : data_(file.get_view(file_offset, 0, data_size, true, false))
64 { }
65
66 const unsigned char* data()
67 { return this->data_; }
68
69 private:
70 const unsigned char* data_;
71 };
72
73 View view(off_t file_offset, off_t data_size)
74 {
75 return View(this->file_, this->offset_ + file_offset, data_size);
76 }
77
78 View view(Location loc)
79 {
80 return this->view(loc.offset(), loc.size());
81 }
82
83 // Report an error.
84 void
85 error(const char* format, ...) const ATTRIBUTE_PRINTF_2;
86
87 private:
88 File_read& file_;
89 off_t offset_;
90 };
91
92
93 template<class base_selector, class nacl_target>
94 class Target_selector_nacl : public base_selector
95 {
96 public:
97 Target_selector_nacl(const char* nacl_abi_name,
98 const char* bfd_name, const char* emulation)
99 : base_selector(), is_nacl_(false), nacl_abi_name_(nacl_abi_name),
100 bfd_name_(bfd_name), emulation_(emulation)
101 { }
102
103 protected:
104 virtual Target*
105 do_instantiate_target()
106 {
107 if (this->is_nacl_)
108 return new nacl_target();
109 return this->base_selector::do_instantiate_target();
110 }
111
112 virtual Target*
113 do_recognize(Input_file* file, off_t offset,
114 int machine, int osabi, int abiversion)
115 {
116 this->is_nacl_ = file != NULL && this->recognize_nacl_file(file, offset);
117 if (this->is_nacl_)
118 return this->instantiate_target();
119 return this->base_selector::do_recognize(file, offset,
120 machine, osabi, abiversion);
121 }
122
123 virtual Target*
124 do_recognize_by_bfd_name(const char* name)
125 {
126 gold_assert(this->bfd_name_ != NULL);
127 this->is_nacl_ = strcmp(name, this->bfd_name_) == 0;
128 if (this->is_nacl_)
129 return this->instantiate_target();
130 return this->base_selector::do_recognize_by_bfd_name(name);
131 }
132
133 virtual void
134 do_supported_bfd_names(std::vector<const char*>* names)
135 {
136 gold_assert(this->bfd_name_ != NULL);
137 this->base_selector::do_supported_bfd_names(names);
138 names->push_back(this->bfd_name_);
139 }
140
141 virtual void
142 do_supported_emulations(std::vector<const char*>* emulations)
143 {
144 gold_assert(this->emulation_ != NULL);
145 this->base_selector::do_supported_emulations(emulations);
146 emulations->push_back(this->emulation_);
147 }
148
149 virtual const char*
150 do_target_bfd_name(const Target* target)
151 {
152 return (!this->is_our_target(target)
153 ? NULL
154 : (this->is_nacl_
155 ? this->bfd_name_
156 : base_selector::do_target_bfd_name(target)));
157 }
158
159 private:
160 bool
161 recognize_nacl_file(Input_file* input_file, off_t offset)
162 {
163 if (this->is_big_endian())
164 {
165 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
166 # ifdef HAVE_TARGET_32_BIG
167 if (this->get_size() == 32)
168 return do_recognize_nacl_file<32, true>(input_file, offset);
169 # endif
170 # ifdef HAVE_TARGET_64_BIG
171 if (this->get_size() == 64)
172 return do_recognize_nacl_file<64, true>(input_file, offset);
173 # endif
174 #endif
175 gold_unreachable();
176 }
177 else
178 {
179 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
180 # ifdef HAVE_TARGET_32_LITTLE
181 if (this->get_size() == 32)
182 return do_recognize_nacl_file<32, false>(input_file, offset);
183 # endif
184 # ifdef HAVE_TARGET_64_LITTLE
185 if (this->get_size() == 64)
186 return do_recognize_nacl_file<64, false>(input_file, offset);
187 # endif
188 #endif
189 gold_unreachable();
190 }
191 }
192
193 template<int size, bool big_endian>
194 bool
195 do_recognize_nacl_file(Input_file* input_file, off_t offset)
196 {
197 Sniff_file file(input_file, offset);
198 elfcpp::Elf_file<size, big_endian, Sniff_file> elf_file(&file);
199 const unsigned int shnum = elf_file.shnum();
200 for (unsigned int shndx = 1; shndx < shnum; ++shndx)
201 {
202 if (elf_file.section_type(shndx) == elfcpp::SHT_NOTE)
203 {
204 Sniff_file::Location loc = elf_file.section_contents(shndx);
205 if (loc.size() < (3 * 4
206 + align_address(sizeof "NaCl", 4)
207 + align_address(nacl_abi_name_.size() + 1, 4)))
208 continue;
209 Sniff_file::View view(file.view(loc));
210 const unsigned char* note_data = view.data();
211 if ((elfcpp::Swap<32, big_endian>::readval(note_data + 0)
212 == sizeof "NaCl")
213 && (elfcpp::Swap<32, big_endian>::readval(note_data + 4)
214 == nacl_abi_name_.size() + 1)
215 && (elfcpp::Swap<32, big_endian>::readval(note_data + 8)
216 == elfcpp::NT_VERSION))
217 {
218 const unsigned char* name = note_data + 12;
219 const unsigned char* desc = (name
220 + align_address(sizeof "NaCl", 4));
221 if (memcmp(name, "NaCl", sizeof "NaCl") == 0
222 && memcmp(desc, nacl_abi_name_.c_str(),
223 nacl_abi_name_.size() + 1) == 0)
224 return true;
225 }
226 }
227 }
228 return false;
229 }
230
231 // Whether we decided this was the NaCl target variant.
232 bool is_nacl_;
233 // The string found in the NaCl ABI note.
234 std::string nacl_abi_name_;
235 // BFD name of NaCl target, for compatibility.
236 const char* const bfd_name_;
237 // GNU linker emulation for this NaCl target, for compatibility.
238 const char* const emulation_;
239 };
240
241 } // end namespace gold
242
243 #endif // !defined(GOLD_NACL_H)