OSDN Git Service

fbddc0492f62c4b868f18faffc62a0c99a711174
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / gogo-tree.cc
1 // gogo-tree.cc -- convert Go frontend Gogo IR to gcc trees.
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
9 #include <gmp.h>
10
11 #ifndef ENABLE_BUILD_WITH_CXX
12 extern "C"
13 {
14 #endif
15
16 #include "toplev.h"
17 #include "tree.h"
18 #include "gimple.h"
19 #include "tree-iterator.h"
20 #include "cgraph.h"
21 #include "langhooks.h"
22 #include "convert.h"
23 #include "output.h"
24 #include "diagnostic.h"
25
26 #ifndef ENABLE_BUILD_WITH_CXX
27 }
28 #endif
29
30 #include "go-c.h"
31 #include "types.h"
32 #include "expressions.h"
33 #include "statements.h"
34 #include "runtime.h"
35 #include "backend.h"
36 #include "gogo.h"
37
38 // Whether we have seen any errors.
39
40 bool
41 saw_errors()
42 {
43   return errorcount != 0 || sorrycount != 0;
44 }
45
46 // A helper function.
47
48 static inline tree
49 get_identifier_from_string(const std::string& str)
50 {
51   return get_identifier_with_length(str.data(), str.length());
52 }
53
54 // Builtin functions.
55
56 static std::map<std::string, tree> builtin_functions;
57
58 // Define a builtin function.  BCODE is the builtin function code
59 // defined by builtins.def.  NAME is the name of the builtin function.
60 // LIBNAME is the name of the corresponding library function, and is
61 // NULL if there isn't one.  FNTYPE is the type of the function.
62 // CONST_P is true if the function has the const attribute.
63
64 static void
65 define_builtin(built_in_function bcode, const char* name, const char* libname,
66                tree fntype, bool const_p)
67 {
68   tree decl = add_builtin_function(name, fntype, bcode, BUILT_IN_NORMAL,
69                                    libname, NULL_TREE);
70   if (const_p)
71     TREE_READONLY(decl) = 1;
72   built_in_decls[bcode] = decl;
73   implicit_built_in_decls[bcode] = decl;
74   builtin_functions[name] = decl;
75   if (libname != NULL)
76     {
77       decl = add_builtin_function(libname, fntype, bcode, BUILT_IN_NORMAL,
78                                   NULL, NULL_TREE);
79       if (const_p)
80         TREE_READONLY(decl) = 1;
81       builtin_functions[libname] = decl;
82     }
83 }
84
85 // Create trees for implicit builtin functions.
86
87 void
88 Gogo::define_builtin_function_trees()
89 {
90   /* We need to define the fetch_and_add functions, since we use them
91      for ++ and --.  */
92   tree t = go_type_for_size(BITS_PER_UNIT, 1);
93   tree p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
94   define_builtin(BUILT_IN_SYNC_ADD_AND_FETCH_1, "__sync_fetch_and_add_1", NULL,
95                  build_function_type_list(t, p, t, NULL_TREE), false);
96
97   t = go_type_for_size(BITS_PER_UNIT * 2, 1);
98   p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
99   define_builtin (BUILT_IN_SYNC_ADD_AND_FETCH_2, "__sync_fetch_and_add_2", NULL,
100                   build_function_type_list(t, p, t, NULL_TREE), false);
101
102   t = go_type_for_size(BITS_PER_UNIT * 4, 1);
103   p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
104   define_builtin(BUILT_IN_SYNC_ADD_AND_FETCH_4, "__sync_fetch_and_add_4", NULL,
105                  build_function_type_list(t, p, t, NULL_TREE), false);
106
107   t = go_type_for_size(BITS_PER_UNIT * 8, 1);
108   p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
109   define_builtin(BUILT_IN_SYNC_ADD_AND_FETCH_8, "__sync_fetch_and_add_8", NULL,
110                  build_function_type_list(t, p, t, NULL_TREE), false);
111
112   // We use __builtin_expect for magic import functions.
113   define_builtin(BUILT_IN_EXPECT, "__builtin_expect", NULL,
114                  build_function_type_list(long_integer_type_node,
115                                           long_integer_type_node,
116                                           long_integer_type_node,
117                                           NULL_TREE),
118                  true);
119
120   // We use __builtin_memmove for the predeclared copy function.
121   define_builtin(BUILT_IN_MEMMOVE, "__builtin_memmove", "memmove",
122                  build_function_type_list(ptr_type_node,
123                                           ptr_type_node,
124                                           const_ptr_type_node,
125                                           size_type_node,
126                                           NULL_TREE),
127                  false);
128
129   // We provide sqrt for the math library.
130   define_builtin(BUILT_IN_SQRT, "__builtin_sqrt", "sqrt",
131                  build_function_type_list(double_type_node,
132                                           double_type_node,
133                                           NULL_TREE),
134                  true);
135   define_builtin(BUILT_IN_SQRTL, "__builtin_sqrtl", "sqrtl",
136                  build_function_type_list(long_double_type_node,
137                                           long_double_type_node,
138                                           NULL_TREE),
139                  true);
140
141   // We use __builtin_return_address in the thunk we build for
142   // functions which call recover.
143   define_builtin(BUILT_IN_RETURN_ADDRESS, "__builtin_return_address", NULL,
144                  build_function_type_list(ptr_type_node,
145                                           unsigned_type_node,
146                                           NULL_TREE),
147                  false);
148
149   // The compiler uses __builtin_trap for some exception handling
150   // cases.
151   define_builtin(BUILT_IN_TRAP, "__builtin_trap", NULL,
152                  build_function_type(void_type_node, void_list_node),
153                  false);
154 }
155
156 // Get the name to use for the import control function.  If there is a
157 // global function or variable, then we know that that name must be
158 // unique in the link, and we use it as the basis for our name.
159
160 const std::string&
161 Gogo::get_init_fn_name()
162 {
163   if (this->init_fn_name_.empty())
164     {
165       go_assert(this->package_ != NULL);
166       if (this->is_main_package())
167         {
168           // Use a name which the runtime knows.
169           this->init_fn_name_ = "__go_init_main";
170         }
171       else
172         {
173           std::string s = this->unique_prefix();
174           s.append(1, '.');
175           s.append(this->package_name());
176           s.append("..import");
177           this->init_fn_name_ = s;
178         }
179     }
180
181   return this->init_fn_name_;
182 }
183
184 // Add statements to INIT_STMT_LIST which run the initialization
185 // functions for imported packages.  This is only used for the "main"
186 // package.
187
188 void
189 Gogo::init_imports(tree* init_stmt_list)
190 {
191   go_assert(this->is_main_package());
192
193   if (this->imported_init_fns_.empty())
194     return;
195
196   tree fntype = build_function_type(void_type_node, void_list_node);
197
198   // We must call them in increasing priority order.
199   std::vector<Import_init> v;
200   for (std::set<Import_init>::const_iterator p =
201          this->imported_init_fns_.begin();
202        p != this->imported_init_fns_.end();
203        ++p)
204     v.push_back(*p);
205   std::sort(v.begin(), v.end());
206
207   for (std::vector<Import_init>::const_iterator p = v.begin();
208        p != v.end();
209        ++p)
210     {
211       std::string user_name = p->package_name() + ".init";
212       tree decl = build_decl(UNKNOWN_LOCATION, FUNCTION_DECL,
213                              get_identifier_from_string(user_name),
214                              fntype);
215       const std::string& init_name(p->init_name());
216       SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(init_name));
217       TREE_PUBLIC(decl) = 1;
218       DECL_EXTERNAL(decl) = 1;
219       append_to_statement_list(build_call_expr(decl, 0), init_stmt_list);
220     }
221 }
222
223 // Register global variables with the garbage collector.  We need to
224 // register all variables which can hold a pointer value.  They become
225 // roots during the mark phase.  We build a struct that is easy to
226 // hook into a list of roots.
227
228 // struct __go_gc_root_list
229 // {
230 //   struct __go_gc_root_list* __next;
231 //   struct __go_gc_root
232 //   {
233 //     void* __decl;
234 //     size_t __size;
235 //   } __roots[];
236 // };
237
238 // The last entry in the roots array has a NULL decl field.
239
240 void
241 Gogo::register_gc_vars(const std::vector<Named_object*>& var_gc,
242                        tree* init_stmt_list)
243 {
244   if (var_gc.empty())
245     return;
246
247   size_t count = var_gc.size();
248
249   tree root_type = Gogo::builtin_struct(NULL, "__go_gc_root", NULL_TREE, 2,
250                                         "__next",
251                                         ptr_type_node,
252                                         "__size",
253                                         sizetype);
254
255   tree index_type = build_index_type(size_int(count));
256   tree array_type = build_array_type(root_type, index_type);
257
258   tree root_list_type = make_node(RECORD_TYPE);
259   root_list_type = Gogo::builtin_struct(NULL, "__go_gc_root_list",
260                                         root_list_type, 2,
261                                         "__next",
262                                         build_pointer_type(root_list_type),
263                                         "__roots",
264                                         array_type);
265
266   // Build an initialier for the __roots array.
267
268   VEC(constructor_elt,gc)* roots_init = VEC_alloc(constructor_elt, gc,
269                                                   count + 1);
270
271   size_t i = 0;
272   for (std::vector<Named_object*>::const_iterator p = var_gc.begin();
273        p != var_gc.end();
274        ++p, ++i)
275     {
276       VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
277
278       constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
279       tree field = TYPE_FIELDS(root_type);
280       elt->index = field;
281       Bvariable* bvar = (*p)->get_backend_variable(this, NULL);
282       tree decl = var_to_tree(bvar);
283       go_assert(TREE_CODE(decl) == VAR_DECL);
284       elt->value = build_fold_addr_expr(decl);
285
286       elt = VEC_quick_push(constructor_elt, init, NULL);
287       field = DECL_CHAIN(field);
288       elt->index = field;
289       elt->value = DECL_SIZE_UNIT(decl);
290
291       elt = VEC_quick_push(constructor_elt, roots_init, NULL);
292       elt->index = size_int(i);
293       elt->value = build_constructor(root_type, init);
294     }
295
296   // The list ends with a NULL entry.
297
298   VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
299
300   constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
301   tree field = TYPE_FIELDS(root_type);
302   elt->index = field;
303   elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
304
305   elt = VEC_quick_push(constructor_elt, init, NULL);
306   field = DECL_CHAIN(field);
307   elt->index = field;
308   elt->value = size_zero_node;
309
310   elt = VEC_quick_push(constructor_elt, roots_init, NULL);
311   elt->index = size_int(i);
312   elt->value = build_constructor(root_type, init);
313
314   // Build a constructor for the struct.
315
316   VEC(constructor_elt,gc*) root_list_init = VEC_alloc(constructor_elt, gc, 2);
317
318   elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
319   field = TYPE_FIELDS(root_list_type);
320   elt->index = field;
321   elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
322
323   elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
324   field = DECL_CHAIN(field);
325   elt->index = field;
326   elt->value = build_constructor(array_type, roots_init);
327
328   // Build a decl to register.
329
330   tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
331                          create_tmp_var_name("gc"), root_list_type);
332   DECL_EXTERNAL(decl) = 0;
333   TREE_PUBLIC(decl) = 0;
334   TREE_STATIC(decl) = 1;
335   DECL_ARTIFICIAL(decl) = 1;
336   DECL_INITIAL(decl) = build_constructor(root_list_type, root_list_init);
337   rest_of_decl_compilation(decl, 1, 0);
338
339   static tree register_gc_fndecl;
340   tree call = Gogo::call_builtin(&register_gc_fndecl, BUILTINS_LOCATION,
341                                  "__go_register_gc_roots",
342                                  1,
343                                  void_type_node,
344                                  build_pointer_type(root_list_type),
345                                  build_fold_addr_expr(decl));
346   if (call != error_mark_node)
347     append_to_statement_list(call, init_stmt_list);
348 }
349
350 // Build the decl for the initialization function.
351
352 tree
353 Gogo::initialization_function_decl()
354 {
355   // The tedious details of building your own function.  There doesn't
356   // seem to be a helper function for this.
357   std::string name = this->package_name() + ".init";
358   tree fndecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL,
359                            get_identifier_from_string(name),
360                            build_function_type(void_type_node,
361                                                void_list_node));
362   const std::string& asm_name(this->get_init_fn_name());
363   SET_DECL_ASSEMBLER_NAME(fndecl, get_identifier_from_string(asm_name));
364
365   tree resdecl = build_decl(BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
366                             void_type_node);
367   DECL_ARTIFICIAL(resdecl) = 1;
368   DECL_CONTEXT(resdecl) = fndecl;
369   DECL_RESULT(fndecl) = resdecl;
370
371   TREE_STATIC(fndecl) = 1;
372   TREE_USED(fndecl) = 1;
373   DECL_ARTIFICIAL(fndecl) = 1;
374   TREE_PUBLIC(fndecl) = 1;
375
376   DECL_INITIAL(fndecl) = make_node(BLOCK);
377   TREE_USED(DECL_INITIAL(fndecl)) = 1;
378
379   return fndecl;
380 }
381
382 // Create the magic initialization function.  INIT_STMT_LIST is the
383 // code that it needs to run.
384
385 void
386 Gogo::write_initialization_function(tree fndecl, tree init_stmt_list)
387 {
388   // Make sure that we thought we needed an initialization function,
389   // as otherwise we will not have reported it in the export data.
390   go_assert(this->is_main_package() || this->need_init_fn_);
391
392   if (fndecl == NULL_TREE)
393     fndecl = this->initialization_function_decl();
394
395   DECL_SAVED_TREE(fndecl) = init_stmt_list;
396
397   current_function_decl = fndecl;
398   if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
399     push_struct_function(fndecl);
400   else
401     push_cfun(DECL_STRUCT_FUNCTION(fndecl));
402   cfun->function_end_locus = BUILTINS_LOCATION;
403
404   gimplify_function_tree(fndecl);
405
406   cgraph_add_new_function(fndecl, false);
407   cgraph_mark_needed_node(cgraph_get_node(fndecl));
408
409   current_function_decl = NULL_TREE;
410   pop_cfun();
411 }
412
413 // Search for references to VAR in any statements or called functions.
414
415 class Find_var : public Traverse
416 {
417  public:
418   // A hash table we use to avoid looping.  The index is the name of a
419   // named object.  We only look through objects defined in this
420   // package.
421   typedef Unordered_set(std::string) Seen_objects;
422
423   Find_var(Named_object* var, Seen_objects* seen_objects)
424     : Traverse(traverse_expressions),
425       var_(var), seen_objects_(seen_objects), found_(false)
426   { }
427
428   // Whether the variable was found.
429   bool
430   found() const
431   { return this->found_; }
432
433   int
434   expression(Expression**);
435
436  private:
437   // The variable we are looking for.
438   Named_object* var_;
439   // Names of objects we have already seen.
440   Seen_objects* seen_objects_;
441   // True if the variable was found.
442   bool found_;
443 };
444
445 // See if EXPR refers to VAR, looking through function calls and
446 // variable initializations.
447
448 int
449 Find_var::expression(Expression** pexpr)
450 {
451   Expression* e = *pexpr;
452
453   Var_expression* ve = e->var_expression();
454   if (ve != NULL)
455     {
456       Named_object* v = ve->named_object();
457       if (v == this->var_)
458         {
459           this->found_ = true;
460           return TRAVERSE_EXIT;
461         }
462
463       if (v->is_variable() && v->package() == NULL)
464         {
465           Expression* init = v->var_value()->init();
466           if (init != NULL)
467             {
468               std::pair<Seen_objects::iterator, bool> ins =
469                 this->seen_objects_->insert(v->name());
470               if (ins.second)
471                 {
472                   // This is the first time we have seen this name.
473                   if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
474                     return TRAVERSE_EXIT;
475                 }
476             }
477         }
478     }
479
480   // We traverse the code of any function we see.  Note that this
481   // means that we will traverse the code of a function whose address
482   // is taken even if it is not called.
483   Func_expression* fe = e->func_expression();
484   if (fe != NULL)
485     {
486       const Named_object* f = fe->named_object();
487       if (f->is_function() && f->package() == NULL)
488         {
489           std::pair<Seen_objects::iterator, bool> ins =
490             this->seen_objects_->insert(f->name());
491           if (ins.second)
492             {
493               // This is the first time we have seen this name.
494               if (f->func_value()->block()->traverse(this) == TRAVERSE_EXIT)
495                 return TRAVERSE_EXIT;
496             }
497         }
498     }
499
500   return TRAVERSE_CONTINUE;
501 }
502
503 // Return true if EXPR refers to VAR.
504
505 static bool
506 expression_requires(Expression* expr, Block* preinit, Named_object* var)
507 {
508   Find_var::Seen_objects seen_objects;
509   Find_var find_var(var, &seen_objects);
510   if (expr != NULL)
511     Expression::traverse(&expr, &find_var);
512   if (preinit != NULL)
513     preinit->traverse(&find_var);
514   
515   return find_var.found();
516 }
517
518 // Sort variable initializations.  If the initialization expression
519 // for variable A refers directly or indirectly to the initialization
520 // expression for variable B, then we must initialize B before A.
521
522 class Var_init
523 {
524  public:
525   Var_init()
526     : var_(NULL), init_(NULL_TREE), waiting_(0)
527   { }
528
529   Var_init(Named_object* var, tree init)
530     : var_(var), init_(init), waiting_(0)
531   { }
532
533   // Return the variable.
534   Named_object*
535   var() const
536   { return this->var_; }
537
538   // Return the initialization expression.
539   tree
540   init() const
541   { return this->init_; }
542
543   // Return the number of variables waiting for this one to be
544   // initialized.
545   size_t
546   waiting() const
547   { return this->waiting_; }
548
549   // Increment the number waiting.
550   void
551   increment_waiting()
552   { ++this->waiting_; }
553
554  private:
555   // The variable being initialized.
556   Named_object* var_;
557   // The initialization expression to run.
558   tree init_;
559   // The number of variables which are waiting for this one.
560   size_t waiting_;
561 };
562
563 typedef std::list<Var_init> Var_inits;
564
565 // Sort the variable initializations.  The rule we follow is that we
566 // emit them in the order they appear in the array, except that if the
567 // initialization expression for a variable V1 depends upon another
568 // variable V2 then we initialize V1 after V2.
569
570 static void
571 sort_var_inits(Var_inits* var_inits)
572 {
573   Var_inits ready;
574   while (!var_inits->empty())
575     {
576       Var_inits::iterator p1 = var_inits->begin();
577       Named_object* var = p1->var();
578       Expression* init = var->var_value()->init();
579       Block* preinit = var->var_value()->preinit();
580
581       // Start walking through the list to see which variables VAR
582       // needs to wait for.  We can skip P1->WAITING variables--that
583       // is the number we've already checked.
584       Var_inits::iterator p2 = p1;
585       ++p2;
586       for (size_t i = p1->waiting(); i > 0; --i)
587         ++p2;
588
589       for (; p2 != var_inits->end(); ++p2)
590         {
591           if (expression_requires(init, preinit, p2->var()))
592             {
593               // Check for cycles.
594               if (expression_requires(p2->var()->var_value()->init(),
595                                       p2->var()->var_value()->preinit(),
596                                       var))
597                 {
598                   error_at(var->location(),
599                            ("initialization expressions for %qs and "
600                             "%qs depend upon each other"),
601                            var->message_name().c_str(),
602                            p2->var()->message_name().c_str());
603                   inform(p2->var()->location(), "%qs defined here",
604                          p2->var()->message_name().c_str());
605                   p2 = var_inits->end();
606                 }
607               else
608                 {
609                   // We can't emit P1 until P2 is emitted.  Move P1.
610                   // Note that the WAITING loop always executes at
611                   // least once, which is what we want.
612                   p2->increment_waiting();
613                   Var_inits::iterator p3 = p2;
614                   for (size_t i = p2->waiting(); i > 0; --i)
615                     ++p3;
616                   var_inits->splice(p3, *var_inits, p1);
617                 }
618               break;
619             }
620         }
621
622       if (p2 == var_inits->end())
623         {
624           // VAR does not depends upon any other initialization expressions.
625
626           // Check for a loop of VAR on itself.  We only do this if
627           // INIT is not NULL; when INIT is NULL, it means that
628           // PREINIT sets VAR, which we will interpret as a loop.
629           if (init != NULL && expression_requires(init, preinit, var))
630             error_at(var->location(),
631                      "initialization expression for %qs depends upon itself",
632                      var->message_name().c_str());
633           ready.splice(ready.end(), *var_inits, p1);
634         }
635     }
636
637   // Now READY is the list in the desired initialization order.
638   var_inits->swap(ready);
639 }
640
641 // Write out the global definitions.
642
643 void
644 Gogo::write_globals()
645 {
646   this->convert_named_types();
647   this->build_interface_method_tables();
648
649   Bindings* bindings = this->current_bindings();
650   size_t count = bindings->size_definitions();
651
652   tree* vec = new tree[count];
653
654   tree init_fndecl = NULL_TREE;
655   tree init_stmt_list = NULL_TREE;
656
657   if (this->is_main_package())
658     this->init_imports(&init_stmt_list);
659
660   // A list of variable initializations.
661   Var_inits var_inits;
662
663   // A list of variables which need to be registered with the garbage
664   // collector.
665   std::vector<Named_object*> var_gc;
666   var_gc.reserve(count);
667
668   tree var_init_stmt_list = NULL_TREE;
669   size_t i = 0;
670   for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
671        p != bindings->end_definitions();
672        ++p, ++i)
673     {
674       Named_object* no = *p;
675
676       go_assert(!no->is_type_declaration() && !no->is_function_declaration());
677       // There is nothing to do for a package.
678       if (no->is_package())
679         {
680           --i;
681           --count;
682           continue;
683         }
684
685       // There is nothing to do for an object which was imported from
686       // a different package into the global scope.
687       if (no->package() != NULL)
688         {
689           --i;
690           --count;
691           continue;
692         }
693
694       // There is nothing useful we can output for constants which
695       // have ideal or non-integeral type.
696       if (no->is_const())
697         {
698           Type* type = no->const_value()->type();
699           if (type == NULL)
700             type = no->const_value()->expr()->type();
701           if (type->is_abstract() || type->integer_type() == NULL)
702             {
703               --i;
704               --count;
705               continue;
706             }
707         }
708
709       if (!no->is_variable())
710         {
711           vec[i] = no->get_tree(this, NULL);
712           if (vec[i] == error_mark_node)
713             {
714               go_assert(saw_errors());
715               --i;
716               --count;
717               continue;
718             }
719         }
720       else
721         {
722           Bvariable* var = no->get_backend_variable(this, NULL);
723           vec[i] = var_to_tree(var);
724           if (vec[i] == error_mark_node)
725             {
726               go_assert(saw_errors());
727               --i;
728               --count;
729               continue;
730             }
731
732           // Check for a sink variable, which may be used to run an
733           // initializer purely for its side effects.
734           bool is_sink = no->name()[0] == '_' && no->name()[1] == '.';
735
736           tree var_init_tree = NULL_TREE;
737           if (!no->var_value()->has_pre_init())
738             {
739               tree init = no->var_value()->get_init_tree(this, NULL);
740               if (init == error_mark_node)
741                 go_assert(saw_errors());
742               else if (init == NULL_TREE)
743                 ;
744               else if (TREE_CONSTANT(init))
745                 this->backend()->global_variable_set_init(var,
746                                                           tree_to_expr(init));
747               else if (is_sink)
748                 var_init_tree = init;
749               else
750                 var_init_tree = fold_build2_loc(no->location(), MODIFY_EXPR,
751                                                 void_type_node, vec[i], init);
752             }
753           else
754             {
755               // We are going to create temporary variables which
756               // means that we need an fndecl.
757               if (init_fndecl == NULL_TREE)
758                 init_fndecl = this->initialization_function_decl();
759               current_function_decl = init_fndecl;
760               if (DECL_STRUCT_FUNCTION(init_fndecl) == NULL)
761                 push_struct_function(init_fndecl);
762               else
763                 push_cfun(DECL_STRUCT_FUNCTION(init_fndecl));
764
765               tree var_decl = is_sink ? NULL_TREE : vec[i];
766               var_init_tree = no->var_value()->get_init_block(this, NULL,
767                                                               var_decl);
768
769               current_function_decl = NULL_TREE;
770               pop_cfun();
771             }
772
773           if (var_init_tree != NULL_TREE && var_init_tree != error_mark_node)
774             {
775               if (no->var_value()->init() == NULL
776                   && !no->var_value()->has_pre_init())
777                 append_to_statement_list(var_init_tree, &var_init_stmt_list);
778               else
779                 var_inits.push_back(Var_init(no, var_init_tree));
780             }
781
782           if (!is_sink && no->var_value()->type()->has_pointer())
783             var_gc.push_back(no);
784         }
785     }
786
787   // Register global variables with the garbage collector.
788   this->register_gc_vars(var_gc, &init_stmt_list);
789
790   // Simple variable initializations, after all variables are
791   // registered.
792   append_to_statement_list(var_init_stmt_list, &init_stmt_list);
793
794   // Complex variable initializations, first sorting them into a
795   // workable order.
796   if (!var_inits.empty())
797     {
798       sort_var_inits(&var_inits);
799       for (Var_inits::const_iterator p = var_inits.begin();
800            p != var_inits.end();
801            ++p)
802         append_to_statement_list(p->init(), &init_stmt_list);
803     }
804
805   // After all the variables are initialized, call the "init"
806   // functions if there are any.
807   for (std::vector<Named_object*>::const_iterator p =
808          this->init_functions_.begin();
809        p != this->init_functions_.end();
810        ++p)
811     {
812       tree decl = (*p)->get_tree(this, NULL);
813       tree call = build_call_expr(decl, 0);
814       append_to_statement_list(call, &init_stmt_list);
815     }
816
817   // Set up a magic function to do all the initialization actions.
818   // This will be called if this package is imported.
819   if (init_stmt_list != NULL_TREE
820       || this->need_init_fn_
821       || this->is_main_package())
822     this->write_initialization_function(init_fndecl, init_stmt_list);
823
824   // Pass everything back to the middle-end.
825
826   wrapup_global_declarations(vec, count);
827
828   cgraph_finalize_compilation_unit();
829
830   check_global_declarations(vec, count);
831   emit_debug_global_declarations(vec, count);
832
833   delete[] vec;
834 }
835
836 // Get a tree for the identifier for a named object.
837
838 tree
839 Named_object::get_id(Gogo* gogo)
840 {
841   go_assert(!this->is_variable() && !this->is_result_variable());
842   std::string decl_name;
843   if (this->is_function_declaration()
844       && !this->func_declaration_value()->asm_name().empty())
845     decl_name = this->func_declaration_value()->asm_name();
846   else if (this->is_type()
847            && this->type_value()->location() == BUILTINS_LOCATION)
848     {
849       // We don't need the package name for builtin types.
850       decl_name = Gogo::unpack_hidden_name(this->name_);
851     }
852   else
853     {
854       std::string package_name;
855       if (this->package_ == NULL)
856         package_name = gogo->package_name();
857       else
858         package_name = this->package_->name();
859
860       decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
861
862       Function_type* fntype;
863       if (this->is_function())
864         fntype = this->func_value()->type();
865       else if (this->is_function_declaration())
866         fntype = this->func_declaration_value()->type();
867       else
868         fntype = NULL;
869       if (fntype != NULL && fntype->is_method())
870         {
871           decl_name.push_back('.');
872           decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
873         }
874     }
875   if (this->is_type())
876     {
877       const Named_object* in_function = this->type_value()->in_function();
878       if (in_function != NULL)
879         decl_name += '$' + in_function->name();
880     }
881   return get_identifier_from_string(decl_name);
882 }
883
884 // Get a tree for a named object.
885
886 tree
887 Named_object::get_tree(Gogo* gogo, Named_object* function)
888 {
889   if (this->tree_ != NULL_TREE)
890     return this->tree_;
891
892   tree name;
893   if (this->classification_ == NAMED_OBJECT_TYPE)
894     name = NULL_TREE;
895   else
896     name = this->get_id(gogo);
897   tree decl;
898   switch (this->classification_)
899     {
900     case NAMED_OBJECT_CONST:
901       {
902         Named_constant* named_constant = this->u_.const_value;
903         Translate_context subcontext(gogo, function, NULL, NULL);
904         tree expr_tree = named_constant->expr()->get_tree(&subcontext);
905         if (expr_tree == error_mark_node)
906           decl = error_mark_node;
907         else
908           {
909             Type* type = named_constant->type();
910             if (type != NULL && !type->is_abstract())
911               {
912                 if (type->is_error())
913                   expr_tree = error_mark_node;
914                 else
915                   {
916                     Btype* btype = type->get_backend(gogo);
917                     expr_tree = fold_convert(type_to_tree(btype), expr_tree);
918                   }
919               }
920             if (expr_tree == error_mark_node)
921               decl = error_mark_node;
922             else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
923               {
924                 decl = build_decl(named_constant->location(), CONST_DECL,
925                                   name, TREE_TYPE(expr_tree));
926                 DECL_INITIAL(decl) = expr_tree;
927                 TREE_CONSTANT(decl) = 1;
928                 TREE_READONLY(decl) = 1;
929               }
930             else
931               {
932                 // A CONST_DECL is only for an enum constant, so we
933                 // shouldn't use for non-integral types.  Instead we
934                 // just return the constant itself, rather than a
935                 // decl.
936                 decl = expr_tree;
937               }
938           }
939       }
940       break;
941
942     case NAMED_OBJECT_TYPE:
943       {
944         Named_type* named_type = this->u_.type_value;
945         tree type_tree = type_to_tree(named_type->get_backend(gogo));
946         if (type_tree == error_mark_node)
947           decl = error_mark_node;
948         else
949           {
950             decl = TYPE_NAME(type_tree);
951             go_assert(decl != NULL_TREE);
952
953             // We need to produce a type descriptor for every named
954             // type, and for a pointer to every named type, since
955             // other files or packages might refer to them.  We need
956             // to do this even for hidden types, because they might
957             // still be returned by some function.  Simply calling the
958             // type_descriptor method is enough to create the type
959             // descriptor, even though we don't do anything with it.
960             if (this->package_ == NULL)
961               {
962                 named_type->type_descriptor_pointer(gogo, BUILTINS_LOCATION);
963                 Type* pn = Type::make_pointer_type(named_type);
964                 pn->type_descriptor_pointer(gogo, BUILTINS_LOCATION);
965               }
966           }
967       }
968       break;
969
970     case NAMED_OBJECT_TYPE_DECLARATION:
971       error("reference to undefined type %qs",
972             this->message_name().c_str());
973       return error_mark_node;
974
975     case NAMED_OBJECT_VAR:
976     case NAMED_OBJECT_RESULT_VAR:
977     case NAMED_OBJECT_SINK:
978       go_unreachable();
979
980     case NAMED_OBJECT_FUNC:
981       {
982         Function* func = this->u_.func_value;
983         decl = func->get_or_make_decl(gogo, this, name);
984         if (decl != error_mark_node)
985           {
986             if (func->block() != NULL)
987               {
988                 if (DECL_STRUCT_FUNCTION(decl) == NULL)
989                   push_struct_function(decl);
990                 else
991                   push_cfun(DECL_STRUCT_FUNCTION(decl));
992
993                 cfun->function_end_locus = func->block()->end_location();
994
995                 current_function_decl = decl;
996
997                 func->build_tree(gogo, this);
998
999                 gimplify_function_tree(decl);
1000
1001                 cgraph_finalize_function(decl, true);
1002
1003                 current_function_decl = NULL_TREE;
1004                 pop_cfun();
1005               }
1006           }
1007       }
1008       break;
1009
1010     default:
1011       go_unreachable();
1012     }
1013
1014   if (TREE_TYPE(decl) == error_mark_node)
1015     decl = error_mark_node;
1016
1017   tree ret = decl;
1018
1019   this->tree_ = ret;
1020
1021   if (ret != error_mark_node)
1022     go_preserve_from_gc(ret);
1023
1024   return ret;
1025 }
1026
1027 // Get the initial value of a variable as a tree.  This does not
1028 // consider whether the variable is in the heap--it returns the
1029 // initial value as though it were always stored in the stack.
1030
1031 tree
1032 Variable::get_init_tree(Gogo* gogo, Named_object* function)
1033 {
1034   go_assert(this->preinit_ == NULL);
1035   if (this->init_ == NULL)
1036     {
1037       go_assert(!this->is_parameter_);
1038       if (this->is_global_ || this->is_in_heap())
1039         return NULL;
1040       Btype* btype = this->type_->get_backend(gogo);
1041       return expr_to_tree(gogo->backend()->zero_expression(btype));
1042     }
1043   else
1044     {
1045       Translate_context context(gogo, function, NULL, NULL);
1046       tree rhs_tree = this->init_->get_tree(&context);
1047       return Expression::convert_for_assignment(&context, this->type(),
1048                                                 this->init_->type(),
1049                                                 rhs_tree, this->location());
1050     }
1051 }
1052
1053 // Get the initial value of a variable when a block is required.
1054 // VAR_DECL is the decl to set; it may be NULL for a sink variable.
1055
1056 tree
1057 Variable::get_init_block(Gogo* gogo, Named_object* function, tree var_decl)
1058 {
1059   go_assert(this->preinit_ != NULL);
1060
1061   // We want to add the variable assignment to the end of the preinit
1062   // block.  The preinit block may have a TRY_FINALLY_EXPR and a
1063   // TRY_CATCH_EXPR; if it does, we want to add to the end of the
1064   // regular statements.
1065
1066   Translate_context context(gogo, function, NULL, NULL);
1067   Bblock* bblock = this->preinit_->get_backend(&context);
1068   tree block_tree = block_to_tree(bblock);
1069   if (block_tree == error_mark_node)
1070     return error_mark_node;
1071   go_assert(TREE_CODE(block_tree) == BIND_EXPR);
1072   tree statements = BIND_EXPR_BODY(block_tree);
1073   while (statements != NULL_TREE
1074          && (TREE_CODE(statements) == TRY_FINALLY_EXPR
1075              || TREE_CODE(statements) == TRY_CATCH_EXPR))
1076     statements = TREE_OPERAND(statements, 0);
1077
1078   // It's possible to have pre-init statements without an initializer
1079   // if the pre-init statements set the variable.
1080   if (this->init_ != NULL)
1081     {
1082       tree rhs_tree = this->init_->get_tree(&context);
1083       if (rhs_tree == error_mark_node)
1084         return error_mark_node;
1085       if (var_decl == NULL_TREE)
1086         append_to_statement_list(rhs_tree, &statements);
1087       else
1088         {
1089           tree val = Expression::convert_for_assignment(&context, this->type(),
1090                                                         this->init_->type(),
1091                                                         rhs_tree,
1092                                                         this->location());
1093           if (val == error_mark_node)
1094             return error_mark_node;
1095           tree set = fold_build2_loc(this->location(), MODIFY_EXPR,
1096                                      void_type_node, var_decl, val);
1097           append_to_statement_list(set, &statements);
1098         }
1099     }
1100
1101   return block_tree;
1102 }
1103
1104 // Get a tree for a function decl.
1105
1106 tree
1107 Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
1108 {
1109   if (this->fndecl_ == NULL_TREE)
1110     {
1111       tree functype = type_to_tree(this->type_->get_backend(gogo));
1112       if (functype == error_mark_node)
1113         this->fndecl_ = error_mark_node;
1114       else
1115         {
1116           // The type of a function comes back as a pointer, but we
1117           // want the real function type for a function declaration.
1118           go_assert(POINTER_TYPE_P(functype));
1119           functype = TREE_TYPE(functype);
1120           tree decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
1121
1122           this->fndecl_ = decl;
1123
1124           if (no->package() != NULL)
1125             ;
1126           else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
1127             ;
1128           else if (Gogo::unpack_hidden_name(no->name()) == "init"
1129                    && !this->type_->is_method())
1130             ;
1131           else if (Gogo::unpack_hidden_name(no->name()) == "main"
1132                    && gogo->is_main_package())
1133             TREE_PUBLIC(decl) = 1;
1134           // Methods have to be public even if they are hidden because
1135           // they can be pulled into type descriptors when using
1136           // anonymous fields.
1137           else if (!Gogo::is_hidden_name(no->name())
1138                    || this->type_->is_method())
1139             {
1140               TREE_PUBLIC(decl) = 1;
1141               std::string asm_name = gogo->unique_prefix();
1142               asm_name.append(1, '.');
1143               asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
1144               SET_DECL_ASSEMBLER_NAME(decl,
1145                                       get_identifier_from_string(asm_name));
1146             }
1147
1148           // Why do we have to do this in the frontend?
1149           tree restype = TREE_TYPE(functype);
1150           tree resdecl = build_decl(this->location(), RESULT_DECL, NULL_TREE,
1151                                     restype);
1152           DECL_ARTIFICIAL(resdecl) = 1;
1153           DECL_IGNORED_P(resdecl) = 1;
1154           DECL_CONTEXT(resdecl) = decl;
1155           DECL_RESULT(decl) = resdecl;
1156
1157           if (this->enclosing_ != NULL)
1158             DECL_STATIC_CHAIN(decl) = 1;
1159
1160           // If a function calls the predeclared recover function, we
1161           // can't inline it, because recover behaves differently in a
1162           // function passed directly to defer.  If this is a recover
1163           // thunk that we built to test whether a function can be
1164           // recovered, we can't inline it, because that will mess up
1165           // our return address comparison.
1166           if (this->calls_recover_ || this->is_recover_thunk_)
1167             DECL_UNINLINABLE(decl) = 1;
1168
1169           // If this is a thunk created to call a function which calls
1170           // the predeclared recover function, we need to disable
1171           // stack splitting for the thunk.
1172           if (this->is_recover_thunk_)
1173             {
1174               tree attr = get_identifier("__no_split_stack__");
1175               DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
1176             }
1177
1178           go_preserve_from_gc(decl);
1179
1180           if (this->closure_var_ != NULL)
1181             {
1182               push_struct_function(decl);
1183
1184               Bvariable* bvar = this->closure_var_->get_backend_variable(gogo,
1185                                                                          no);
1186               tree closure_decl = var_to_tree(bvar);
1187               if (closure_decl == error_mark_node)
1188                 this->fndecl_ = error_mark_node;
1189               else
1190                 {
1191                   DECL_ARTIFICIAL(closure_decl) = 1;
1192                   DECL_IGNORED_P(closure_decl) = 1;
1193                   TREE_USED(closure_decl) = 1;
1194                   DECL_ARG_TYPE(closure_decl) = TREE_TYPE(closure_decl);
1195                   TREE_READONLY(closure_decl) = 1;
1196
1197                   DECL_STRUCT_FUNCTION(decl)->static_chain_decl = closure_decl;
1198                 }
1199
1200               pop_cfun();
1201             }
1202         }
1203     }
1204   return this->fndecl_;
1205 }
1206
1207 // Get a tree for a function declaration.
1208
1209 tree
1210 Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
1211 {
1212   if (this->fndecl_ == NULL_TREE)
1213     {
1214       // Let Go code use an asm declaration to pick up a builtin
1215       // function.
1216       if (!this->asm_name_.empty())
1217         {
1218           std::map<std::string, tree>::const_iterator p =
1219             builtin_functions.find(this->asm_name_);
1220           if (p != builtin_functions.end())
1221             {
1222               this->fndecl_ = p->second;
1223               return this->fndecl_;
1224             }
1225         }
1226
1227       tree functype = type_to_tree(this->fntype_->get_backend(gogo));
1228       tree decl;
1229       if (functype == error_mark_node)
1230         decl = error_mark_node;
1231       else
1232         {
1233           // The type of a function comes back as a pointer, but we
1234           // want the real function type for a function declaration.
1235           go_assert(POINTER_TYPE_P(functype));
1236           functype = TREE_TYPE(functype);
1237           decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
1238           TREE_PUBLIC(decl) = 1;
1239           DECL_EXTERNAL(decl) = 1;
1240
1241           if (this->asm_name_.empty())
1242             {
1243               std::string asm_name = (no->package() == NULL
1244                                       ? gogo->unique_prefix()
1245                                       : no->package()->unique_prefix());
1246               asm_name.append(1, '.');
1247               asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
1248               SET_DECL_ASSEMBLER_NAME(decl,
1249                                       get_identifier_from_string(asm_name));
1250             }
1251         }
1252       this->fndecl_ = decl;
1253       go_preserve_from_gc(decl);
1254     }
1255   return this->fndecl_;
1256 }
1257
1258 // We always pass the receiver to a method as a pointer.  If the
1259 // receiver is actually declared as a non-pointer type, then we copy
1260 // the value into a local variable, so that it has the right type.  In
1261 // this function we create the real PARM_DECL to use, and set
1262 // DEC_INITIAL of the var_decl to be the value passed in.
1263
1264 tree
1265 Function::make_receiver_parm_decl(Gogo* gogo, Named_object* no, tree var_decl)
1266 {
1267   if (var_decl == error_mark_node)
1268     return error_mark_node;
1269   go_assert(TREE_CODE(var_decl) == VAR_DECL);
1270   tree val_type = TREE_TYPE(var_decl);
1271   bool is_in_heap = no->var_value()->is_in_heap();
1272   if (is_in_heap)
1273     {
1274       go_assert(POINTER_TYPE_P(val_type));
1275       val_type = TREE_TYPE(val_type);
1276     }
1277
1278   source_location loc = DECL_SOURCE_LOCATION(var_decl);
1279   std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
1280   name += ".pointer";
1281   tree id = get_identifier_from_string(name);
1282   tree parm_decl = build_decl(loc, PARM_DECL, id, build_pointer_type(val_type));
1283   DECL_CONTEXT(parm_decl) = current_function_decl;
1284   DECL_ARG_TYPE(parm_decl) = TREE_TYPE(parm_decl);
1285
1286   go_assert(DECL_INITIAL(var_decl) == NULL_TREE);
1287   tree init = build_fold_indirect_ref_loc(loc, parm_decl);
1288
1289   if (is_in_heap)
1290     {
1291       tree size = TYPE_SIZE_UNIT(val_type);
1292       tree space = gogo->allocate_memory(no->var_value()->type(), size,
1293                                          no->location());
1294       space = save_expr(space);
1295       space = fold_convert(build_pointer_type(val_type), space);
1296       tree spaceref = build_fold_indirect_ref_loc(no->location(), space);
1297       TREE_THIS_NOTRAP(spaceref) = 1;
1298       tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
1299                                  spaceref, init);
1300       init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space), set, space);
1301     }
1302
1303   DECL_INITIAL(var_decl) = init;
1304
1305   return parm_decl;
1306 }
1307
1308 // If we take the address of a parameter, then we need to copy it into
1309 // the heap.  We will access it as a local variable via an
1310 // indirection.
1311
1312 tree
1313 Function::copy_parm_to_heap(Gogo* gogo, Named_object* no, tree var_decl)
1314 {
1315   if (var_decl == error_mark_node)
1316     return error_mark_node;
1317   go_assert(TREE_CODE(var_decl) == VAR_DECL);
1318   source_location loc = DECL_SOURCE_LOCATION(var_decl);
1319
1320   std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
1321   name += ".param";
1322   tree id = get_identifier_from_string(name);
1323
1324   tree type = TREE_TYPE(var_decl);
1325   go_assert(POINTER_TYPE_P(type));
1326   type = TREE_TYPE(type);
1327
1328   tree parm_decl = build_decl(loc, PARM_DECL, id, type);
1329   DECL_CONTEXT(parm_decl) = current_function_decl;
1330   DECL_ARG_TYPE(parm_decl) = type;
1331
1332   tree size = TYPE_SIZE_UNIT(type);
1333   tree space = gogo->allocate_memory(no->var_value()->type(), size, loc);
1334   space = save_expr(space);
1335   space = fold_convert(TREE_TYPE(var_decl), space);
1336   tree spaceref = build_fold_indirect_ref_loc(loc, space);
1337   TREE_THIS_NOTRAP(spaceref) = 1;
1338   tree init = build2(COMPOUND_EXPR, TREE_TYPE(space),
1339                      build2(MODIFY_EXPR, void_type_node, spaceref, parm_decl),
1340                      space);
1341   DECL_INITIAL(var_decl) = init;
1342
1343   return parm_decl;
1344 }
1345
1346 // Get a tree for function code.
1347
1348 void
1349 Function::build_tree(Gogo* gogo, Named_object* named_function)
1350 {
1351   tree fndecl = this->fndecl_;
1352   go_assert(fndecl != NULL_TREE);
1353
1354   tree params = NULL_TREE;
1355   tree* pp = &params;
1356
1357   tree declare_vars = NULL_TREE;
1358   for (Bindings::const_definitions_iterator p =
1359          this->block_->bindings()->begin_definitions();
1360        p != this->block_->bindings()->end_definitions();
1361        ++p)
1362     {
1363       if ((*p)->is_variable() && (*p)->var_value()->is_parameter())
1364         {
1365           Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
1366           *pp = var_to_tree(bvar);
1367
1368           // We always pass the receiver to a method as a pointer.  If
1369           // the receiver is declared as a non-pointer type, then we
1370           // copy the value into a local variable.
1371           if ((*p)->var_value()->is_receiver()
1372               && (*p)->var_value()->type()->points_to() == NULL)
1373             {
1374               tree parm_decl = this->make_receiver_parm_decl(gogo, *p, *pp);
1375               tree var = *pp;
1376               if (var != error_mark_node)
1377                 {
1378                   go_assert(TREE_CODE(var) == VAR_DECL);
1379                   DECL_CHAIN(var) = declare_vars;
1380                   declare_vars = var;
1381                 }
1382               *pp = parm_decl;
1383             }
1384           else if ((*p)->var_value()->is_in_heap())
1385             {
1386               // If we take the address of a parameter, then we need
1387               // to copy it into the heap.
1388               tree parm_decl = this->copy_parm_to_heap(gogo, *p, *pp);
1389               tree var = *pp;
1390               if (var != error_mark_node)
1391                 {
1392                   go_assert(TREE_CODE(var) == VAR_DECL);
1393                   DECL_CHAIN(var) = declare_vars;
1394                   declare_vars = var;
1395                 }
1396               *pp = parm_decl;
1397             }
1398
1399           if (*pp != error_mark_node)
1400             {
1401               go_assert(TREE_CODE(*pp) == PARM_DECL);
1402               pp = &DECL_CHAIN(*pp);
1403             }
1404         }
1405       else if ((*p)->is_result_variable())
1406         {
1407           Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
1408           tree var_decl = var_to_tree(bvar);
1409
1410           Type* type = (*p)->result_var_value()->type();
1411           tree init;
1412           if (!(*p)->result_var_value()->is_in_heap())
1413             {
1414               Btype* btype = type->get_backend(gogo);
1415               init = expr_to_tree(gogo->backend()->zero_expression(btype));
1416             }
1417           else
1418             {
1419               source_location loc = (*p)->location();
1420               tree type_tree = type_to_tree(type->get_backend(gogo));
1421               tree space = gogo->allocate_memory(type,
1422                                                  TYPE_SIZE_UNIT(type_tree),
1423                                                  loc);
1424               tree ptr_type_tree = build_pointer_type(type_tree);
1425               init = fold_convert_loc(loc, ptr_type_tree, space);
1426             }
1427
1428           if (var_decl != error_mark_node)
1429             {
1430               go_assert(TREE_CODE(var_decl) == VAR_DECL);
1431               DECL_INITIAL(var_decl) = init;
1432               DECL_CHAIN(var_decl) = declare_vars;
1433               declare_vars = var_decl;
1434             }
1435         }
1436     }
1437   *pp = NULL_TREE;
1438
1439   DECL_ARGUMENTS(fndecl) = params;
1440
1441   if (this->block_ != NULL)
1442     {
1443       go_assert(DECL_INITIAL(fndecl) == NULL_TREE);
1444
1445       // Declare variables if necessary.
1446       tree bind = NULL_TREE;
1447       tree defer_init = NULL_TREE;
1448       if (declare_vars != NULL_TREE || this->defer_stack_ != NULL)
1449         {
1450           tree block = make_node(BLOCK);
1451           BLOCK_SUPERCONTEXT(block) = fndecl;
1452           DECL_INITIAL(fndecl) = block;
1453           BLOCK_VARS(block) = declare_vars;
1454           TREE_USED(block) = 1;
1455
1456           bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block),
1457                         NULL_TREE, block);
1458           TREE_SIDE_EFFECTS(bind) = 1;
1459
1460           if (this->defer_stack_ != NULL)
1461             {
1462               Translate_context dcontext(gogo, named_function, this->block_,
1463                                          tree_to_block(bind));
1464               Bstatement* bdi = this->defer_stack_->get_backend(&dcontext);
1465               defer_init = stat_to_tree(bdi);
1466             }
1467         }
1468
1469       // Build the trees for all the statements in the function.
1470       Translate_context context(gogo, named_function, NULL, NULL);
1471       Bblock* bblock = this->block_->get_backend(&context);
1472       tree code = block_to_tree(bblock);
1473
1474       tree init = NULL_TREE;
1475       tree except = NULL_TREE;
1476       tree fini = NULL_TREE;
1477
1478       // Initialize variables if necessary.
1479       for (tree v = declare_vars; v != NULL_TREE; v = DECL_CHAIN(v))
1480         {
1481           tree dv = build1(DECL_EXPR, void_type_node, v);
1482           SET_EXPR_LOCATION(dv, DECL_SOURCE_LOCATION(v));
1483           append_to_statement_list(dv, &init);
1484         }
1485
1486       // If we have a defer stack, initialize it at the start of a
1487       // function.
1488       if (defer_init != NULL_TREE && defer_init != error_mark_node)
1489         {
1490           SET_EXPR_LOCATION(defer_init, this->block_->start_location());
1491           append_to_statement_list(defer_init, &init);
1492
1493           // Clean up the defer stack when we leave the function.
1494           this->build_defer_wrapper(gogo, named_function, &except, &fini);
1495         }
1496
1497       if (code != NULL_TREE && code != error_mark_node)
1498         {
1499           if (init != NULL_TREE)
1500             code = build2(COMPOUND_EXPR, void_type_node, init, code);
1501           if (except != NULL_TREE)
1502             code = build2(TRY_CATCH_EXPR, void_type_node, code,
1503                           build2(CATCH_EXPR, void_type_node, NULL, except));
1504           if (fini != NULL_TREE)
1505             code = build2(TRY_FINALLY_EXPR, void_type_node, code, fini);
1506         }
1507
1508       // Stick the code into the block we built for the receiver, if
1509       // we built on.
1510       if (bind != NULL_TREE && code != NULL_TREE && code != error_mark_node)
1511         {
1512           BIND_EXPR_BODY(bind) = code;
1513           code = bind;
1514         }
1515
1516       DECL_SAVED_TREE(fndecl) = code;
1517     }
1518 }
1519
1520 // Build the wrappers around function code needed if the function has
1521 // any defer statements.  This sets *EXCEPT to an exception handler
1522 // and *FINI to a finally handler.
1523
1524 void
1525 Function::build_defer_wrapper(Gogo* gogo, Named_object* named_function,
1526                               tree *except, tree *fini)
1527 {
1528   source_location end_loc = this->block_->end_location();
1529
1530   // Add an exception handler.  This is used if a panic occurs.  Its
1531   // purpose is to stop the stack unwinding if a deferred function
1532   // calls recover.  There are more details in
1533   // libgo/runtime/go-unwind.c.
1534
1535   tree stmt_list = NULL_TREE;
1536
1537   Expression* call = Runtime::make_call(Runtime::CHECK_DEFER, end_loc, 1,
1538                                         this->defer_stack(end_loc));
1539   Translate_context context(gogo, named_function, NULL, NULL);
1540   tree call_tree = call->get_tree(&context);
1541   if (call_tree != error_mark_node)
1542     append_to_statement_list(call_tree, &stmt_list);
1543
1544   tree retval = this->return_value(gogo, named_function, end_loc, &stmt_list);
1545   tree set;
1546   if (retval == NULL_TREE)
1547     set = NULL_TREE;
1548   else
1549     set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
1550                           DECL_RESULT(this->fndecl_), retval);
1551   tree ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
1552   append_to_statement_list(ret_stmt, &stmt_list);
1553
1554   go_assert(*except == NULL_TREE);
1555   *except = stmt_list;
1556
1557   // Add some finally code to run the defer functions.  This is used
1558   // both in the normal case, when no panic occurs, and also if a
1559   // panic occurs to run any further defer functions.  Of course, it
1560   // is possible for a defer function to call panic which should be
1561   // caught by another defer function.  To handle that we use a loop.
1562   //  finish:
1563   //   try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
1564   //   if (return values are named) return named_vals;
1565
1566   stmt_list = NULL;
1567
1568   tree label = create_artificial_label(end_loc);
1569   tree define_label = fold_build1_loc(end_loc, LABEL_EXPR, void_type_node,
1570                                       label);
1571   append_to_statement_list(define_label, &stmt_list);
1572
1573   call = Runtime::make_call(Runtime::UNDEFER, end_loc, 1,
1574                             this->defer_stack(end_loc));
1575   tree undefer = call->get_tree(&context);
1576
1577   call = Runtime::make_call(Runtime::CHECK_DEFER, end_loc, 1,
1578                             this->defer_stack(end_loc));
1579   tree defer = call->get_tree(&context);
1580
1581   if (undefer == error_mark_node || defer == error_mark_node)
1582     return;
1583
1584   tree jump = fold_build1_loc(end_loc, GOTO_EXPR, void_type_node, label);
1585   tree catch_body = build2(COMPOUND_EXPR, void_type_node, defer, jump);
1586   catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
1587   tree try_catch = build2(TRY_CATCH_EXPR, void_type_node, undefer, catch_body);
1588
1589   append_to_statement_list(try_catch, &stmt_list);
1590
1591   if (this->type_->results() != NULL
1592       && !this->type_->results()->empty()
1593       && !this->type_->results()->front().name().empty())
1594     {
1595       // If the result variables are named, we need to return them
1596       // again, because they might have been changed by a defer
1597       // function.
1598       retval = this->return_value(gogo, named_function, end_loc,
1599                                   &stmt_list);
1600       set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
1601                             DECL_RESULT(this->fndecl_), retval);
1602       ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
1603       append_to_statement_list(ret_stmt, &stmt_list);
1604     }
1605   
1606   go_assert(*fini == NULL_TREE);
1607   *fini = stmt_list;
1608 }
1609
1610 // Return the value to assign to DECL_RESULT(this->fndecl_).  This may
1611 // also add statements to STMT_LIST, which need to be executed before
1612 // the assignment.  This is used for a return statement with no
1613 // explicit values.
1614
1615 tree
1616 Function::return_value(Gogo* gogo, Named_object* named_function,
1617                        source_location location, tree* stmt_list) const
1618 {
1619   const Typed_identifier_list* results = this->type_->results();
1620   if (results == NULL || results->empty())
1621     return NULL_TREE;
1622
1623   go_assert(this->results_ != NULL);
1624   if (this->results_->size() != results->size())
1625     {
1626       go_assert(saw_errors());
1627       return error_mark_node;
1628     }
1629
1630   tree retval;
1631   if (results->size() == 1)
1632     {
1633       Bvariable* bvar =
1634         this->results_->front()->get_backend_variable(gogo,
1635                                                       named_function);
1636       tree ret = var_to_tree(bvar);
1637       if (this->results_->front()->result_var_value()->is_in_heap())
1638         ret = build_fold_indirect_ref_loc(location, ret);
1639       return ret;
1640     }
1641   else
1642     {
1643       tree rettype = TREE_TYPE(DECL_RESULT(this->fndecl_));
1644       retval = create_tmp_var(rettype, "RESULT");
1645       tree field = TYPE_FIELDS(rettype);
1646       int index = 0;
1647       for (Typed_identifier_list::const_iterator pr = results->begin();
1648            pr != results->end();
1649            ++pr, ++index, field = DECL_CHAIN(field))
1650         {
1651           go_assert(field != NULL);
1652           Named_object* no = (*this->results_)[index];
1653           Bvariable* bvar = no->get_backend_variable(gogo, named_function);
1654           tree val = var_to_tree(bvar);
1655           if (no->result_var_value()->is_in_heap())
1656             val = build_fold_indirect_ref_loc(location, val);
1657           tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
1658                                      build3(COMPONENT_REF, TREE_TYPE(field),
1659                                             retval, field, NULL_TREE),
1660                                      val);
1661           append_to_statement_list(set, stmt_list);
1662         }
1663       return retval;
1664     }
1665 }
1666
1667 // Return the integer type to use for a size.
1668
1669 GO_EXTERN_C
1670 tree
1671 go_type_for_size(unsigned int bits, int unsignedp)
1672 {
1673   const char* name;
1674   switch (bits)
1675     {
1676     case 8:
1677       name = unsignedp ? "uint8" : "int8";
1678       break;
1679     case 16:
1680       name = unsignedp ? "uint16" : "int16";
1681       break;
1682     case 32:
1683       name = unsignedp ? "uint32" : "int32";
1684       break;
1685     case 64:
1686       name = unsignedp ? "uint64" : "int64";
1687       break;
1688     default:
1689       if (bits == POINTER_SIZE && unsignedp)
1690         name = "uintptr";
1691       else
1692         return NULL_TREE;
1693     }
1694   Type* type = Type::lookup_integer_type(name);
1695   return type_to_tree(type->get_backend(go_get_gogo()));
1696 }
1697
1698 // Return the type to use for a mode.
1699
1700 GO_EXTERN_C
1701 tree
1702 go_type_for_mode(enum machine_mode mode, int unsignedp)
1703 {
1704   // FIXME: This static_cast should be in machmode.h.
1705   enum mode_class mc = static_cast<enum mode_class>(GET_MODE_CLASS(mode));
1706   if (mc == MODE_INT)
1707     return go_type_for_size(GET_MODE_BITSIZE(mode), unsignedp);
1708   else if (mc == MODE_FLOAT)
1709     {
1710       Type* type;
1711       switch (GET_MODE_BITSIZE (mode))
1712         {
1713         case 32:
1714           type = Type::lookup_float_type("float32");
1715           break;
1716         case 64:
1717           type = Type::lookup_float_type("float64");
1718           break;
1719         default:
1720           // We have to check for long double in order to support
1721           // i386 excess precision.
1722           if (mode == TYPE_MODE(long_double_type_node))
1723             return long_double_type_node;
1724           return NULL_TREE;
1725         }
1726       return type_to_tree(type->get_backend(go_get_gogo()));
1727     }
1728   else if (mc == MODE_COMPLEX_FLOAT)
1729     {
1730       Type *type;
1731       switch (GET_MODE_BITSIZE (mode))
1732         {
1733         case 64:
1734           type = Type::lookup_complex_type("complex64");
1735           break;
1736         case 128:
1737           type = Type::lookup_complex_type("complex128");
1738           break;
1739         default:
1740           // We have to check for long double in order to support
1741           // i386 excess precision.
1742           if (mode == TYPE_MODE(complex_long_double_type_node))
1743             return complex_long_double_type_node;
1744           return NULL_TREE;
1745         }
1746       return type_to_tree(type->get_backend(go_get_gogo()));
1747     }
1748   else
1749     return NULL_TREE;
1750 }
1751
1752 // Return a tree which allocates SIZE bytes which will holds value of
1753 // type TYPE.
1754
1755 tree
1756 Gogo::allocate_memory(Type* type, tree size, source_location location)
1757 {
1758   // If the package imports unsafe, then it may play games with
1759   // pointers that look like integers.
1760   if (this->imported_unsafe_ || type->has_pointer())
1761     {
1762       static tree new_fndecl;
1763       return Gogo::call_builtin(&new_fndecl,
1764                                 location,
1765                                 "__go_new",
1766                                 1,
1767                                 ptr_type_node,
1768                                 sizetype,
1769                                 size);
1770     }
1771   else
1772     {
1773       static tree new_nopointers_fndecl;
1774       return Gogo::call_builtin(&new_nopointers_fndecl,
1775                                 location,
1776                                 "__go_new_nopointers",
1777                                 1,
1778                                 ptr_type_node,
1779                                 sizetype,
1780                                 size);
1781     }
1782 }
1783
1784 // Build a builtin struct with a list of fields.  The name is
1785 // STRUCT_NAME.  STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
1786 // node; this exists so that the struct can have fields which point to
1787 // itself.  If PTYPE is not NULL, store the result in *PTYPE.  There
1788 // are NFIELDS fields.  Each field is a name (a const char*) followed
1789 // by a type (a tree).
1790
1791 tree
1792 Gogo::builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
1793                      int nfields, ...)
1794 {
1795   if (ptype != NULL && *ptype != NULL_TREE)
1796     return *ptype;
1797
1798   va_list ap;
1799   va_start(ap, nfields);
1800
1801   tree fields = NULL_TREE;
1802   for (int i = 0; i < nfields; ++i)
1803     {
1804       const char* field_name = va_arg(ap, const char*);
1805       tree type = va_arg(ap, tree);
1806       if (type == error_mark_node)
1807         {
1808           if (ptype != NULL)
1809             *ptype = error_mark_node;
1810           return error_mark_node;
1811         }
1812       tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL,
1813                               get_identifier(field_name), type);
1814       DECL_CHAIN(field) = fields;
1815       fields = field;
1816     }
1817
1818   va_end(ap);
1819
1820   if (struct_type == NULL_TREE)
1821     struct_type = make_node(RECORD_TYPE);
1822   finish_builtin_struct(struct_type, struct_name, fields, NULL_TREE);
1823
1824   if (ptype != NULL)
1825     {
1826       go_preserve_from_gc(struct_type);
1827       *ptype = struct_type;
1828     }
1829
1830   return struct_type;
1831 }
1832
1833 // Return a type to use for pointer to const char for a string.
1834
1835 tree
1836 Gogo::const_char_pointer_type_tree()
1837 {
1838   static tree type;
1839   if (type == NULL_TREE)
1840     {
1841       tree const_char_type = build_qualified_type(unsigned_char_type_node,
1842                                                   TYPE_QUAL_CONST);
1843       type = build_pointer_type(const_char_type);
1844       go_preserve_from_gc(type);
1845     }
1846   return type;
1847 }
1848
1849 // Return a tree for a string constant.
1850
1851 tree
1852 Gogo::string_constant_tree(const std::string& val)
1853 {
1854   tree index_type = build_index_type(size_int(val.length()));
1855   tree const_char_type = build_qualified_type(unsigned_char_type_node,
1856                                               TYPE_QUAL_CONST);
1857   tree string_type = build_array_type(const_char_type, index_type);
1858   string_type = build_variant_type_copy(string_type);
1859   TYPE_STRING_FLAG(string_type) = 1;
1860   tree string_val = build_string(val.length(), val.data());
1861   TREE_TYPE(string_val) = string_type;
1862   return string_val;
1863 }
1864
1865 // Return a tree for a Go string constant.
1866
1867 tree
1868 Gogo::go_string_constant_tree(const std::string& val)
1869 {
1870   tree string_type = type_to_tree(Type::make_string_type()->get_backend(this));
1871
1872   VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
1873
1874   constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
1875   tree field = TYPE_FIELDS(string_type);
1876   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__data") == 0);
1877   elt->index = field;
1878   tree str = Gogo::string_constant_tree(val);
1879   elt->value = fold_convert(TREE_TYPE(field),
1880                             build_fold_addr_expr(str));
1881
1882   elt = VEC_quick_push(constructor_elt, init, NULL);
1883   field = DECL_CHAIN(field);
1884   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__length") == 0);
1885   elt->index = field;
1886   elt->value = build_int_cst_type(TREE_TYPE(field), val.length());
1887
1888   tree constructor = build_constructor(string_type, init);
1889   TREE_READONLY(constructor) = 1;
1890   TREE_CONSTANT(constructor) = 1;
1891
1892   return constructor;
1893 }
1894
1895 // Return a tree for a pointer to a Go string constant.  This is only
1896 // used for type descriptors, so we return a pointer to a constant
1897 // decl.
1898
1899 tree
1900 Gogo::ptr_go_string_constant_tree(const std::string& val)
1901 {
1902   tree pval = this->go_string_constant_tree(val);
1903
1904   tree decl = build_decl(UNKNOWN_LOCATION, VAR_DECL,
1905                          create_tmp_var_name("SP"), TREE_TYPE(pval));
1906   DECL_EXTERNAL(decl) = 0;
1907   TREE_PUBLIC(decl) = 0;
1908   TREE_USED(decl) = 1;
1909   TREE_READONLY(decl) = 1;
1910   TREE_CONSTANT(decl) = 1;
1911   TREE_STATIC(decl) = 1;
1912   DECL_ARTIFICIAL(decl) = 1;
1913   DECL_INITIAL(decl) = pval;
1914   rest_of_decl_compilation(decl, 1, 0);
1915
1916   return build_fold_addr_expr(decl);
1917 }
1918
1919 // Build a constructor for a slice.  SLICE_TYPE_TREE is the type of
1920 // the slice.  VALUES is the value pointer and COUNT is the number of
1921 // entries.  If CAPACITY is not NULL, it is the capacity; otherwise
1922 // the capacity and the count are the same.
1923
1924 tree
1925 Gogo::slice_constructor(tree slice_type_tree, tree values, tree count,
1926                         tree capacity)
1927 {
1928   go_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE);
1929
1930   VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
1931
1932   tree field = TYPE_FIELDS(slice_type_tree);
1933   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
1934   constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
1935   elt->index = field;
1936   go_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field))
1937              == TYPE_MAIN_VARIANT(TREE_TYPE(values)));
1938   elt->value = values;
1939
1940   count = fold_convert(sizetype, count);
1941   if (capacity == NULL_TREE)
1942     {
1943       count = save_expr(count);
1944       capacity = count;
1945     }
1946
1947   field = DECL_CHAIN(field);
1948   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
1949   elt = VEC_quick_push(constructor_elt, init, NULL);
1950   elt->index = field;
1951   elt->value = fold_convert(TREE_TYPE(field), count);
1952
1953   field = DECL_CHAIN(field);
1954   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
1955   elt = VEC_quick_push(constructor_elt, init, NULL);
1956   elt->index = field;
1957   elt->value = fold_convert(TREE_TYPE(field), capacity);
1958
1959   return build_constructor(slice_type_tree, init);
1960 }
1961
1962 // Build an interface method table for a type: a list of function
1963 // pointers, one for each interface method.  This is used for
1964 // interfaces.
1965
1966 tree
1967 Gogo::interface_method_table_for_type(const Interface_type* interface,
1968                                       Named_type* type,
1969                                       bool is_pointer)
1970 {
1971   const Typed_identifier_list* interface_methods = interface->methods();
1972   go_assert(!interface_methods->empty());
1973
1974   std::string mangled_name = ((is_pointer ? "__go_pimt__" : "__go_imt_")
1975                               + interface->mangled_name(this)
1976                               + "__"
1977                               + type->mangled_name(this));
1978
1979   tree id = get_identifier_from_string(mangled_name);
1980
1981   // See whether this interface has any hidden methods.
1982   bool has_hidden_methods = false;
1983   for (Typed_identifier_list::const_iterator p = interface_methods->begin();
1984        p != interface_methods->end();
1985        ++p)
1986     {
1987       if (Gogo::is_hidden_name(p->name()))
1988         {
1989           has_hidden_methods = true;
1990           break;
1991         }
1992     }
1993
1994   // We already know that the named type is convertible to the
1995   // interface.  If the interface has hidden methods, and the named
1996   // type is defined in a different package, then the interface
1997   // conversion table will be defined by that other package.
1998   if (has_hidden_methods && type->named_object()->package() != NULL)
1999     {
2000       tree array_type = build_array_type(const_ptr_type_node, NULL);
2001       tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
2002       TREE_READONLY(decl) = 1;
2003       TREE_CONSTANT(decl) = 1;
2004       TREE_PUBLIC(decl) = 1;
2005       DECL_EXTERNAL(decl) = 1;
2006       go_preserve_from_gc(decl);
2007       return decl;
2008     }
2009
2010   size_t count = interface_methods->size();
2011   VEC(constructor_elt, gc)* pointers = VEC_alloc(constructor_elt, gc,
2012                                                  count + 1);
2013
2014   // The first element is the type descriptor.
2015   constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, NULL);
2016   elt->index = size_zero_node;
2017   Type* td_type;
2018   if (!is_pointer)
2019     td_type = type;
2020   else
2021     td_type = Type::make_pointer_type(type);
2022   tree tdp = td_type->type_descriptor_pointer(this, BUILTINS_LOCATION);
2023   elt->value = fold_convert(const_ptr_type_node, tdp);
2024
2025   size_t i = 1;
2026   for (Typed_identifier_list::const_iterator p = interface_methods->begin();
2027        p != interface_methods->end();
2028        ++p, ++i)
2029     {
2030       bool is_ambiguous;
2031       Method* m = type->method_function(p->name(), &is_ambiguous);
2032       go_assert(m != NULL);
2033
2034       Named_object* no = m->named_object();
2035
2036       tree fnid = no->get_id(this);
2037
2038       tree fndecl;
2039       if (no->is_function())
2040         fndecl = no->func_value()->get_or_make_decl(this, no, fnid);
2041       else if (no->is_function_declaration())
2042         fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
2043                                                                 fnid);
2044       else
2045         go_unreachable();
2046       fndecl = build_fold_addr_expr(fndecl);
2047
2048       elt = VEC_quick_push(constructor_elt, pointers, NULL);
2049       elt->index = size_int(i);
2050       elt->value = fold_convert(const_ptr_type_node, fndecl);
2051     }
2052   go_assert(i == count + 1);
2053
2054   tree array_type = build_array_type(const_ptr_type_node,
2055                                      build_index_type(size_int(count)));
2056   tree constructor = build_constructor(array_type, pointers);
2057
2058   tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
2059   TREE_STATIC(decl) = 1;
2060   TREE_USED(decl) = 1;
2061   TREE_READONLY(decl) = 1;
2062   TREE_CONSTANT(decl) = 1;
2063   DECL_INITIAL(decl) = constructor;
2064
2065   // If the interface type has hidden methods, then this is the only
2066   // definition of the table.  Otherwise it is a comdat table which
2067   // may be defined in multiple packages.
2068   if (has_hidden_methods)
2069     TREE_PUBLIC(decl) = 1;
2070   else
2071     {
2072       make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
2073       resolve_unique_section(decl, 1, 0);
2074     }
2075
2076   rest_of_decl_compilation(decl, 1, 0);
2077
2078   go_preserve_from_gc(decl);
2079
2080   return decl;
2081 }
2082
2083 // Mark a function as a builtin library function.
2084
2085 void
2086 Gogo::mark_fndecl_as_builtin_library(tree fndecl)
2087 {
2088   DECL_EXTERNAL(fndecl) = 1;
2089   TREE_PUBLIC(fndecl) = 1;
2090   DECL_ARTIFICIAL(fndecl) = 1;
2091   TREE_NOTHROW(fndecl) = 1;
2092   DECL_VISIBILITY(fndecl) = VISIBILITY_DEFAULT;
2093   DECL_VISIBILITY_SPECIFIED(fndecl) = 1;
2094 }
2095
2096 // Build a call to a builtin function.
2097
2098 tree
2099 Gogo::call_builtin(tree* pdecl, source_location location, const char* name,
2100                    int nargs, tree rettype, ...)
2101 {
2102   if (rettype == error_mark_node)
2103     return error_mark_node;
2104
2105   tree* types = new tree[nargs];
2106   tree* args = new tree[nargs];
2107
2108   va_list ap;
2109   va_start(ap, rettype);
2110   for (int i = 0; i < nargs; ++i)
2111     {
2112       types[i] = va_arg(ap, tree);
2113       args[i] = va_arg(ap, tree);
2114       if (types[i] == error_mark_node || args[i] == error_mark_node)
2115         {
2116           delete[] types;
2117           delete[] args;
2118           return error_mark_node;
2119         }
2120     }
2121   va_end(ap);
2122
2123   if (*pdecl == NULL_TREE)
2124     {
2125       tree fnid = get_identifier(name);
2126
2127       tree argtypes = NULL_TREE;
2128       tree* pp = &argtypes;
2129       for (int i = 0; i < nargs; ++i)
2130         {
2131           *pp = tree_cons(NULL_TREE, types[i], NULL_TREE);
2132           pp = &TREE_CHAIN(*pp);
2133         }
2134       *pp = void_list_node;
2135
2136       tree fntype = build_function_type(rettype, argtypes);
2137
2138       *pdecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL, fnid, fntype);
2139       Gogo::mark_fndecl_as_builtin_library(*pdecl);
2140       go_preserve_from_gc(*pdecl);
2141     }
2142
2143   tree fnptr = build_fold_addr_expr(*pdecl);
2144   if (CAN_HAVE_LOCATION_P(fnptr))
2145     SET_EXPR_LOCATION(fnptr, location);
2146
2147   tree ret = build_call_array(rettype, fnptr, nargs, args);
2148   SET_EXPR_LOCATION(ret, location);
2149
2150   delete[] types;
2151   delete[] args;
2152
2153   return ret;
2154 }
2155
2156 // Build a call to the runtime error function.
2157
2158 tree
2159 Gogo::runtime_error(int code, source_location location)
2160 {
2161   static tree runtime_error_fndecl;
2162   tree ret = Gogo::call_builtin(&runtime_error_fndecl,
2163                                 location,
2164                                 "__go_runtime_error",
2165                                 1,
2166                                 void_type_node,
2167                                 integer_type_node,
2168                                 build_int_cst(integer_type_node, code));
2169   if (ret == error_mark_node)
2170     return error_mark_node;
2171   // The runtime error function panics and does not return.
2172   TREE_NOTHROW(runtime_error_fndecl) = 0;
2173   TREE_THIS_VOLATILE(runtime_error_fndecl) = 1;
2174   return ret;
2175 }
2176
2177 // Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
2178 // This does a blocking receive and returns the value read from the
2179 // channel.  If FOR_SELECT is true, this is being done because it was
2180 // chosen in a select statement.
2181
2182 tree
2183 Gogo::receive_from_channel(tree type_tree, tree channel, bool for_select,
2184                            source_location location)
2185 {
2186   if (type_tree == error_mark_node || channel == error_mark_node)
2187     return error_mark_node;
2188
2189   if (int_size_in_bytes(type_tree) <= 8
2190       && !AGGREGATE_TYPE_P(type_tree)
2191       && !FLOAT_TYPE_P(type_tree))
2192     {
2193       static tree receive_small_fndecl;
2194       tree call = Gogo::call_builtin(&receive_small_fndecl,
2195                                      location,
2196                                      "__go_receive_small",
2197                                      2,
2198                                      uint64_type_node,
2199                                      ptr_type_node,
2200                                      channel,
2201                                      boolean_type_node,
2202                                      (for_select
2203                                       ? boolean_true_node
2204                                       : boolean_false_node));
2205       if (call == error_mark_node)
2206         return error_mark_node;
2207       // This can panic if there are too many operations on a closed
2208       // channel.
2209       TREE_NOTHROW(receive_small_fndecl) = 0;
2210       int bitsize = GET_MODE_BITSIZE(TYPE_MODE(type_tree));
2211       tree int_type_tree = go_type_for_size(bitsize, 1);
2212       return fold_convert_loc(location, type_tree,
2213                               fold_convert_loc(location, int_type_tree,
2214                                                call));
2215     }
2216   else
2217     {
2218       tree tmp = create_tmp_var(type_tree, get_name(type_tree));
2219       DECL_IGNORED_P(tmp) = 0;
2220       TREE_ADDRESSABLE(tmp) = 1;
2221       tree make_tmp = build1(DECL_EXPR, void_type_node, tmp);
2222       SET_EXPR_LOCATION(make_tmp, location);
2223       tree tmpaddr = build_fold_addr_expr(tmp);
2224       tmpaddr = fold_convert(ptr_type_node, tmpaddr);
2225       static tree receive_big_fndecl;
2226       tree call = Gogo::call_builtin(&receive_big_fndecl,
2227                                      location,
2228                                      "__go_receive_big",
2229                                      3,
2230                                      boolean_type_node,
2231                                      ptr_type_node,
2232                                      channel,
2233                                      ptr_type_node,
2234                                      tmpaddr,
2235                                      boolean_type_node,
2236                                      (for_select
2237                                       ? boolean_true_node
2238                                       : boolean_false_node));
2239       if (call == error_mark_node)
2240         return error_mark_node;
2241       // This can panic if there are too many operations on a closed
2242       // channel.
2243       TREE_NOTHROW(receive_big_fndecl) = 0;
2244       return build2(COMPOUND_EXPR, type_tree, make_tmp,
2245                     build2(COMPOUND_EXPR, type_tree, call, tmp));
2246     }
2247 }
2248
2249 // Return the type of a function trampoline.  This is like
2250 // get_trampoline_type in tree-nested.c.
2251
2252 tree
2253 Gogo::trampoline_type_tree()
2254 {
2255   static tree type_tree;
2256   if (type_tree == NULL_TREE)
2257     {
2258       unsigned int size;
2259       unsigned int align;
2260       go_trampoline_info(&size, &align);
2261       tree t = build_index_type(build_int_cst(integer_type_node, size - 1));
2262       t = build_array_type(char_type_node, t);
2263
2264       type_tree = Gogo::builtin_struct(NULL, "__go_trampoline", NULL_TREE, 1,
2265                                        "__data", t);
2266       t = TYPE_FIELDS(type_tree);
2267       DECL_ALIGN(t) = align;
2268       DECL_USER_ALIGN(t) = 1;
2269
2270       go_preserve_from_gc(type_tree);
2271     }
2272   return type_tree;
2273 }
2274
2275 // Make a trampoline which calls FNADDR passing CLOSURE.
2276
2277 tree
2278 Gogo::make_trampoline(tree fnaddr, tree closure, source_location location)
2279 {
2280   tree trampoline_type = Gogo::trampoline_type_tree();
2281   tree trampoline_size = TYPE_SIZE_UNIT(trampoline_type);
2282
2283   closure = save_expr(closure);
2284
2285   // We allocate the trampoline using a special function which will
2286   // mark it as executable.
2287   static tree trampoline_fndecl;
2288   tree x = Gogo::call_builtin(&trampoline_fndecl,
2289                               location,
2290                               "__go_allocate_trampoline",
2291                               2,
2292                               ptr_type_node,
2293                               size_type_node,
2294                               trampoline_size,
2295                               ptr_type_node,
2296                               fold_convert_loc(location, ptr_type_node,
2297                                                closure));
2298   if (x == error_mark_node)
2299     return error_mark_node;
2300
2301   x = save_expr(x);
2302
2303   // Initialize the trampoline.
2304   tree ini = build_call_expr(implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE],
2305                              3, x, fnaddr, closure);
2306
2307   // On some targets the trampoline address needs to be adjusted.  For
2308   // example, when compiling in Thumb mode on the ARM, the address
2309   // needs to have the low bit set.
2310   x = build_call_expr(implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE],
2311                       1, x);
2312   x = fold_convert(TREE_TYPE(fnaddr), x);
2313
2314   return build2(COMPOUND_EXPR, TREE_TYPE(x), ini, x);
2315 }