OSDN Git Service

538fb97ce6806f63b94bdacee512616d01d171f8
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / export.cc
1 // export.cc -- Export declarations in Go frontend.
2
3 // Copyright 2009 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
6
7 #include "go-system.h"
8 #include "sha1.h"
9
10 #ifndef ENABLE_BUILD_WITH_CXX
11 extern "C"
12 {
13 #endif
14
15 #include "machmode.h"
16 #include "output.h"
17 #include "target.h"
18
19 #ifndef ENABLE_BUILD_WITH_CXX
20 }
21 #endif
22
23 #include "gogo.h"
24 #include "types.h"
25 #include "statements.h"
26 #include "export.h"
27
28 // This file handles exporting global declarations.
29
30 // Class Export.
31
32 // Version 1 magic number.
33
34 const int Export::v1_magic_len;
35
36 const char Export::v1_magic[Export::v1_magic_len] =
37   {
38     'v', '1', ';', '\n'
39   };
40
41 const int Export::v1_checksum_len;
42
43 // Constructor.
44
45 Export::Export(Stream* stream)
46   : stream_(stream), type_refs_(), type_index_(1)
47 {
48 }
49
50 // A functor to sort Named_object pointers by name.
51
52 struct Sort_bindings
53 {
54   bool
55   operator()(const Named_object* n1, const Named_object* n2) const
56   { return n1->name() < n2->name(); }
57 };
58
59 // Return true if we should export NO.
60
61 static bool
62 should_export(Named_object* no)
63 {
64   // We only export objects which are locally defined.
65   if (no->package() != NULL)
66     return false;
67
68   // We don't export packages.
69   if (no->is_package())
70     return false;
71
72   // We don't export hidden names.
73   if (Gogo::is_hidden_name(no->name()))
74     return false;
75
76   // We don't export nested functions.
77   if (no->is_function() && no->func_value()->enclosing() != NULL)
78     return false;
79
80   // We don't export thunks.
81   if (no->is_function() && Gogo::is_thunk(no))
82     return false;
83
84   // Methods are exported with the type, not here.
85   if (no->is_function()
86       && no->func_value()->type()->is_method())
87     return false;
88   if (no->is_function_declaration()
89       && no->func_declaration_value()->type()->is_method())
90     return false;
91
92   // Don't export dummy global variables created for initializers when
93   // used with sinks.
94   if (no->is_variable() && no->name()[0] == '_' && no->name()[1] == '.')
95     return false;
96
97   return true;
98 }
99
100 // Export those identifiers marked for exporting.
101
102 void
103 Export::export_globals(const std::string& package_name,
104                        const std::string& unique_prefix,
105                        int package_priority,
106                        const std::string& import_init_fn,
107                        const std::set<Import_init>& imported_init_fns,
108                        const Bindings* bindings)
109 {
110   // If there have been any errors so far, don't try to export
111   // anything.  That way the export code doesn't have to worry about
112   // mismatched types or other confusions.
113   if (saw_errors())
114     return;
115
116   // Export the symbols in sorted order.  That will reduce cases where
117   // irrelevant changes to the source code affect the exported
118   // interface.
119   std::vector<Named_object*> exports;
120   exports.reserve(bindings->size_definitions());
121
122   for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
123        p != bindings->end_definitions();
124        ++p)
125     if (should_export(*p))
126       exports.push_back(*p);
127
128   for (Bindings::const_declarations_iterator p =
129          bindings->begin_declarations();
130        p != bindings->end_declarations();
131        ++p)
132     {
133       // We export a function declaration as it may be implemented in
134       // supporting C code.  We do not export type declarations.
135       if (p->second->is_function_declaration()
136           && should_export(p->second))
137         exports.push_back(p->second);
138     }
139
140   std::sort(exports.begin(), exports.end(), Sort_bindings());
141
142   // Although the export data is readable, at least this version is,
143   // it is conceptually a binary format.  Start with a four byte
144   // verison number.
145   this->write_bytes(Export::v1_magic, Export::v1_magic_len);
146
147   // The package name.
148   this->write_c_string("package ");
149   this->write_string(package_name);
150   this->write_c_string(";\n");
151
152   // The unique prefix.  This prefix is used for all global symbols.
153   this->write_c_string("prefix ");
154   this->write_string(unique_prefix);
155   this->write_c_string(";\n");
156
157   // The package priority.
158   char buf[100];
159   snprintf(buf, sizeof buf, "priority %d;\n", package_priority);
160   this->write_c_string(buf);
161
162   this->write_imported_init_fns(package_name, package_priority, import_init_fn,
163                                 imported_init_fns);
164
165   // FIXME: It might be clever to add something about the processor
166   // and ABI being used, although ideally any problems in that area
167   // would be caught by the linker.
168
169   for (std::vector<Named_object*>::const_iterator p = exports.begin();
170        p != exports.end();
171        ++p)
172     (*p)->export_named_object(this);
173
174   std::string checksum = this->stream_->checksum();
175   std::string s = "checksum ";
176   for (std::string::const_iterator p = checksum.begin();
177        p != checksum.end();
178        ++p)
179     {
180       unsigned char c = *p;
181       unsigned int dig = c >> 4;
182       s += dig < 10 ? '0' + dig : 'A' + dig - 10;
183       dig = c & 0xf;
184       s += dig < 10 ? '0' + dig : 'A' + dig - 10;
185     }
186   s += ";\n";
187   this->stream_->write_checksum(s);
188 }
189
190 // Write out the import control variables for this package.
191
192 void
193 Export::write_imported_init_fns(
194     const std::string& package_name,
195     int priority,
196     const std::string& import_init_fn,
197     const std::set<Import_init>& imported_init_fns)
198 {
199   if (import_init_fn.empty() && imported_init_fns.empty())
200     return;
201
202   this->write_c_string("import");
203
204   if (!import_init_fn.empty())
205     {
206       this->write_c_string(" ");
207       this->write_string(package_name);
208       this->write_c_string(" ");
209       this->write_string(import_init_fn);
210       char buf[100];
211       snprintf(buf, sizeof buf, " %d", priority);
212       this->write_c_string(buf);
213     }
214
215   if (!imported_init_fns.empty())
216     {
217       // Sort the list of functions for more consistent output.
218       std::vector<Import_init> v;
219       for (std::set<Import_init>::const_iterator p = imported_init_fns.begin();
220            p != imported_init_fns.end();
221            ++p)
222         v.push_back(*p);
223       std::sort(v.begin(), v.end());
224
225       for (std::vector<Import_init>::const_iterator p = v.begin();
226            p != v.end();
227            ++p)
228         {
229           this->write_c_string(" ");
230           this->write_string(p->package_name());
231           this->write_c_string(" ");
232           this->write_string(p->init_name());
233           char buf[100];
234           snprintf(buf, sizeof buf, " %d", p->priority());
235           this->write_c_string(buf);
236         }
237     }
238
239   this->write_c_string(";\n");
240 }
241
242 // Export a type.  We have to ensure that on import we create a single
243 // Named_type node for each named type.  We do this by keeping a hash
244 // table mapping named types to reference numbers.  The first time we
245 // see a named type we assign it a reference number by making an entry
246 // in the hash table.  If we see it again, we just refer to the
247 // reference number.
248
249 // Named types are, of course, associated with packages.  Note that we
250 // may see a named type when importing one package, and then later see
251 // the same named type when importing a different package.  The home
252 // package may or may not be imported during this compilation.  The
253 // reference number scheme has to get this all right.  Basic approach
254 // taken from "On the Linearization of Graphs and Writing Symbol
255 // Files" by Robert Griesemer.
256
257 void
258 Export::write_type(const Type* type)
259 {
260   // We don't want to assign a reference number to a forward
261   // declaration to a type which was defined later.
262   type = type->forwarded();
263
264   Type_refs::const_iterator p = this->type_refs_.find(type);
265   if (p != this->type_refs_.end())
266     {
267       // This type was already in the table.
268       int index = p->second;
269       go_assert(index != 0);
270       char buf[30];
271       snprintf(buf, sizeof buf, "<type %d>", index);
272       this->write_c_string(buf);
273       return;
274     }
275
276   const Named_type* named_type = type->named_type();
277   const Forward_declaration_type* forward = type->forward_declaration_type();
278
279   int index = this->type_index_;
280   ++this->type_index_;
281
282   char buf[30];
283   snprintf(buf, sizeof buf, "<type %d ", index);
284   this->write_c_string(buf);
285
286   if (named_type != NULL || forward != NULL)
287     {
288       const Named_object* named_object;
289       if (named_type != NULL)
290         {
291           // The builtin types should have been predefined.
292           go_assert(named_type->location() != BUILTINS_LOCATION
293                      || (named_type->named_object()->package()->name()
294                          == "unsafe"));
295           named_object = named_type->named_object();
296         }
297       else
298         named_object = forward->named_object();
299
300       const Package* package = named_object->package();
301
302       std::string s = "\"";
303       if (package != NULL && !Gogo::is_hidden_name(named_object->name()))
304         {
305           s += package->unique_prefix();
306           s += '.';
307           s += package->name();
308           s += '.';
309         }
310       s += named_object->name();
311       s += "\" ";
312       this->write_string(s);
313
314       // We must add a named type to the table now, since the
315       // definition of the type may refer to the named type via a
316       // pointer.
317       this->type_refs_[type] = index;
318     }
319
320   type->export_type(this);
321
322   this->write_c_string(">");
323
324   if (named_type == NULL)
325     this->type_refs_[type] = index;
326 }
327
328 // Add the builtin types to the export table.
329
330 void
331 Export::register_builtin_types(Gogo* gogo)
332 {
333   this->register_builtin_type(gogo, "int8", BUILTIN_INT8);
334   this->register_builtin_type(gogo, "int16", BUILTIN_INT16);
335   this->register_builtin_type(gogo, "int32", BUILTIN_INT32);
336   this->register_builtin_type(gogo, "int64", BUILTIN_INT64);
337   this->register_builtin_type(gogo, "uint8", BUILTIN_UINT8);
338   this->register_builtin_type(gogo, "uint16", BUILTIN_UINT16);
339   this->register_builtin_type(gogo, "uint32", BUILTIN_UINT32);
340   this->register_builtin_type(gogo, "uint64", BUILTIN_UINT64);
341   this->register_builtin_type(gogo, "float32", BUILTIN_FLOAT32);
342   this->register_builtin_type(gogo, "float64", BUILTIN_FLOAT64);
343   this->register_builtin_type(gogo, "complex64", BUILTIN_COMPLEX64);
344   this->register_builtin_type(gogo, "complex128", BUILTIN_COMPLEX128);
345   this->register_builtin_type(gogo, "int", BUILTIN_INT);
346   this->register_builtin_type(gogo, "uint", BUILTIN_UINT);
347   this->register_builtin_type(gogo, "uintptr", BUILTIN_UINTPTR);
348   this->register_builtin_type(gogo, "bool", BUILTIN_BOOL);
349   this->register_builtin_type(gogo, "string", BUILTIN_STRING);
350 }
351
352 // Register one builtin type in the export table.
353
354 void
355 Export::register_builtin_type(Gogo* gogo, const char* name, Builtin_code code)
356 {
357   Named_object* named_object = gogo->lookup_global(name);
358   go_assert(named_object != NULL && named_object->is_type());
359   std::pair<Type_refs::iterator, bool> ins =
360     this->type_refs_.insert(std::make_pair(named_object->type_value(), code));
361   go_assert(ins.second);
362
363   // We also insert the underlying type.  We can see the underlying
364   // type at least for string and bool.
365   Type* real_type = named_object->type_value()->real_type();
366   ins = this->type_refs_.insert(std::make_pair(real_type, code));
367   go_assert(ins.second);
368 }
369
370 // Class Export::Stream.
371
372 Export::Stream::Stream()
373 {
374   this->checksum_ = new sha1_ctx;
375   memset(this->checksum_, 0, sizeof(sha1_ctx));
376   sha1_init_ctx(this->checksum_);
377 }
378
379 Export::Stream::~Stream()
380 {
381 }
382
383 // Write bytes to the stream.  This keeps a checksum of bytes as they
384 // go by.
385
386 void
387 Export::Stream::write_and_sum_bytes(const char* bytes, size_t length)
388 {
389   sha1_process_bytes(bytes, length, this->checksum_);
390   this->do_write(bytes, length);
391 }
392
393 // Get the checksum.
394
395 std::string
396 Export::Stream::checksum()
397 {
398   // Use a union to provide the required alignment.
399   union
400   {
401     char checksum[Export::v1_checksum_len];
402     long align;
403   } u;
404   sha1_finish_ctx(this->checksum_, u.checksum);
405   return std::string(u.checksum, Export::v1_checksum_len);
406 }
407
408 // Write the checksum string to the export data.
409
410 void
411 Export::Stream::write_checksum(const std::string& s)
412 {
413   this->do_write(s.data(), s.length());
414 }
415
416 // Class Stream_to_section.
417
418 Stream_to_section::Stream_to_section()
419   : section_(NULL)
420 {
421 }
422
423 // Write data to a section.
424
425 void
426 Stream_to_section::do_write(const char* bytes, size_t length)
427 {
428   section* sec = (section*) this->section_;
429   if (sec == NULL)
430     {
431       go_assert(targetm.have_named_sections);
432
433       sec = get_section(".go_export", SECTION_DEBUG, NULL);
434       this->section_ = (void*) sec;
435     }
436
437   switch_to_section(sec);
438   assemble_string(bytes, length);
439 }