Line data Source code
1 : // go-gcc.cc -- Go frontend to gcc IR.
2 : // Copyright (C) 2011-2026 Free Software Foundation, Inc.
3 : // Contributed by Ian Lance Taylor, Google.
4 :
5 : // This file is part of GCC.
6 :
7 : // GCC is free software; you can redistribute it and/or modify it under
8 : // the terms of the GNU General Public License as published by the Free
9 : // Software Foundation; either version 3, or (at your option) any later
10 : // version.
11 :
12 : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : // for more details.
16 :
17 : // You should have received a copy of the GNU General Public License
18 : // along with GCC; see the file COPYING3. If not see
19 : // <http://www.gnu.org/licenses/>.
20 :
21 : #include "go-system.h"
22 :
23 : // This has to be included outside of extern "C", so we have to
24 : // include it here before tree.h includes it later.
25 : #include <gmp.h>
26 :
27 : #include "tree.h"
28 : #include "opts.h"
29 : #include "fold-const.h"
30 : #include "stringpool.h"
31 : #include "stor-layout.h"
32 : #include "varasm.h"
33 : #include "tree-iterator.h"
34 : #include "tm.h"
35 : #include "function.h"
36 : #include "cgraph.h"
37 : #include "convert.h"
38 : #include "gimple-expr.h"
39 : #include "gimplify.h"
40 : #include "langhooks.h"
41 : #include "toplev.h"
42 : #include "output.h"
43 : #include "realmpfr.h"
44 : #include "builtins.h"
45 :
46 : #include "go-c.h"
47 : #include "go-gcc.h"
48 :
49 : #include "gogo.h"
50 : #include "backend.h"
51 :
52 : // A class wrapping a tree.
53 :
54 : class Gcc_tree
55 : {
56 : public:
57 72711536 : Gcc_tree(tree t)
58 72711536 : : t_(t)
59 : { }
60 :
61 : tree
62 136904129 : get_tree() const
63 587447 : { return this->t_; }
64 :
65 : void
66 2 : set_tree(tree t)
67 2 : { this->t_ = t; }
68 :
69 : private:
70 : tree t_;
71 : };
72 :
73 : // In gcc, types, expressions, and statements are all trees.
74 : class Btype : public Gcc_tree
75 : {
76 : public:
77 6233879 : Btype(tree t)
78 6233879 : : Gcc_tree(t)
79 : { }
80 : };
81 :
82 : class Bexpression : public Gcc_tree
83 : {
84 : public:
85 52369410 : Bexpression(tree t)
86 52369410 : : Gcc_tree(t)
87 : { }
88 : };
89 :
90 : class Bstatement : public Gcc_tree
91 : {
92 : public:
93 9805051 : Bstatement(tree t)
94 9805051 : : Gcc_tree(t)
95 : { }
96 : };
97 :
98 : class Bfunction : public Gcc_tree
99 : {
100 : public:
101 1247858 : Bfunction(tree t)
102 1247858 : : Gcc_tree(t)
103 : { }
104 : };
105 :
106 : class Bblock : public Gcc_tree
107 : {
108 : public:
109 2862174 : Bblock(tree t)
110 2862174 : : Gcc_tree(t)
111 : { }
112 : };
113 :
114 : class Blabel : public Gcc_tree
115 : {
116 : public:
117 193164 : Blabel(tree t)
118 193164 : : Gcc_tree(t)
119 : { }
120 : };
121 :
122 : // Bvariable is a bit more complicated, because of zero-sized types.
123 : // The GNU linker does not permit dynamic variables with zero size.
124 : // When we see such a variable, we generate a version of the type with
125 : // non-zero size. However, when referring to the global variable, we
126 : // want an expression of zero size; otherwise, if, say, the global
127 : // variable is passed to a function, we will be passing a
128 : // non-zero-sized value to a zero-sized value, which can lead to a
129 : // miscompilation.
130 :
131 : class Bvariable
132 : {
133 : public:
134 5128279 : Bvariable(tree t)
135 5128279 : : t_(t), orig_type_(NULL)
136 : { }
137 :
138 34340 : Bvariable(tree t, tree orig_type)
139 34340 : : t_(t), orig_type_(orig_type)
140 : { }
141 :
142 : // Get the tree for use as an expression.
143 : tree
144 : get_tree(Location) const;
145 :
146 : // Get the actual decl;
147 : tree
148 3270649 : get_decl() const
149 3270649 : { return this->t_; }
150 :
151 : private:
152 : tree t_;
153 : tree orig_type_;
154 : };
155 :
156 : // Get the tree of a variable for use as an expression. If this is a
157 : // zero-sized global, create an expression that refers to the decl but
158 : // has zero size.
159 : tree
160 12135900 : Bvariable::get_tree(Location location) const
161 : {
162 12135900 : if (this->orig_type_ == NULL
163 474762 : || this->t_ == error_mark_node
164 12610662 : || TREE_TYPE(this->t_) == this->orig_type_)
165 12133744 : return this->t_;
166 : // Return *(orig_type*)&decl. */
167 2156 : tree t = build_fold_addr_expr_loc(location.gcc_location(), this->t_);
168 2156 : t = fold_build1_loc(location.gcc_location(), NOP_EXPR,
169 2156 : build_pointer_type(this->orig_type_), t);
170 2156 : return build_fold_indirect_ref_loc(location.gcc_location(), t);
171 : }
172 :
173 : // This file implements the interface between the Go frontend proper
174 : // and the gcc IR. This implements specific instantiations of
175 : // abstract classes defined by the Go frontend proper. The Go
176 : // frontend proper class methods of these classes to generate the
177 : // backend representation.
178 :
179 : class Gcc_backend : public Backend
180 : {
181 : public:
182 : Gcc_backend();
183 :
184 : // Types.
185 :
186 : Btype*
187 172 : error_type()
188 344 : { return this->make_type(error_mark_node); }
189 :
190 : Btype*
191 7814 : void_type()
192 15628 : { return this->make_type(void_type_node); }
193 :
194 : Btype*
195 6766 : bool_type()
196 13532 : { return this->make_type(boolean_type_node); }
197 :
198 : Btype*
199 : integer_type(bool, int);
200 :
201 : Btype*
202 : float_type(int);
203 :
204 : Btype*
205 : complex_type(int);
206 :
207 : Btype*
208 : pointer_type(Btype*);
209 :
210 : Btype*
211 : function_type(const Btyped_identifier&,
212 : const std::vector<Btyped_identifier>&,
213 : const std::vector<Btyped_identifier>&,
214 : Btype*,
215 : const Location);
216 :
217 : Btype*
218 : struct_type(const std::vector<Btyped_identifier>&);
219 :
220 : Btype*
221 : array_type(Btype*, Bexpression*);
222 :
223 : Btype*
224 : placeholder_pointer_type(const std::string&, Location, bool);
225 :
226 : bool
227 : set_placeholder_pointer_type(Btype*, Btype*);
228 :
229 : bool
230 : set_placeholder_function_type(Btype*, Btype*);
231 :
232 : Btype*
233 : placeholder_struct_type(const std::string&, Location);
234 :
235 : bool
236 : set_placeholder_struct_type(Btype* placeholder,
237 : const std::vector<Btyped_identifier>&);
238 :
239 : Btype*
240 : placeholder_array_type(const std::string&, Location);
241 :
242 : bool
243 : set_placeholder_array_type(Btype*, Btype*, Bexpression*);
244 :
245 : Btype*
246 : named_type(const std::string&, Btype*, Location);
247 :
248 : Btype*
249 : circular_pointer_type(Btype*, bool);
250 :
251 : bool
252 : is_circular_pointer_type(Btype*);
253 :
254 : int64_t
255 : type_size(Btype*);
256 :
257 : int64_t
258 : type_alignment(Btype*);
259 :
260 : int64_t
261 : type_field_alignment(Btype*);
262 :
263 : int64_t
264 : type_field_offset(Btype*, size_t index);
265 :
266 : // Expressions.
267 :
268 : Bexpression*
269 : zero_expression(Btype*);
270 :
271 : Bexpression*
272 3834 : error_expression()
273 7668 : { return this->make_expression(error_mark_node); }
274 :
275 : Bexpression*
276 1244550 : nil_pointer_expression()
277 2489100 : { return this->make_expression(null_pointer_node); }
278 :
279 : Bexpression*
280 : var_expression(Bvariable* var, Location);
281 :
282 : Bexpression*
283 : indirect_expression(Btype*, Bexpression* expr, bool known_valid, Location);
284 :
285 : Bexpression*
286 : named_constant_expression(Btype* btype, const std::string& name,
287 : Bexpression* val, Location);
288 :
289 : Bexpression*
290 : integer_constant_expression(Btype* btype, mpz_t val);
291 :
292 : Bexpression*
293 : float_constant_expression(Btype* btype, mpfr_t val);
294 :
295 : Bexpression*
296 : complex_constant_expression(Btype* btype, mpc_t val);
297 :
298 : Bexpression*
299 : string_constant_expression(const std::string& val);
300 :
301 : Bexpression*
302 : boolean_constant_expression(bool val);
303 :
304 : Bexpression*
305 : real_part_expression(Bexpression* bcomplex, Location);
306 :
307 : Bexpression*
308 : imag_part_expression(Bexpression* bcomplex, Location);
309 :
310 : Bexpression*
311 : complex_expression(Bexpression* breal, Bexpression* bimag, Location);
312 :
313 : Bexpression*
314 : convert_expression(Btype* type, Bexpression* expr, Location);
315 :
316 : Bexpression*
317 : function_code_expression(Bfunction*, Location);
318 :
319 : Bexpression*
320 : address_expression(Bexpression*, Location);
321 :
322 : Bexpression*
323 : struct_field_expression(Bexpression*, size_t, Location);
324 :
325 : Bexpression*
326 : compound_expression(Bstatement*, Bexpression*, Location);
327 :
328 : Bexpression*
329 : conditional_expression(Bfunction*, Btype*, Bexpression*, Bexpression*,
330 : Bexpression*, Location);
331 :
332 : Bexpression*
333 : unary_expression(Operator, Bexpression*, Location);
334 :
335 : Bexpression*
336 : binary_expression(Operator, Bexpression*, Bexpression*, Location);
337 :
338 : Bexpression*
339 : constructor_expression(Btype*, const std::vector<Bexpression*>&, Location);
340 :
341 : Bexpression*
342 : array_constructor_expression(Btype*, const std::vector<unsigned long>&,
343 : const std::vector<Bexpression*>&, Location);
344 :
345 : Bexpression*
346 : pointer_offset_expression(Bexpression* base, Bexpression* offset, Location);
347 :
348 : Bexpression*
349 : array_index_expression(Bexpression* array, Bexpression* index, Location);
350 :
351 : Bexpression*
352 : call_expression(Bfunction* caller, Bexpression* fn,
353 : const std::vector<Bexpression*>& args,
354 : Bexpression* static_chain, Location);
355 :
356 : // Statements.
357 :
358 : Bstatement*
359 786 : error_statement()
360 1572 : { return this->make_statement(error_mark_node); }
361 :
362 : Bstatement*
363 : expression_statement(Bfunction*, Bexpression*);
364 :
365 : Bstatement*
366 : init_statement(Bfunction*, Bvariable* var, Bexpression* init);
367 :
368 : Bstatement*
369 : assignment_statement(Bfunction*, Bexpression* lhs, Bexpression* rhs,
370 : Location);
371 :
372 : Bstatement*
373 : return_statement(Bfunction*, const std::vector<Bexpression*>&,
374 : Location);
375 :
376 : Bstatement*
377 : if_statement(Bfunction*, Bexpression* condition, Bblock* then_block,
378 : Bblock* else_block, Location);
379 :
380 : Bstatement*
381 : switch_statement(Bfunction* function, Bexpression* value,
382 : const std::vector<std::vector<Bexpression*> >& cases,
383 : const std::vector<Bstatement*>& statements,
384 : Location);
385 :
386 : Bstatement*
387 : compound_statement(Bstatement*, Bstatement*);
388 :
389 : Bstatement*
390 : statement_list(const std::vector<Bstatement*>&);
391 :
392 : Bstatement*
393 : exception_handler_statement(Bstatement* bstat, Bstatement* except_stmt,
394 : Bstatement* finally_stmt, Location);
395 :
396 : // Blocks.
397 :
398 : Bblock*
399 : block(Bfunction*, Bblock*, const std::vector<Bvariable*>&,
400 : Location, Location);
401 :
402 : void
403 : block_add_statements(Bblock*, const std::vector<Bstatement*>&);
404 :
405 : Bstatement*
406 : block_statement(Bblock*);
407 :
408 : // Variables.
409 :
410 : Bvariable*
411 176 : error_variable()
412 176 : { return new Bvariable(error_mark_node); }
413 :
414 : Bvariable*
415 : global_variable(const std::string& var_name,
416 : const std::string& asm_name,
417 : Btype* btype,
418 : unsigned int flags,
419 : Location location);
420 :
421 : void
422 : global_variable_set_init(Bvariable*, Bexpression*);
423 :
424 : Bvariable*
425 : local_variable(Bfunction*, const std::string&, Btype*, Bvariable*,
426 : unsigned int, Location);
427 :
428 : Bvariable*
429 : parameter_variable(Bfunction*, const std::string&, Btype*, unsigned int,
430 : Location);
431 :
432 : Bvariable*
433 : static_chain_variable(Bfunction*, const std::string&, Btype*, unsigned int,
434 : Location);
435 :
436 : Bvariable*
437 : temporary_variable(Bfunction*, Bblock*, Btype*, Bexpression*, unsigned int,
438 : Location, Bstatement**);
439 :
440 : Bvariable*
441 : implicit_variable(const std::string&, const std::string&, Btype*,
442 : unsigned int, int64_t);
443 :
444 : void
445 : implicit_variable_set_init(Bvariable*, const std::string&, Btype*,
446 : unsigned int, Bexpression*);
447 :
448 : Bvariable*
449 : implicit_variable_reference(const std::string&, const std::string&, Btype*);
450 :
451 : Bvariable*
452 : immutable_struct(const std::string&, const std::string&,
453 : unsigned int, Btype*, Location);
454 :
455 : void
456 : immutable_struct_set_init(Bvariable*, const std::string&, unsigned int,
457 : Btype*, Location, Bexpression*);
458 :
459 : Bvariable*
460 : immutable_struct_reference(const std::string&, const std::string&,
461 : Btype*, Location);
462 :
463 : // Labels.
464 :
465 : Blabel*
466 : label(Bfunction*, const std::string& name, Location);
467 :
468 : Bstatement*
469 : label_definition_statement(Blabel*);
470 :
471 : Bstatement*
472 : goto_statement(Blabel*, Location);
473 :
474 : Bexpression*
475 : label_address(Blabel*, Location);
476 :
477 : // Functions.
478 :
479 : Bfunction*
480 14 : error_function()
481 28 : { return this->make_function(error_mark_node); }
482 :
483 : Bfunction*
484 : function(Btype* fntype, const std::string& name, const std::string& asm_name,
485 : unsigned int flags, Location);
486 :
487 : Bstatement*
488 : function_defer_statement(Bfunction* function, Bexpression* undefer,
489 : Bexpression* defer, Location);
490 :
491 : bool
492 : function_set_parameters(Bfunction* function, const std::vector<Bvariable*>&);
493 :
494 : bool
495 : function_set_body(Bfunction* function, Bstatement* code_stmt);
496 :
497 : Bfunction*
498 : lookup_builtin(const std::string&);
499 :
500 : void
501 : write_global_definitions(const std::vector<Btype*>&,
502 : const std::vector<Bexpression*>&,
503 : const std::vector<Bfunction*>&,
504 : const std::vector<Bvariable*>&);
505 :
506 : void
507 : write_export_data(const char* bytes, unsigned int size);
508 :
509 :
510 : private:
511 : // Make a Bexpression from a tree.
512 : Bexpression*
513 52369410 : make_expression(tree t)
514 1248384 : { return new Bexpression(t); }
515 :
516 : // Make a Bstatement from a tree.
517 : Bstatement*
518 9805051 : make_statement(tree t)
519 786 : { return new Bstatement(t); }
520 :
521 : // Make a Btype from a tree.
522 : Btype*
523 6233879 : make_type(tree t)
524 14752 : { return new Btype(t); }
525 :
526 : Bfunction*
527 636242 : make_function(tree t)
528 14 : { return new Bfunction(t); }
529 :
530 : Btype*
531 : fill_in_struct(Btype*, const std::vector<Btyped_identifier>&);
532 :
533 : Btype*
534 : fill_in_array(Btype*, Btype*, Bexpression*);
535 :
536 : tree
537 : non_zero_size_type(tree);
538 :
539 : tree
540 : convert_tree(tree, tree, Location);
541 :
542 : private:
543 : static const int builtin_cold = 1 << 0;
544 : static const int builtin_const = 1 << 1;
545 : static const int builtin_leaf = 1 << 2;
546 : static const int builtin_nonnull = 1 << 3;
547 : static const int builtin_noreturn = 1 << 4;
548 : static const int builtin_nothrow = 1 << 5;
549 : static const int builtin_novops = 1 << 6;
550 : static const int builtin_pure = 1 << 7;
551 :
552 : void
553 : define_builtin(built_in_function bcode, const char* name, const char* libname,
554 : tree fntype, int flags);
555 :
556 : void
557 : set_attributes(tree decl, int flags);
558 :
559 : // A mapping of the GCC built-ins exposed to GCCGo.
560 : std::map<std::string, Bfunction*> builtin_functions_;
561 : };
562 :
563 : // A helper function to create a GCC identifier from a C++ string.
564 :
565 : static inline tree
566 12630901 : get_identifier_from_string(const std::string& str)
567 : {
568 12630901 : return get_identifier_with_length(str.data(), str.length());
569 : }
570 :
571 : // Define the built-in functions that are exposed to GCCGo.
572 :
573 4644 : Gcc_backend::Gcc_backend()
574 : {
575 : /* We need to define the fetch_and_add functions, since we use them
576 : for ++ and --. */
577 4644 : tree t = this->integer_type(true, BITS_PER_UNIT)->get_tree();
578 4644 : tree p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
579 4644 : this->define_builtin(BUILT_IN_SYNC_ADD_AND_FETCH_1, "__sync_fetch_and_add_1",
580 : NULL, build_function_type_list(t, p, t, NULL_TREE),
581 : builtin_leaf);
582 :
583 4644 : t = this->integer_type(true, BITS_PER_UNIT * 2)->get_tree();
584 4644 : p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
585 4644 : this->define_builtin(BUILT_IN_SYNC_ADD_AND_FETCH_2, "__sync_fetch_and_add_2",
586 : NULL, build_function_type_list(t, p, t, NULL_TREE),
587 : builtin_leaf);
588 :
589 4644 : t = this->integer_type(true, BITS_PER_UNIT * 4)->get_tree();
590 4644 : p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
591 4644 : this->define_builtin(BUILT_IN_SYNC_ADD_AND_FETCH_4, "__sync_fetch_and_add_4",
592 : NULL, build_function_type_list(t, p, t, NULL_TREE),
593 : builtin_leaf);
594 :
595 4644 : t = this->integer_type(true, BITS_PER_UNIT * 8)->get_tree();
596 4644 : p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
597 4644 : this->define_builtin(BUILT_IN_SYNC_ADD_AND_FETCH_8, "__sync_fetch_and_add_8",
598 : NULL, build_function_type_list(t, p, t, NULL_TREE),
599 : builtin_leaf);
600 :
601 : // We use __builtin_expect for magic import functions.
602 4644 : this->define_builtin(BUILT_IN_EXPECT, "__builtin_expect", NULL,
603 : build_function_type_list(long_integer_type_node,
604 : long_integer_type_node,
605 : long_integer_type_node,
606 : NULL_TREE),
607 : builtin_const | builtin_nothrow | builtin_leaf);
608 :
609 : // We use __builtin_memcmp for struct comparisons.
610 4644 : this->define_builtin(BUILT_IN_MEMCMP, "__builtin_memcmp", "memcmp",
611 : build_function_type_list(integer_type_node,
612 : const_ptr_type_node,
613 : const_ptr_type_node,
614 : size_type_node,
615 : NULL_TREE),
616 : builtin_pure | builtin_nothrow | builtin_nonnull);
617 :
618 : // We use __builtin_memmove for copying data.
619 4644 : this->define_builtin(BUILT_IN_MEMMOVE, "__builtin_memmove", "memmove",
620 : build_function_type_list(void_type_node,
621 : ptr_type_node,
622 : const_ptr_type_node,
623 : size_type_node,
624 : NULL_TREE),
625 : builtin_nothrow | builtin_nonnull);
626 :
627 : // We use __builtin_memset for zeroing data.
628 4644 : this->define_builtin(BUILT_IN_MEMSET, "__builtin_memset", "memset",
629 : build_function_type_list(void_type_node,
630 : ptr_type_node,
631 : integer_type_node,
632 : size_type_node,
633 : NULL_TREE),
634 : builtin_nothrow | builtin_nonnull);
635 :
636 : // Used by runtime/internal/sys and math/bits.
637 4644 : this->define_builtin(BUILT_IN_CTZ, "__builtin_ctz", "ctz",
638 : build_function_type_list(integer_type_node,
639 : unsigned_type_node,
640 : NULL_TREE),
641 : builtin_const | builtin_nothrow | builtin_leaf);
642 4644 : this->define_builtin(BUILT_IN_CTZL, "__builtin_ctzl", "ctzl",
643 : build_function_type_list(integer_type_node,
644 : long_unsigned_type_node,
645 : NULL_TREE),
646 : builtin_const | builtin_nothrow | builtin_leaf);
647 4644 : this->define_builtin(BUILT_IN_CTZLL, "__builtin_ctzll", "ctzll",
648 : build_function_type_list(integer_type_node,
649 : long_long_unsigned_type_node,
650 : NULL_TREE),
651 : builtin_const | builtin_nothrow | builtin_leaf);
652 4644 : this->define_builtin(BUILT_IN_CLZ, "__builtin_clz", "clz",
653 : build_function_type_list(integer_type_node,
654 : unsigned_type_node,
655 : NULL_TREE),
656 : builtin_const | builtin_nothrow | builtin_leaf);
657 4644 : this->define_builtin(BUILT_IN_CLZL, "__builtin_clzl", "clzl",
658 : build_function_type_list(integer_type_node,
659 : long_unsigned_type_node,
660 : NULL_TREE),
661 : builtin_const | builtin_nothrow | builtin_leaf);
662 4644 : this->define_builtin(BUILT_IN_CLZLL, "__builtin_clzll", "clzll",
663 : build_function_type_list(integer_type_node,
664 : long_long_unsigned_type_node,
665 : NULL_TREE),
666 : builtin_const | builtin_nothrow | builtin_leaf);
667 4644 : this->define_builtin(BUILT_IN_POPCOUNT, "__builtin_popcount", "popcount",
668 : build_function_type_list(integer_type_node,
669 : unsigned_type_node,
670 : NULL_TREE),
671 : builtin_const | builtin_nothrow | builtin_leaf);
672 4644 : this->define_builtin(BUILT_IN_POPCOUNTLL, "__builtin_popcountll", "popcountll",
673 : build_function_type_list(integer_type_node,
674 : long_long_unsigned_type_node,
675 : NULL_TREE),
676 : builtin_const | builtin_nothrow | builtin_leaf);
677 4644 : this->define_builtin(BUILT_IN_BSWAP16, "__builtin_bswap16", "bswap16",
678 : build_function_type_list(uint16_type_node,
679 : uint16_type_node,
680 : NULL_TREE),
681 : builtin_const | builtin_nothrow | builtin_leaf);
682 4644 : this->define_builtin(BUILT_IN_BSWAP32, "__builtin_bswap32", "bswap32",
683 : build_function_type_list(uint32_type_node,
684 : uint32_type_node,
685 : NULL_TREE),
686 : builtin_const | builtin_nothrow | builtin_leaf);
687 4644 : this->define_builtin(BUILT_IN_BSWAP64, "__builtin_bswap64", "bswap64",
688 : build_function_type_list(uint64_type_node,
689 : uint64_type_node,
690 : NULL_TREE),
691 : builtin_const | builtin_nothrow | builtin_leaf);
692 :
693 : // We provide some functions for the math library.
694 4644 : tree math_function_type = build_function_type_list(double_type_node,
695 : double_type_node,
696 : NULL_TREE);
697 4644 : tree math_function_type_long =
698 4644 : build_function_type_list(long_double_type_node, long_double_type_node,
699 : NULL_TREE);
700 4644 : tree math_function_type_two = build_function_type_list(double_type_node,
701 : double_type_node,
702 : double_type_node,
703 : NULL_TREE);
704 4644 : tree math_function_type_long_two =
705 4644 : build_function_type_list(long_double_type_node, long_double_type_node,
706 : long_double_type_node, NULL_TREE);
707 4644 : this->define_builtin(BUILT_IN_ACOS, "__builtin_acos", "acos",
708 : math_function_type, builtin_const);
709 4644 : this->define_builtin(BUILT_IN_ACOSL, "__builtin_acosl", "acosl",
710 : math_function_type_long, builtin_const);
711 4644 : this->define_builtin(BUILT_IN_ASIN, "__builtin_asin", "asin",
712 : math_function_type, builtin_const);
713 4644 : this->define_builtin(BUILT_IN_ASINL, "__builtin_asinl", "asinl",
714 : math_function_type_long, builtin_const);
715 4644 : this->define_builtin(BUILT_IN_ATAN, "__builtin_atan", "atan",
716 : math_function_type, builtin_const);
717 4644 : this->define_builtin(BUILT_IN_ATANL, "__builtin_atanl", "atanl",
718 : math_function_type_long, builtin_const);
719 4644 : this->define_builtin(BUILT_IN_ATAN2, "__builtin_atan2", "atan2",
720 : math_function_type_two, builtin_const);
721 4644 : this->define_builtin(BUILT_IN_ATAN2L, "__builtin_atan2l", "atan2l",
722 : math_function_type_long_two, builtin_const);
723 4644 : this->define_builtin(BUILT_IN_CEIL, "__builtin_ceil", "ceil",
724 : math_function_type, builtin_const);
725 4644 : this->define_builtin(BUILT_IN_CEILL, "__builtin_ceill", "ceill",
726 : math_function_type_long, builtin_const);
727 4644 : this->define_builtin(BUILT_IN_COS, "__builtin_cos", "cos",
728 : math_function_type, builtin_const);
729 4644 : this->define_builtin(BUILT_IN_COSL, "__builtin_cosl", "cosl",
730 : math_function_type_long, builtin_const);
731 4644 : this->define_builtin(BUILT_IN_EXP, "__builtin_exp", "exp",
732 : math_function_type, builtin_const);
733 4644 : this->define_builtin(BUILT_IN_EXPL, "__builtin_expl", "expl",
734 : math_function_type_long, builtin_const);
735 4644 : this->define_builtin(BUILT_IN_EXPM1, "__builtin_expm1", "expm1",
736 : math_function_type, builtin_const);
737 4644 : this->define_builtin(BUILT_IN_EXPM1L, "__builtin_expm1l", "expm1l",
738 : math_function_type_long, builtin_const);
739 4644 : this->define_builtin(BUILT_IN_FABS, "__builtin_fabs", "fabs",
740 : math_function_type, builtin_const);
741 4644 : this->define_builtin(BUILT_IN_FABSL, "__builtin_fabsl", "fabsl",
742 : math_function_type_long, builtin_const);
743 4644 : this->define_builtin(BUILT_IN_FLOOR, "__builtin_floor", "floor",
744 : math_function_type, builtin_const);
745 4644 : this->define_builtin(BUILT_IN_FLOORL, "__builtin_floorl", "floorl",
746 : math_function_type_long, builtin_const);
747 4644 : this->define_builtin(BUILT_IN_FMOD, "__builtin_fmod", "fmod",
748 : math_function_type_two, builtin_const);
749 4644 : this->define_builtin(BUILT_IN_FMODL, "__builtin_fmodl", "fmodl",
750 : math_function_type_long_two, builtin_const);
751 4644 : this->define_builtin(BUILT_IN_LDEXP, "__builtin_ldexp", "ldexp",
752 : build_function_type_list(double_type_node,
753 : double_type_node,
754 : integer_type_node,
755 : NULL_TREE),
756 : builtin_const);
757 4644 : this->define_builtin(BUILT_IN_LDEXPL, "__builtin_ldexpl", "ldexpl",
758 : build_function_type_list(long_double_type_node,
759 : long_double_type_node,
760 : integer_type_node,
761 : NULL_TREE),
762 : builtin_const);
763 4644 : this->define_builtin(BUILT_IN_LOG, "__builtin_log", "log",
764 : math_function_type, builtin_const);
765 4644 : this->define_builtin(BUILT_IN_LOGL, "__builtin_logl", "logl",
766 : math_function_type_long, builtin_const);
767 4644 : this->define_builtin(BUILT_IN_LOG1P, "__builtin_log1p", "log1p",
768 : math_function_type, builtin_const);
769 4644 : this->define_builtin(BUILT_IN_LOG1PL, "__builtin_log1pl", "log1pl",
770 : math_function_type_long, builtin_const);
771 4644 : this->define_builtin(BUILT_IN_LOG10, "__builtin_log10", "log10",
772 : math_function_type, builtin_const);
773 4644 : this->define_builtin(BUILT_IN_LOG10L, "__builtin_log10l", "log10l",
774 : math_function_type_long, builtin_const);
775 4644 : this->define_builtin(BUILT_IN_LOG2, "__builtin_log2", "log2",
776 : math_function_type, builtin_const);
777 4644 : this->define_builtin(BUILT_IN_LOG2L, "__builtin_log2l", "log2l",
778 : math_function_type_long, builtin_const);
779 4644 : this->define_builtin(BUILT_IN_SIN, "__builtin_sin", "sin",
780 : math_function_type, builtin_const);
781 4644 : this->define_builtin(BUILT_IN_SINL, "__builtin_sinl", "sinl",
782 : math_function_type_long, builtin_const);
783 4644 : this->define_builtin(BUILT_IN_SQRT, "__builtin_sqrt", "sqrt",
784 : math_function_type, builtin_const);
785 4644 : this->define_builtin(BUILT_IN_SQRTL, "__builtin_sqrtl", "sqrtl",
786 : math_function_type_long, builtin_const);
787 4644 : this->define_builtin(BUILT_IN_TAN, "__builtin_tan", "tan",
788 : math_function_type, builtin_const);
789 4644 : this->define_builtin(BUILT_IN_TANL, "__builtin_tanl", "tanl",
790 : math_function_type_long, builtin_const);
791 4644 : this->define_builtin(BUILT_IN_TRUNC, "__builtin_trunc", "trunc",
792 : math_function_type, builtin_const);
793 4644 : this->define_builtin(BUILT_IN_TRUNCL, "__builtin_truncl", "truncl",
794 : math_function_type_long, builtin_const);
795 :
796 : // We use __builtin_return_address in the thunk we build for
797 : // functions which call recover, and for runtime.getcallerpc.
798 4644 : t = build_function_type_list(ptr_type_node, unsigned_type_node, NULL_TREE);
799 4644 : this->define_builtin(BUILT_IN_RETURN_ADDRESS, "__builtin_return_address",
800 : NULL, t, builtin_leaf);
801 :
802 : // The runtime calls __builtin_dwarf_cfa for runtime.getcallersp.
803 4644 : t = build_function_type_list(ptr_type_node, NULL_TREE);
804 4644 : this->define_builtin(BUILT_IN_DWARF_CFA, "__builtin_dwarf_cfa",
805 : NULL, t, 0);
806 :
807 : // The runtime calls __builtin_extract_return_addr when recording
808 : // the address to which a function returns.
809 4644 : this->define_builtin(BUILT_IN_EXTRACT_RETURN_ADDR,
810 : "__builtin_extract_return_addr", NULL,
811 : build_function_type_list(ptr_type_node,
812 : ptr_type_node,
813 : NULL_TREE),
814 : builtin_leaf);
815 :
816 : // The compiler uses __builtin_trap for some exception handling
817 : // cases.
818 4644 : this->define_builtin(BUILT_IN_TRAP, "__builtin_trap", NULL,
819 : build_function_type(void_type_node, void_list_node),
820 : (builtin_noreturn | builtin_nothrow | builtin_leaf
821 : | builtin_cold));
822 :
823 : // The runtime uses __builtin_prefetch.
824 4644 : this->define_builtin(BUILT_IN_PREFETCH, "__builtin_prefetch", NULL,
825 : build_varargs_function_type_list(void_type_node,
826 : const_ptr_type_node,
827 : NULL_TREE),
828 : builtin_novops | builtin_leaf);
829 :
830 : // The compiler uses __builtin_unreachable for cases that cannot
831 : // occur.
832 4644 : this->define_builtin(BUILT_IN_UNREACHABLE, "__builtin_unreachable", NULL,
833 : build_function_type(void_type_node, void_list_node),
834 : (builtin_const | builtin_noreturn | builtin_nothrow
835 : | builtin_leaf | builtin_cold));
836 :
837 : // We provide some atomic functions.
838 4644 : t = build_function_type_list(uint32_type_node,
839 : ptr_type_node,
840 : integer_type_node,
841 : NULL_TREE);
842 4644 : this->define_builtin(BUILT_IN_ATOMIC_LOAD_4, "__atomic_load_4", NULL,
843 : t, builtin_leaf);
844 :
845 4644 : t = build_function_type_list(uint64_type_node,
846 : ptr_type_node,
847 : integer_type_node,
848 : NULL_TREE);
849 4644 : this->define_builtin(BUILT_IN_ATOMIC_LOAD_8, "__atomic_load_8", NULL,
850 : t, builtin_leaf);
851 :
852 4644 : t = build_function_type_list(void_type_node,
853 : ptr_type_node,
854 : uint32_type_node,
855 : integer_type_node,
856 : NULL_TREE);
857 4644 : this->define_builtin(BUILT_IN_ATOMIC_STORE_4, "__atomic_store_4", NULL,
858 : t, builtin_leaf);
859 :
860 4644 : t = build_function_type_list(void_type_node,
861 : ptr_type_node,
862 : uint64_type_node,
863 : integer_type_node,
864 : NULL_TREE);
865 4644 : this->define_builtin(BUILT_IN_ATOMIC_STORE_8, "__atomic_store_8", NULL,
866 : t, builtin_leaf);
867 :
868 4644 : t = build_function_type_list(uint32_type_node,
869 : ptr_type_node,
870 : uint32_type_node,
871 : integer_type_node,
872 : NULL_TREE);
873 4644 : this->define_builtin(BUILT_IN_ATOMIC_EXCHANGE_4, "__atomic_exchange_4", NULL,
874 : t, builtin_leaf);
875 :
876 4644 : t = build_function_type_list(uint64_type_node,
877 : ptr_type_node,
878 : uint64_type_node,
879 : integer_type_node,
880 : NULL_TREE);
881 4644 : this->define_builtin(BUILT_IN_ATOMIC_EXCHANGE_8, "__atomic_exchange_8", NULL,
882 : t, builtin_leaf);
883 :
884 4644 : t = build_function_type_list(boolean_type_node,
885 : ptr_type_node,
886 : ptr_type_node,
887 : uint32_type_node,
888 : boolean_type_node,
889 : integer_type_node,
890 : integer_type_node,
891 : NULL_TREE);
892 4644 : this->define_builtin(BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4,
893 : "__atomic_compare_exchange_4", NULL,
894 : t, builtin_leaf);
895 :
896 4644 : t = build_function_type_list(boolean_type_node,
897 : ptr_type_node,
898 : ptr_type_node,
899 : uint64_type_node,
900 : boolean_type_node,
901 : integer_type_node,
902 : integer_type_node,
903 : NULL_TREE);
904 4644 : this->define_builtin(BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8,
905 : "__atomic_compare_exchange_8", NULL,
906 : t, builtin_leaf);
907 :
908 4644 : t = build_function_type_list(uint32_type_node,
909 : ptr_type_node,
910 : uint32_type_node,
911 : integer_type_node,
912 : NULL_TREE);
913 4644 : this->define_builtin(BUILT_IN_ATOMIC_ADD_FETCH_4, "__atomic_add_fetch_4",
914 : NULL, t, builtin_leaf);
915 4644 : this->define_builtin(BUILT_IN_ATOMIC_FETCH_ADD_4, "__atomic_fetch_add_4",
916 : NULL, t, builtin_leaf);
917 :
918 4644 : t = build_function_type_list(uint64_type_node,
919 : ptr_type_node,
920 : uint64_type_node,
921 : integer_type_node,
922 : NULL_TREE);
923 4644 : this->define_builtin(BUILT_IN_ATOMIC_ADD_FETCH_8, "__atomic_add_fetch_8",
924 : NULL, t, builtin_leaf);
925 4644 : this->define_builtin(BUILT_IN_ATOMIC_FETCH_ADD_8, "__atomic_fetch_add_8",
926 : NULL, t, builtin_leaf);
927 :
928 4644 : t = build_function_type_list(unsigned_char_type_node,
929 : ptr_type_node,
930 : integer_type_node,
931 : NULL_TREE);
932 4644 : this->define_builtin(BUILT_IN_ATOMIC_LOAD_1, "__atomic_load_1", NULL, t,
933 : builtin_leaf);
934 :
935 4644 : t = build_function_type_list(void_type_node,
936 : ptr_type_node,
937 : unsigned_char_type_node,
938 : integer_type_node,
939 : NULL_TREE);
940 4644 : this->define_builtin(BUILT_IN_ATOMIC_STORE_1, "__atomic_store_1", NULL,
941 : t, builtin_leaf);
942 :
943 4644 : t = build_function_type_list(unsigned_char_type_node,
944 : ptr_type_node,
945 : unsigned_char_type_node,
946 : integer_type_node,
947 : NULL_TREE);
948 4644 : this->define_builtin(BUILT_IN_ATOMIC_AND_FETCH_1, "__atomic_and_fetch_1", NULL,
949 : t, builtin_leaf);
950 4644 : this->define_builtin(BUILT_IN_ATOMIC_FETCH_AND_1, "__atomic_fetch_and_1", NULL,
951 : t, builtin_leaf);
952 :
953 4644 : t = build_function_type_list(unsigned_char_type_node,
954 : ptr_type_node,
955 : unsigned_char_type_node,
956 : integer_type_node,
957 : NULL_TREE);
958 4644 : this->define_builtin(BUILT_IN_ATOMIC_OR_FETCH_1, "__atomic_or_fetch_1", NULL,
959 : t, builtin_leaf);
960 4644 : this->define_builtin(BUILT_IN_ATOMIC_FETCH_OR_1, "__atomic_fetch_or_1", NULL,
961 : t, builtin_leaf);
962 4644 : }
963 :
964 : // Get an unnamed integer type.
965 :
966 : Btype*
967 196636 : Gcc_backend::integer_type(bool is_unsigned, int bits)
968 : {
969 196636 : tree type;
970 196636 : if (is_unsigned)
971 : {
972 118708 : if (bits == INT_TYPE_SIZE)
973 35731 : type = unsigned_type_node;
974 82977 : else if (bits == CHAR_TYPE_SIZE)
975 32222 : type = unsigned_char_type_node;
976 50755 : else if (bits == SHORT_TYPE_SIZE)
977 10913 : type = short_unsigned_type_node;
978 43367 : else if (bits == LONG_TYPE_SIZE)
979 36317 : type = long_unsigned_type_node;
980 3525 : else if (bits == LONG_LONG_TYPE_SIZE)
981 3525 : type = long_long_unsigned_type_node;
982 : else
983 0 : type = make_unsigned_type(bits);
984 : }
985 : else
986 : {
987 77928 : if (bits == INT_TYPE_SIZE)
988 30422 : type = integer_type_node;
989 47506 : else if (bits == CHAR_TYPE_SIZE)
990 5903 : type = signed_char_type_node;
991 41603 : else if (bits == SHORT_TYPE_SIZE)
992 4926 : type = short_integer_type_node;
993 39498 : else if (bits == LONG_TYPE_SIZE)
994 33856 : type = long_integer_type_node;
995 2821 : else if (bits == LONG_LONG_TYPE_SIZE)
996 2821 : type = long_long_integer_type_node;
997 : else
998 0 : type = make_signed_type(bits);
999 : }
1000 196636 : return this->make_type(type);
1001 : }
1002 :
1003 : // Get an unnamed float type.
1004 :
1005 : Btype*
1006 9823 : Gcc_backend::float_type(int bits)
1007 : {
1008 9823 : tree type;
1009 9823 : if (bits == TYPE_PRECISION (float_type_node))
1010 : type = float_type_node;
1011 5056 : else if (bits == TYPE_PRECISION (double_type_node))
1012 : type = double_type_node;
1013 0 : else if (bits == TYPE_PRECISION (long_double_type_node))
1014 : type = long_double_type_node;
1015 : else
1016 : {
1017 0 : type = make_node(REAL_TYPE);
1018 0 : TYPE_PRECISION(type) = bits;
1019 0 : layout_type(type);
1020 : }
1021 9823 : return this->make_type(type);
1022 : }
1023 :
1024 : // Get an unnamed complex type.
1025 :
1026 : Btype*
1027 9462 : Gcc_backend::complex_type(int bits)
1028 : {
1029 9462 : tree type;
1030 9462 : if (bits == TYPE_PRECISION (float_type_node) * 2)
1031 4704 : type = complex_float_type_node;
1032 4758 : else if (bits == TYPE_PRECISION (double_type_node) * 2)
1033 4758 : type = complex_double_type_node;
1034 0 : else if (bits == TYPE_PRECISION (long_double_type_node) * 2)
1035 0 : type = complex_long_double_type_node;
1036 : else
1037 : {
1038 0 : type = make_node(REAL_TYPE);
1039 0 : TYPE_PRECISION(type) = bits / 2;
1040 0 : layout_type(type);
1041 0 : type = build_complex_type(type);
1042 : }
1043 9462 : return this->make_type(type);
1044 : }
1045 :
1046 : // Get a pointer type.
1047 :
1048 : Btype*
1049 2392715 : Gcc_backend::pointer_type(Btype* to_type)
1050 : {
1051 2392715 : tree to_type_tree = to_type->get_tree();
1052 2392715 : if (to_type_tree == error_mark_node)
1053 13 : return this->error_type();
1054 2392702 : tree type = build_pointer_type(to_type_tree);
1055 2392702 : return this->make_type(type);
1056 : }
1057 :
1058 : // Make a function type.
1059 :
1060 : Btype*
1061 883804 : Gcc_backend::function_type(const Btyped_identifier& receiver,
1062 : const std::vector<Btyped_identifier>& parameters,
1063 : const std::vector<Btyped_identifier>& results,
1064 : Btype* result_struct,
1065 : Location)
1066 : {
1067 883804 : tree args = NULL_TREE;
1068 883804 : tree* pp = &args;
1069 883804 : if (receiver.btype != NULL)
1070 : {
1071 198072 : tree t = receiver.btype->get_tree();
1072 198072 : if (t == error_mark_node)
1073 5 : return this->error_type();
1074 198067 : *pp = tree_cons(NULL_TREE, t, NULL_TREE);
1075 198067 : pp = &TREE_CHAIN(*pp);
1076 : }
1077 :
1078 883799 : for (std::vector<Btyped_identifier>::const_iterator p = parameters.begin();
1079 2171429 : p != parameters.end();
1080 1287630 : ++p)
1081 : {
1082 1287638 : tree t = p->btype->get_tree();
1083 1287638 : if (t == error_mark_node)
1084 8 : return this->error_type();
1085 1287630 : *pp = tree_cons(NULL_TREE, t, NULL_TREE);
1086 1287630 : pp = &TREE_CHAIN(*pp);
1087 : }
1088 :
1089 : // Varargs is handled entirely at the Go level. When converted to
1090 : // GENERIC functions are not varargs.
1091 883791 : *pp = void_list_node;
1092 :
1093 883791 : tree result;
1094 883791 : if (results.empty())
1095 195286 : result = void_type_node;
1096 688505 : else if (results.size() == 1)
1097 587447 : result = results.front().btype->get_tree();
1098 : else
1099 : {
1100 101058 : gcc_assert(result_struct != NULL);
1101 101058 : result = result_struct->get_tree();
1102 : }
1103 883791 : if (result == error_mark_node)
1104 2 : return this->error_type();
1105 :
1106 : // The libffi library cannot represent a zero-sized object. To
1107 : // avoid causing confusion on 32-bit SPARC, we treat a function that
1108 : // returns a zero-sized value as returning void. That should do no
1109 : // harm since there is no actual value to be returned. See
1110 : // https://gcc.gnu.org/PR72814 for details.
1111 883789 : if (result != void_type_node && int_size_in_bytes(result) == 0)
1112 31 : result = void_type_node;
1113 :
1114 883789 : tree fntype = build_function_type(result, args);
1115 883789 : if (fntype == error_mark_node)
1116 0 : return this->error_type();
1117 :
1118 883789 : return this->make_type(build_pointer_type(fntype));
1119 : }
1120 :
1121 : // Make a struct type.
1122 :
1123 : Btype*
1124 476569 : Gcc_backend::struct_type(const std::vector<Btyped_identifier>& fields)
1125 : {
1126 476569 : return this->fill_in_struct(this->make_type(make_node(RECORD_TYPE)), fields);
1127 : }
1128 :
1129 : // Fill in the fields of a struct type.
1130 :
1131 : Btype*
1132 1964274 : Gcc_backend::fill_in_struct(Btype* fill,
1133 : const std::vector<Btyped_identifier>& fields)
1134 : {
1135 1964274 : tree fill_tree = fill->get_tree();
1136 1964274 : tree field_trees = NULL_TREE;
1137 1964274 : tree* pp = &field_trees;
1138 1964274 : for (std::vector<Btyped_identifier>::const_iterator p = fields.begin();
1139 9479261 : p != fields.end();
1140 7514987 : ++p)
1141 : {
1142 7515001 : tree name_tree = get_identifier_from_string(p->name);
1143 7515001 : tree type_tree = p->btype->get_tree();
1144 7515001 : if (type_tree == error_mark_node)
1145 14 : return this->error_type();
1146 7514987 : tree field = build_decl(p->location.gcc_location(), FIELD_DECL, name_tree,
1147 : type_tree);
1148 7514987 : DECL_CONTEXT(field) = fill_tree;
1149 7514987 : *pp = field;
1150 7514987 : pp = &DECL_CHAIN(field);
1151 : }
1152 1964260 : TYPE_FIELDS(fill_tree) = field_trees;
1153 1964260 : layout_type(fill_tree);
1154 :
1155 : // Because Go permits converting between named struct types and
1156 : // equivalent struct types, for which we use VIEW_CONVERT_EXPR, and
1157 : // because we don't try to maintain TYPE_CANONICAL for struct types,
1158 : // we need to tell the middle-end to use structural equality.
1159 1964260 : SET_TYPE_STRUCTURAL_EQUALITY(fill_tree);
1160 :
1161 1964260 : return fill;
1162 : }
1163 :
1164 : // Make an array type.
1165 :
1166 : Btype*
1167 203558 : Gcc_backend::array_type(Btype* element_btype, Bexpression* length)
1168 : {
1169 203558 : return this->fill_in_array(this->make_type(make_node(ARRAY_TYPE)),
1170 203558 : element_btype, length);
1171 : }
1172 :
1173 : // Fill in an array type.
1174 :
1175 : Btype*
1176 215954 : Gcc_backend::fill_in_array(Btype* fill, Btype* element_type,
1177 : Bexpression* length)
1178 : {
1179 215954 : tree element_type_tree = element_type->get_tree();
1180 215954 : tree length_tree = length->get_tree();
1181 215954 : if (element_type_tree == error_mark_node || length_tree == error_mark_node)
1182 2 : return this->error_type();
1183 :
1184 215952 : gcc_assert(TYPE_SIZE(element_type_tree) != NULL_TREE);
1185 :
1186 215952 : length_tree = fold_convert(sizetype, length_tree);
1187 :
1188 : // build_index_type takes the maximum index, which is one less than
1189 : // the length.
1190 215952 : tree index_type_tree = build_index_type(fold_build2(MINUS_EXPR, sizetype,
1191 : length_tree,
1192 : size_one_node));
1193 :
1194 215952 : tree fill_tree = fill->get_tree();
1195 215952 : TREE_TYPE(fill_tree) = element_type_tree;
1196 215952 : TYPE_DOMAIN(fill_tree) = index_type_tree;
1197 215952 : TYPE_ADDR_SPACE(fill_tree) = TYPE_ADDR_SPACE(element_type_tree);
1198 215952 : layout_type(fill_tree);
1199 :
1200 215952 : if (TYPE_STRUCTURAL_EQUALITY_P(element_type_tree))
1201 73219 : SET_TYPE_STRUCTURAL_EQUALITY(fill_tree);
1202 142733 : else if (TYPE_CANONICAL(element_type_tree) != element_type_tree
1203 142733 : || TYPE_CANONICAL(index_type_tree) != index_type_tree)
1204 32051 : TYPE_CANONICAL(fill_tree) =
1205 32051 : build_array_type(TYPE_CANONICAL(element_type_tree),
1206 32051 : TYPE_CANONICAL(index_type_tree));
1207 :
1208 : return fill;
1209 : }
1210 :
1211 : // Create a placeholder for a pointer type.
1212 :
1213 : Btype*
1214 332763 : Gcc_backend::placeholder_pointer_type(const std::string& name,
1215 : Location location, bool)
1216 : {
1217 332763 : tree ret = build_distinct_type_copy(ptr_type_node);
1218 332763 : if (!name.empty())
1219 : {
1220 19048 : tree decl = build_decl(location.gcc_location(), TYPE_DECL,
1221 : get_identifier_from_string(name),
1222 : ret);
1223 9524 : TYPE_NAME(ret) = decl;
1224 : }
1225 332763 : return this->make_type(ret);
1226 : }
1227 :
1228 : // Set the real target type for a placeholder pointer type.
1229 :
1230 : bool
1231 312192 : Gcc_backend::set_placeholder_pointer_type(Btype* placeholder,
1232 : Btype* to_type)
1233 : {
1234 312192 : tree pt = placeholder->get_tree();
1235 312192 : if (pt == error_mark_node)
1236 : return false;
1237 312192 : gcc_assert(TREE_CODE(pt) == POINTER_TYPE);
1238 312192 : tree tt = to_type->get_tree();
1239 312192 : if (tt == error_mark_node)
1240 : {
1241 2 : placeholder->set_tree(error_mark_node);
1242 2 : return false;
1243 : }
1244 312190 : gcc_assert(TREE_CODE(tt) == POINTER_TYPE);
1245 312190 : TREE_TYPE(pt) = TREE_TYPE(tt);
1246 312190 : TYPE_CANONICAL(pt) = TYPE_CANONICAL(tt);
1247 312190 : if (TYPE_NAME(pt) != NULL_TREE)
1248 : {
1249 : // Build the data structure gcc wants to see for a typedef.
1250 4817 : tree copy = build_variant_type_copy(pt);
1251 4817 : TYPE_NAME(copy) = NULL_TREE;
1252 4817 : DECL_ORIGINAL_TYPE(TYPE_NAME(pt)) = copy;
1253 : }
1254 : return true;
1255 : }
1256 :
1257 : // Set the real values for a placeholder function type.
1258 :
1259 : bool
1260 0 : Gcc_backend::set_placeholder_function_type(Btype* placeholder, Btype* ft)
1261 : {
1262 0 : return this->set_placeholder_pointer_type(placeholder, ft);
1263 : }
1264 :
1265 : // Create a placeholder for a struct type.
1266 :
1267 : Btype*
1268 747935 : Gcc_backend::placeholder_struct_type(const std::string& name,
1269 : Location location)
1270 : {
1271 747935 : tree ret = make_node(RECORD_TYPE);
1272 747935 : if (!name.empty())
1273 : {
1274 1479540 : tree decl = build_decl(location.gcc_location(), TYPE_DECL,
1275 : get_identifier_from_string(name),
1276 : ret);
1277 739770 : TYPE_NAME(ret) = decl;
1278 :
1279 : // The struct type that eventually replaces this placeholder will require
1280 : // structural equality. The placeholder must too, so that the requirement
1281 : // for structural equality propagates to references that are constructed
1282 : // before the replacement occurs.
1283 739770 : SET_TYPE_STRUCTURAL_EQUALITY(ret);
1284 : }
1285 747935 : return this->make_type(ret);
1286 : }
1287 :
1288 : // Fill in the fields of a placeholder struct type.
1289 :
1290 : bool
1291 747935 : Gcc_backend::set_placeholder_struct_type(
1292 : Btype* placeholder,
1293 : const std::vector<Btyped_identifier>& fields)
1294 : {
1295 747935 : tree t = placeholder->get_tree();
1296 747935 : gcc_assert(TREE_CODE(t) == RECORD_TYPE && TYPE_FIELDS(t) == NULL_TREE);
1297 747935 : Btype* r = this->fill_in_struct(placeholder, fields);
1298 :
1299 747935 : if (TYPE_NAME(t) != NULL_TREE)
1300 : {
1301 : // Build the data structure gcc wants to see for a typedef.
1302 739770 : tree copy = build_distinct_type_copy(t);
1303 739770 : TYPE_NAME(copy) = NULL_TREE;
1304 739770 : DECL_ORIGINAL_TYPE(TYPE_NAME(t)) = copy;
1305 739770 : TYPE_SIZE(copy) = NULL_TREE;
1306 739770 : Btype* bc = this->make_type(copy);
1307 739770 : this->fill_in_struct(bc, fields);
1308 739770 : delete bc;
1309 : }
1310 :
1311 747935 : return r->get_tree() != error_mark_node;
1312 : }
1313 :
1314 : // Create a placeholder for an array type.
1315 :
1316 : Btype*
1317 12396 : Gcc_backend::placeholder_array_type(const std::string& name,
1318 : Location location)
1319 : {
1320 12396 : tree ret = make_node(ARRAY_TYPE);
1321 24792 : tree decl = build_decl(location.gcc_location(), TYPE_DECL,
1322 : get_identifier_from_string(name),
1323 : ret);
1324 12396 : TYPE_NAME(ret) = decl;
1325 12396 : return this->make_type(ret);
1326 : }
1327 :
1328 : // Fill in the fields of a placeholder array type.
1329 :
1330 : bool
1331 12396 : Gcc_backend::set_placeholder_array_type(Btype* placeholder,
1332 : Btype* element_btype,
1333 : Bexpression* length)
1334 : {
1335 12396 : tree t = placeholder->get_tree();
1336 12396 : gcc_assert(TREE_CODE(t) == ARRAY_TYPE && TREE_TYPE(t) == NULL_TREE);
1337 12396 : Btype* r = this->fill_in_array(placeholder, element_btype, length);
1338 :
1339 : // Build the data structure gcc wants to see for a typedef.
1340 12396 : tree copy = build_distinct_type_copy(t);
1341 12396 : TYPE_NAME(copy) = NULL_TREE;
1342 12396 : DECL_ORIGINAL_TYPE(TYPE_NAME(t)) = copy;
1343 :
1344 12396 : return r->get_tree() != error_mark_node;
1345 : }
1346 :
1347 : // Return a named version of a type.
1348 :
1349 : Btype*
1350 213675 : Gcc_backend::named_type(const std::string& name, Btype* btype,
1351 : Location location)
1352 : {
1353 213675 : tree type = btype->get_tree();
1354 213675 : if (type == error_mark_node)
1355 0 : return this->error_type();
1356 :
1357 : // The middle-end expects a basic type to have a name. In Go every
1358 : // basic type will have a name. The first time we see a basic type,
1359 : // give it whatever Go name we have at this point.
1360 213675 : if (TYPE_NAME(type) == NULL_TREE
1361 81803 : && location.gcc_location() == BUILTINS_LOCATION
1362 213675 : && (TREE_CODE(type) == INTEGER_TYPE
1363 73637 : || TREE_CODE(type) == REAL_TYPE
1364 : || TREE_CODE(type) == COMPLEX_TYPE
1365 : || TREE_CODE(type) == BOOLEAN_TYPE))
1366 : {
1367 120744 : tree decl = build_decl(BUILTINS_LOCATION, TYPE_DECL,
1368 : get_identifier_from_string(name),
1369 : type);
1370 60372 : TYPE_NAME(type) = decl;
1371 60372 : return this->make_type(type);
1372 : }
1373 :
1374 153303 : tree copy = build_variant_type_copy(type);
1375 306606 : tree decl = build_decl(location.gcc_location(), TYPE_DECL,
1376 : get_identifier_from_string(name),
1377 : copy);
1378 153303 : DECL_ORIGINAL_TYPE(decl) = type;
1379 153303 : TYPE_NAME(copy) = decl;
1380 153303 : return this->make_type(copy);
1381 : }
1382 :
1383 : // Return a pointer type used as a marker for a circular type.
1384 :
1385 : Btype*
1386 49 : Gcc_backend::circular_pointer_type(Btype*, bool)
1387 : {
1388 49 : return this->make_type(ptr_type_node);
1389 : }
1390 :
1391 : // Return whether we might be looking at a circular type.
1392 :
1393 : bool
1394 543597 : Gcc_backend::is_circular_pointer_type(Btype* btype)
1395 : {
1396 543597 : return btype->get_tree() == ptr_type_node;
1397 : }
1398 :
1399 : // Return the size of a type.
1400 :
1401 : int64_t
1402 26501188 : Gcc_backend::type_size(Btype* btype)
1403 : {
1404 26501188 : tree t = btype->get_tree();
1405 26501188 : if (t == error_mark_node)
1406 : return 1;
1407 26501178 : if (t == void_type_node)
1408 : return 0;
1409 26501178 : t = TYPE_SIZE_UNIT(t);
1410 26501178 : gcc_assert(tree_fits_uhwi_p (t));
1411 26501178 : unsigned HOST_WIDE_INT val_wide = TREE_INT_CST_LOW(t);
1412 26501178 : int64_t ret = static_cast<int64_t>(val_wide);
1413 26501178 : if (ret < 0 || static_cast<unsigned HOST_WIDE_INT>(ret) != val_wide)
1414 : return -1;
1415 : return ret;
1416 : }
1417 :
1418 : // Return the alignment of a type.
1419 :
1420 : int64_t
1421 4558811 : Gcc_backend::type_alignment(Btype* btype)
1422 : {
1423 4558811 : tree t = btype->get_tree();
1424 4558811 : if (t == error_mark_node)
1425 : return 1;
1426 4558809 : return TYPE_ALIGN_UNIT(t);
1427 : }
1428 :
1429 : // Return the alignment of a struct field of type BTYPE.
1430 :
1431 : int64_t
1432 1187319 : Gcc_backend::type_field_alignment(Btype* btype)
1433 : {
1434 1187319 : tree t = btype->get_tree();
1435 1187319 : if (t == error_mark_node)
1436 : return 1;
1437 1187319 : return go_field_alignment(t);
1438 : }
1439 :
1440 : // Return the offset of a field in a struct.
1441 :
1442 : int64_t
1443 128481 : Gcc_backend::type_field_offset(Btype* btype, size_t index)
1444 : {
1445 128481 : tree struct_tree = btype->get_tree();
1446 128481 : if (struct_tree == error_mark_node)
1447 : return 0;
1448 128481 : gcc_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
1449 128481 : tree field = TYPE_FIELDS(struct_tree);
1450 617926 : for (; index > 0; --index)
1451 : {
1452 489445 : field = DECL_CHAIN(field);
1453 489445 : gcc_assert(field != NULL_TREE);
1454 : }
1455 128481 : HOST_WIDE_INT offset_wide = int_byte_position(field);
1456 128481 : int64_t ret = static_cast<int64_t>(offset_wide);
1457 128481 : gcc_assert(ret == offset_wide);
1458 128481 : return ret;
1459 : }
1460 :
1461 : // Return the zero value for a type.
1462 :
1463 : Bexpression*
1464 465675 : Gcc_backend::zero_expression(Btype* btype)
1465 : {
1466 465675 : tree t = btype->get_tree();
1467 465675 : tree ret;
1468 465675 : if (t == error_mark_node)
1469 : ret = error_mark_node;
1470 : else
1471 465668 : ret = build_zero_cst(t);
1472 465675 : return this->make_expression(ret);
1473 : }
1474 :
1475 : // An expression that references a variable.
1476 :
1477 : Bexpression*
1478 12135900 : Gcc_backend::var_expression(Bvariable* var, Location location)
1479 : {
1480 12135900 : tree ret = var->get_tree(location);
1481 12135900 : if (ret == error_mark_node)
1482 42 : return this->error_expression();
1483 12135858 : return this->make_expression(ret);
1484 : }
1485 :
1486 : // An expression that indirectly references an expression.
1487 :
1488 : Bexpression*
1489 1470924 : Gcc_backend::indirect_expression(Btype* btype, Bexpression* expr,
1490 : bool known_valid, Location location)
1491 : {
1492 1470924 : tree expr_tree = expr->get_tree();
1493 1470924 : tree type_tree = btype->get_tree();
1494 1470924 : if (expr_tree == error_mark_node || type_tree == error_mark_node)
1495 7 : return this->error_expression();
1496 :
1497 : // If the type of EXPR is a recursive pointer type, then we
1498 : // need to insert a cast before indirecting.
1499 1470917 : tree target_type_tree = TREE_TYPE(TREE_TYPE(expr_tree));
1500 1470917 : if (VOID_TYPE_P(target_type_tree))
1501 547 : expr_tree = fold_convert_loc(location.gcc_location(),
1502 : build_pointer_type(type_tree), expr_tree);
1503 :
1504 1470917 : tree ret = build_fold_indirect_ref_loc(location.gcc_location(),
1505 : expr_tree);
1506 1470917 : if (known_valid)
1507 271220 : TREE_THIS_NOTRAP(ret) = 1;
1508 1470917 : return this->make_expression(ret);
1509 : }
1510 :
1511 : // Return an expression that declares a constant named NAME with the
1512 : // constant value VAL in BTYPE.
1513 :
1514 : Bexpression*
1515 23411 : Gcc_backend::named_constant_expression(Btype* btype, const std::string& name,
1516 : Bexpression* val, Location location)
1517 : {
1518 23411 : tree type_tree = btype->get_tree();
1519 23411 : tree const_val = val->get_tree();
1520 23411 : if (type_tree == error_mark_node || const_val == error_mark_node)
1521 13 : return this->error_expression();
1522 :
1523 23398 : tree name_tree = get_identifier_from_string(name);
1524 23398 : tree decl = build_decl(location.gcc_location(), CONST_DECL, name_tree,
1525 : type_tree);
1526 23398 : DECL_INITIAL(decl) = const_val;
1527 23398 : TREE_CONSTANT(decl) = 1;
1528 23398 : TREE_READONLY(decl) = 1;
1529 :
1530 23398 : go_preserve_from_gc(decl);
1531 23398 : return this->make_expression(decl);
1532 : }
1533 :
1534 : // Return a typed value as a constant integer.
1535 :
1536 : Bexpression*
1537 7297457 : Gcc_backend::integer_constant_expression(Btype* btype, mpz_t val)
1538 : {
1539 7297457 : tree t = btype->get_tree();
1540 7297457 : if (t == error_mark_node)
1541 0 : return this->error_expression();
1542 :
1543 7297457 : tree ret = double_int_to_tree(t, mpz_get_double_int(t, val, true));
1544 7297457 : return this->make_expression(ret);
1545 : }
1546 :
1547 : // Return a typed value as a constant floating-point number.
1548 :
1549 : Bexpression*
1550 33424 : Gcc_backend::float_constant_expression(Btype* btype, mpfr_t val)
1551 : {
1552 33424 : tree t = btype->get_tree();
1553 33424 : tree ret;
1554 33424 : if (t == error_mark_node)
1555 0 : return this->error_expression();
1556 :
1557 33424 : REAL_VALUE_TYPE r1;
1558 33424 : real_from_mpfr(&r1, val, t, GMP_RNDN);
1559 33424 : REAL_VALUE_TYPE r2;
1560 33424 : real_convert(&r2, TYPE_MODE(t), &r1);
1561 33424 : ret = build_real(t, r2);
1562 33424 : return this->make_expression(ret);
1563 : }
1564 :
1565 : // Return a typed real and imaginary value as a constant complex number.
1566 :
1567 : Bexpression*
1568 2944 : Gcc_backend::complex_constant_expression(Btype* btype, mpc_t val)
1569 : {
1570 2944 : tree t = btype->get_tree();
1571 2944 : tree ret;
1572 2944 : if (t == error_mark_node)
1573 0 : return this->error_expression();
1574 :
1575 2944 : REAL_VALUE_TYPE r1;
1576 2944 : real_from_mpfr(&r1, mpc_realref(val), TREE_TYPE(t), GMP_RNDN);
1577 2944 : REAL_VALUE_TYPE r2;
1578 2944 : real_convert(&r2, TYPE_MODE(TREE_TYPE(t)), &r1);
1579 :
1580 2944 : REAL_VALUE_TYPE r3;
1581 2944 : real_from_mpfr(&r3, mpc_imagref(val), TREE_TYPE(t), GMP_RNDN);
1582 2944 : REAL_VALUE_TYPE r4;
1583 2944 : real_convert(&r4, TYPE_MODE(TREE_TYPE(t)), &r3);
1584 :
1585 2944 : ret = build_complex(t, build_real(TREE_TYPE(t), r2),
1586 2944 : build_real(TREE_TYPE(t), r4));
1587 2944 : return this->make_expression(ret);
1588 : }
1589 :
1590 : // Make a constant string expression.
1591 :
1592 : Bexpression*
1593 989579 : Gcc_backend::string_constant_expression(const std::string& val)
1594 : {
1595 989579 : tree index_type = build_index_type(size_int(val.length()));
1596 989579 : tree const_char_type = build_qualified_type(unsigned_char_type_node,
1597 : TYPE_QUAL_CONST);
1598 989579 : tree string_type = build_array_type(const_char_type, index_type);
1599 989579 : TYPE_STRING_FLAG(string_type) = 1;
1600 989579 : tree string_val = build_string(val.length(), val.data());
1601 989579 : TREE_TYPE(string_val) = string_type;
1602 :
1603 989579 : return this->make_expression(string_val);
1604 : }
1605 :
1606 : // Make a constant boolean expression.
1607 :
1608 : Bexpression*
1609 653661 : Gcc_backend::boolean_constant_expression(bool val)
1610 : {
1611 653661 : tree bool_cst = val ? boolean_true_node : boolean_false_node;
1612 653661 : return this->make_expression(bool_cst);
1613 : }
1614 :
1615 : // Return the real part of a complex expression.
1616 :
1617 : Bexpression*
1618 460 : Gcc_backend::real_part_expression(Bexpression* bcomplex, Location location)
1619 : {
1620 460 : tree complex_tree = bcomplex->get_tree();
1621 460 : if (complex_tree == error_mark_node)
1622 0 : return this->error_expression();
1623 460 : gcc_assert(COMPLEX_FLOAT_TYPE_P(TREE_TYPE(complex_tree)));
1624 460 : tree ret = fold_build1_loc(location.gcc_location(), REALPART_EXPR,
1625 460 : TREE_TYPE(TREE_TYPE(complex_tree)),
1626 : complex_tree);
1627 460 : return this->make_expression(ret);
1628 : }
1629 :
1630 : // Return the imaginary part of a complex expression.
1631 :
1632 : Bexpression*
1633 526 : Gcc_backend::imag_part_expression(Bexpression* bcomplex, Location location)
1634 : {
1635 526 : tree complex_tree = bcomplex->get_tree();
1636 526 : if (complex_tree == error_mark_node)
1637 0 : return this->error_expression();
1638 526 : gcc_assert(COMPLEX_FLOAT_TYPE_P(TREE_TYPE(complex_tree)));
1639 526 : tree ret = fold_build1_loc(location.gcc_location(), IMAGPART_EXPR,
1640 526 : TREE_TYPE(TREE_TYPE(complex_tree)),
1641 : complex_tree);
1642 526 : return this->make_expression(ret);
1643 : }
1644 :
1645 : // Make a complex expression given its real and imaginary parts.
1646 :
1647 : Bexpression*
1648 12165 : Gcc_backend::complex_expression(Bexpression* breal, Bexpression* bimag,
1649 : Location location)
1650 : {
1651 12165 : tree real_tree = breal->get_tree();
1652 12165 : tree imag_tree = bimag->get_tree();
1653 12165 : if (real_tree == error_mark_node || imag_tree == error_mark_node)
1654 0 : return this->error_expression();
1655 12165 : gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(real_tree))
1656 : == TYPE_MAIN_VARIANT(TREE_TYPE(imag_tree)));
1657 12165 : gcc_assert(SCALAR_FLOAT_TYPE_P(TREE_TYPE(real_tree)));
1658 12165 : tree ret = fold_build2_loc(location.gcc_location(), COMPLEX_EXPR,
1659 12165 : build_complex_type(TREE_TYPE(real_tree)),
1660 : real_tree, imag_tree);
1661 12165 : return this->make_expression(ret);
1662 : }
1663 :
1664 : // An expression that converts an expression to a different type.
1665 :
1666 : Bexpression*
1667 9627968 : Gcc_backend::convert_expression(Btype* type, Bexpression* expr,
1668 : Location location)
1669 : {
1670 9627968 : tree type_tree = type->get_tree();
1671 9627968 : tree expr_tree = expr->get_tree();
1672 9627968 : if (type_tree == error_mark_node
1673 9627961 : || expr_tree == error_mark_node
1674 19255901 : || TREE_TYPE(expr_tree) == error_mark_node)
1675 35 : return this->error_expression();
1676 :
1677 9627933 : tree ret;
1678 9627933 : if (this->type_size(type) == 0
1679 9627933 : || TREE_TYPE(expr_tree) == void_type_node)
1680 : {
1681 : // Do not convert zero-sized types.
1682 : ret = expr_tree;
1683 : }
1684 9626682 : else if (TREE_CODE(type_tree) == INTEGER_TYPE)
1685 2375332 : ret = fold(convert_to_integer(type_tree, expr_tree));
1686 7251350 : else if (TREE_CODE(type_tree) == REAL_TYPE)
1687 32302 : ret = fold(convert_to_real(type_tree, expr_tree));
1688 7219048 : else if (TREE_CODE(type_tree) == COMPLEX_TYPE)
1689 1447 : ret = fold(convert_to_complex(type_tree, expr_tree));
1690 7217601 : else if (TREE_CODE(type_tree) == POINTER_TYPE
1691 7217601 : && TREE_CODE(TREE_TYPE(expr_tree)) == INTEGER_TYPE)
1692 1578 : ret = fold(convert_to_pointer(type_tree, expr_tree));
1693 7216023 : else if (TREE_CODE(type_tree) == RECORD_TYPE
1694 7216023 : || TREE_CODE(type_tree) == ARRAY_TYPE)
1695 925398 : ret = fold_build1_loc(location.gcc_location(), VIEW_CONVERT_EXPR,
1696 : type_tree, expr_tree);
1697 : else
1698 6290625 : ret = fold_convert_loc(location.gcc_location(), type_tree, expr_tree);
1699 :
1700 9627933 : return this->make_expression(ret);
1701 : }
1702 :
1703 : // Get the address of a function.
1704 :
1705 : Bexpression*
1706 2175239 : Gcc_backend::function_code_expression(Bfunction* bfunc, Location location)
1707 : {
1708 2175239 : tree func = bfunc->get_tree();
1709 2175239 : if (func == error_mark_node)
1710 3 : return this->error_expression();
1711 :
1712 2175236 : tree ret = build_fold_addr_expr_loc(location.gcc_location(), func);
1713 2175236 : return this->make_expression(ret);
1714 : }
1715 :
1716 : // Get the address of an expression.
1717 :
1718 : Bexpression*
1719 5041599 : Gcc_backend::address_expression(Bexpression* bexpr, Location location)
1720 : {
1721 5041599 : tree expr = bexpr->get_tree();
1722 5041599 : if (expr == error_mark_node)
1723 14 : return this->error_expression();
1724 :
1725 5041585 : tree ret = build_fold_addr_expr_loc(location.gcc_location(), expr);
1726 5041585 : return this->make_expression(ret);
1727 : }
1728 :
1729 : // Return an expression for the field at INDEX in BSTRUCT.
1730 :
1731 : Bexpression*
1732 2432403 : Gcc_backend::struct_field_expression(Bexpression* bstruct, size_t index,
1733 : Location location)
1734 : {
1735 2432403 : tree struct_tree = bstruct->get_tree();
1736 2432403 : if (struct_tree == error_mark_node
1737 2432403 : || TREE_TYPE(struct_tree) == error_mark_node)
1738 3 : return this->error_expression();
1739 :
1740 : // A function call that returns a zero-sized object will have been
1741 : // changed to return void. A zero-sized object can have a
1742 : // (zero-sized) field, so support that case.
1743 2432400 : if (TREE_TYPE(struct_tree) == void_type_node)
1744 : return bstruct;
1745 :
1746 2432400 : gcc_assert(TREE_CODE(TREE_TYPE(struct_tree)) == RECORD_TYPE);
1747 2432400 : tree field = TYPE_FIELDS(TREE_TYPE(struct_tree));
1748 2432400 : if (field == NULL_TREE)
1749 : {
1750 : // This can happen for a type which refers to itself indirectly
1751 : // and then turns out to be erroneous.
1752 0 : return this->error_expression();
1753 : }
1754 6093473 : for (unsigned int i = index; i > 0; --i)
1755 : {
1756 3661073 : field = DECL_CHAIN(field);
1757 3661073 : gcc_assert(field != NULL_TREE);
1758 : }
1759 2432400 : if (TREE_TYPE(field) == error_mark_node)
1760 0 : return this->error_expression();
1761 2432400 : tree ret = fold_build3_loc(location.gcc_location(), COMPONENT_REF,
1762 2432400 : TREE_TYPE(field), struct_tree, field,
1763 : NULL_TREE);
1764 2432400 : if (TREE_CONSTANT(struct_tree))
1765 135 : TREE_CONSTANT(ret) = 1;
1766 2432400 : return this->make_expression(ret);
1767 : }
1768 :
1769 : // Return an expression that executes BSTAT before BEXPR.
1770 :
1771 : Bexpression*
1772 450088 : Gcc_backend::compound_expression(Bstatement* bstat, Bexpression* bexpr,
1773 : Location location)
1774 : {
1775 450088 : tree stat = bstat->get_tree();
1776 450088 : tree expr = bexpr->get_tree();
1777 450088 : if (stat == error_mark_node || expr == error_mark_node)
1778 9 : return this->error_expression();
1779 450079 : tree ret = fold_build2_loc(location.gcc_location(), COMPOUND_EXPR,
1780 450079 : TREE_TYPE(expr), stat, expr);
1781 450079 : return this->make_expression(ret);
1782 : }
1783 :
1784 : // Return an expression that executes THEN_EXPR if CONDITION is true, or
1785 : // ELSE_EXPR otherwise.
1786 :
1787 : Bexpression*
1788 558018 : Gcc_backend::conditional_expression(Bfunction*, Btype* btype,
1789 : Bexpression* condition,
1790 : Bexpression* then_expr,
1791 : Bexpression* else_expr, Location location)
1792 : {
1793 558018 : tree type_tree = btype == NULL ? void_type_node : btype->get_tree();
1794 558018 : tree cond_tree = condition->get_tree();
1795 558018 : tree then_tree = then_expr->get_tree();
1796 558018 : tree else_tree = else_expr == NULL ? NULL_TREE : else_expr->get_tree();
1797 558018 : if (type_tree == error_mark_node
1798 558018 : || cond_tree == error_mark_node
1799 558018 : || then_tree == error_mark_node
1800 558018 : || else_tree == error_mark_node)
1801 0 : return this->error_expression();
1802 558018 : tree ret = build3_loc(location.gcc_location(), COND_EXPR, type_tree,
1803 : cond_tree, then_tree, else_tree);
1804 558018 : return this->make_expression(ret);
1805 : }
1806 :
1807 : // Return an expression for the unary operation OP EXPR.
1808 :
1809 : Bexpression*
1810 108286 : Gcc_backend::unary_expression(Operator op, Bexpression* expr, Location location)
1811 : {
1812 108286 : tree expr_tree = expr->get_tree();
1813 108286 : if (expr_tree == error_mark_node
1814 108286 : || TREE_TYPE(expr_tree) == error_mark_node)
1815 1 : return this->error_expression();
1816 :
1817 108285 : tree type_tree = TREE_TYPE(expr_tree);
1818 108285 : enum tree_code code;
1819 108285 : switch (op)
1820 : {
1821 10894 : case OPERATOR_MINUS:
1822 10894 : {
1823 10894 : tree computed_type = excess_precision_type(type_tree);
1824 10894 : if (computed_type != NULL_TREE)
1825 : {
1826 464 : expr_tree = convert(computed_type, expr_tree);
1827 464 : type_tree = computed_type;
1828 : }
1829 : code = NEGATE_EXPR;
1830 : break;
1831 : }
1832 : case OPERATOR_NOT:
1833 : code = TRUTH_NOT_EXPR;
1834 : break;
1835 3062 : case OPERATOR_XOR:
1836 3062 : code = BIT_NOT_EXPR;
1837 3062 : break;
1838 0 : default:
1839 0 : gcc_unreachable();
1840 108285 : break;
1841 : }
1842 :
1843 108285 : tree ret = fold_build1_loc(location.gcc_location(), code, type_tree,
1844 : expr_tree);
1845 108285 : return this->make_expression(ret);
1846 : }
1847 :
1848 : // Convert a gofrontend operator to an equivalent tree_code.
1849 :
1850 : static enum tree_code
1851 2291797 : operator_to_tree_code(Operator op, tree type)
1852 : {
1853 2291797 : enum tree_code code;
1854 2291797 : switch (op)
1855 : {
1856 : case OPERATOR_EQEQ:
1857 : code = EQ_EXPR;
1858 : break;
1859 163063 : case OPERATOR_NOTEQ:
1860 163063 : code = NE_EXPR;
1861 163063 : break;
1862 222537 : case OPERATOR_LT:
1863 222537 : code = LT_EXPR;
1864 222537 : break;
1865 92034 : case OPERATOR_LE:
1866 92034 : code = LE_EXPR;
1867 92034 : break;
1868 37325 : case OPERATOR_GT:
1869 37325 : code = GT_EXPR;
1870 37325 : break;
1871 225125 : case OPERATOR_GE:
1872 225125 : code = GE_EXPR;
1873 225125 : break;
1874 16 : case OPERATOR_OROR:
1875 16 : code = TRUTH_ORIF_EXPR;
1876 16 : break;
1877 217786 : case OPERATOR_ANDAND:
1878 217786 : code = TRUTH_ANDIF_EXPR;
1879 217786 : break;
1880 142275 : case OPERATOR_PLUS:
1881 142275 : code = PLUS_EXPR;
1882 142275 : break;
1883 150242 : case OPERATOR_MINUS:
1884 150242 : code = MINUS_EXPR;
1885 150242 : break;
1886 129013 : case OPERATOR_OR:
1887 129013 : code = BIT_IOR_EXPR;
1888 129013 : break;
1889 3908 : case OPERATOR_XOR:
1890 3908 : code = BIT_XOR_EXPR;
1891 3908 : break;
1892 28250 : case OPERATOR_MULT:
1893 28250 : code = MULT_EXPR;
1894 28250 : break;
1895 8928 : case OPERATOR_DIV:
1896 8928 : if (TREE_CODE(type) == REAL_TYPE || TREE_CODE(type) == COMPLEX_TYPE)
1897 : code = RDIV_EXPR;
1898 : else
1899 2291797 : code = TRUNC_DIV_EXPR;
1900 : break;
1901 4242 : case OPERATOR_MOD:
1902 4242 : code = TRUNC_MOD_EXPR;
1903 4242 : break;
1904 131262 : case OPERATOR_LSHIFT:
1905 131262 : code = LSHIFT_EXPR;
1906 131262 : break;
1907 13650 : case OPERATOR_RSHIFT:
1908 13650 : code = RSHIFT_EXPR;
1909 13650 : break;
1910 : case OPERATOR_AND:
1911 17617 : code = BIT_AND_EXPR;
1912 : break;
1913 : case OPERATOR_BITCLEAR:
1914 17617 : code = BIT_AND_EXPR;
1915 : break;
1916 0 : default:
1917 0 : gcc_unreachable();
1918 : }
1919 :
1920 2291797 : return code;
1921 : }
1922 :
1923 : // Return an expression for the binary operation LEFT OP RIGHT.
1924 :
1925 : Bexpression*
1926 2291798 : Gcc_backend::binary_expression(Operator op, Bexpression* left,
1927 : Bexpression* right, Location location)
1928 : {
1929 2291798 : tree left_tree = left->get_tree();
1930 2291798 : tree right_tree = right->get_tree();
1931 2291798 : if (left_tree == error_mark_node
1932 2291798 : || right_tree == error_mark_node)
1933 1 : return this->error_expression();
1934 2291797 : enum tree_code code = operator_to_tree_code(op, TREE_TYPE(left_tree));
1935 :
1936 2291797 : bool use_left_type = op != OPERATOR_OROR && op != OPERATOR_ANDAND;
1937 2291797 : tree type_tree = use_left_type ? TREE_TYPE(left_tree) : TREE_TYPE(right_tree);
1938 2291797 : tree computed_type = excess_precision_type(type_tree);
1939 2291797 : if (computed_type != NULL_TREE)
1940 : {
1941 8586 : left_tree = convert(computed_type, left_tree);
1942 8586 : right_tree = convert(computed_type, right_tree);
1943 8586 : type_tree = computed_type;
1944 : }
1945 :
1946 : // For comparison operators, the resulting type should be boolean.
1947 2291797 : switch (op)
1948 : {
1949 1444608 : case OPERATOR_EQEQ:
1950 1444608 : case OPERATOR_NOTEQ:
1951 1444608 : case OPERATOR_LT:
1952 1444608 : case OPERATOR_LE:
1953 1444608 : case OPERATOR_GT:
1954 1444608 : case OPERATOR_GE:
1955 1444608 : type_tree = boolean_type_node;
1956 1444608 : break;
1957 : default:
1958 : break;
1959 : }
1960 :
1961 2291797 : tree ret = fold_build2_loc(location.gcc_location(), code, type_tree,
1962 : left_tree, right_tree);
1963 2291797 : return this->make_expression(ret);
1964 : }
1965 :
1966 : // Return an expression that constructs BTYPE with VALS.
1967 :
1968 : Bexpression*
1969 2880351 : Gcc_backend::constructor_expression(Btype* btype,
1970 : const std::vector<Bexpression*>& vals,
1971 : Location location)
1972 : {
1973 2880351 : tree type_tree = btype->get_tree();
1974 2880351 : if (type_tree == error_mark_node)
1975 0 : return this->error_expression();
1976 :
1977 2880351 : vec<constructor_elt, va_gc> *init;
1978 2880351 : vec_alloc(init, vals.size());
1979 :
1980 2880351 : tree sink = NULL_TREE;
1981 2880351 : bool is_constant = true;
1982 2880351 : tree field = TYPE_FIELDS(type_tree);
1983 2880351 : for (std::vector<Bexpression*>::const_iterator p = vals.begin();
1984 12761428 : p != vals.end();
1985 9881077 : ++p, field = DECL_CHAIN(field))
1986 : {
1987 9881093 : gcc_assert(field != NULL_TREE);
1988 9881093 : tree val = (*p)->get_tree();
1989 9881093 : if (TREE_TYPE(field) == error_mark_node
1990 9881093 : || val == error_mark_node
1991 19762170 : || TREE_TYPE(val) == error_mark_node)
1992 16 : return this->error_expression();
1993 :
1994 9881077 : if (int_size_in_bytes(TREE_TYPE(field)) == 0)
1995 : {
1996 : // GIMPLE cannot represent indices of zero-sized types so
1997 : // trying to construct a map with zero-sized keys might lead
1998 : // to errors. Instead, we evaluate each expression that
1999 : // would have been added as a map element for its
2000 : // side-effects and construct an empty map.
2001 810 : append_to_statement_list(val, &sink);
2002 810 : continue;
2003 : }
2004 :
2005 9880267 : constructor_elt empty = {NULL, NULL};
2006 9880267 : constructor_elt* elt = init->quick_push(empty);
2007 9880267 : elt->index = field;
2008 9880267 : elt->value = this->convert_tree(TREE_TYPE(field), val, location);
2009 9880267 : if (!TREE_CONSTANT(elt->value))
2010 597767 : is_constant = false;
2011 : }
2012 2880335 : gcc_assert(field == NULL_TREE);
2013 2880335 : tree ret = build_constructor(type_tree, init);
2014 2880335 : if (is_constant)
2015 2469013 : TREE_CONSTANT(ret) = 1;
2016 2880335 : if (sink != NULL_TREE)
2017 0 : ret = fold_build2_loc(location.gcc_location(), COMPOUND_EXPR,
2018 : type_tree, sink, ret);
2019 2880335 : return this->make_expression(ret);
2020 : }
2021 :
2022 : Bexpression*
2023 441149 : Gcc_backend::array_constructor_expression(
2024 : Btype* array_btype, const std::vector<unsigned long>& indexes,
2025 : const std::vector<Bexpression*>& vals, Location location)
2026 : {
2027 441149 : tree type_tree = array_btype->get_tree();
2028 441149 : if (type_tree == error_mark_node)
2029 1 : return this->error_expression();
2030 :
2031 441148 : gcc_assert(indexes.size() == vals.size());
2032 :
2033 441148 : tree element_type = TREE_TYPE(type_tree);
2034 441148 : HOST_WIDE_INT element_size = int_size_in_bytes(element_type);
2035 441148 : vec<constructor_elt, va_gc> *init;
2036 882233 : vec_alloc(init, element_size == 0 ? 0 : vals.size());
2037 :
2038 441148 : tree sink = NULL_TREE;
2039 441148 : bool is_constant = true;
2040 2374607 : for (size_t i = 0; i < vals.size(); ++i)
2041 : {
2042 1933464 : tree index = size_int(indexes[i]);
2043 1933464 : tree val = (vals[i])->get_tree();
2044 :
2045 1933464 : if (index == error_mark_node
2046 1933464 : || val == error_mark_node)
2047 5 : return this->error_expression();
2048 :
2049 1933459 : if (element_size == 0)
2050 : {
2051 : // GIMPLE cannot represent arrays of zero-sized types so trying
2052 : // to construct an array of zero-sized values might lead to errors.
2053 : // Instead, we evaluate each expression that would have been added as
2054 : // an array value for its side-effects and construct an empty array.
2055 9 : append_to_statement_list(val, &sink);
2056 9 : continue;
2057 : }
2058 :
2059 1933450 : if (!TREE_CONSTANT(val))
2060 156463 : is_constant = false;
2061 :
2062 1933450 : constructor_elt empty = {NULL, NULL};
2063 1933450 : constructor_elt* elt = init->quick_push(empty);
2064 1933450 : elt->index = index;
2065 1933450 : elt->value = val;
2066 : }
2067 :
2068 441143 : tree ret = build_constructor(type_tree, init);
2069 441143 : if (is_constant)
2070 365121 : TREE_CONSTANT(ret) = 1;
2071 441143 : if (sink != NULL_TREE)
2072 0 : ret = fold_build2_loc(location.gcc_location(), COMPOUND_EXPR,
2073 : type_tree, sink, ret);
2074 441143 : return this->make_expression(ret);
2075 : }
2076 :
2077 : // Return an expression for the address of BASE[INDEX].
2078 :
2079 : Bexpression*
2080 160626 : Gcc_backend::pointer_offset_expression(Bexpression* base, Bexpression* index,
2081 : Location location)
2082 : {
2083 160626 : tree base_tree = base->get_tree();
2084 160626 : tree index_tree = index->get_tree();
2085 160626 : tree element_type_tree = TREE_TYPE(TREE_TYPE(base_tree));
2086 160626 : if (base_tree == error_mark_node
2087 160626 : || TREE_TYPE(base_tree) == error_mark_node
2088 160626 : || index_tree == error_mark_node
2089 321252 : || element_type_tree == error_mark_node)
2090 0 : return this->error_expression();
2091 :
2092 160626 : tree element_size = TYPE_SIZE_UNIT(element_type_tree);
2093 160626 : index_tree = fold_convert_loc(location.gcc_location(), sizetype, index_tree);
2094 160626 : tree offset = fold_build2_loc(location.gcc_location(), MULT_EXPR, sizetype,
2095 : index_tree, element_size);
2096 160626 : tree ptr = fold_build2_loc(location.gcc_location(), POINTER_PLUS_EXPR,
2097 160626 : TREE_TYPE(base_tree), base_tree, offset);
2098 160626 : return this->make_expression(ptr);
2099 : }
2100 :
2101 : // Return an expression representing ARRAY[INDEX]
2102 :
2103 : Bexpression*
2104 66928 : Gcc_backend::array_index_expression(Bexpression* array, Bexpression* index,
2105 : Location location)
2106 : {
2107 66928 : tree array_tree = array->get_tree();
2108 66928 : tree index_tree = index->get_tree();
2109 66928 : if (array_tree == error_mark_node
2110 66928 : || TREE_TYPE(array_tree) == error_mark_node
2111 133856 : || index_tree == error_mark_node)
2112 0 : return this->error_expression();
2113 :
2114 : // A function call that returns a zero sized object will have been
2115 : // changed to return void. If we see void here, assume we are
2116 : // dealing with a zero sized type and just evaluate the operands.
2117 66928 : tree ret;
2118 66928 : if (TREE_TYPE(array_tree) != void_type_node)
2119 66927 : ret = build4_loc(location.gcc_location(), ARRAY_REF,
2120 66927 : TREE_TYPE(TREE_TYPE(array_tree)), array_tree,
2121 : index_tree, NULL_TREE, NULL_TREE);
2122 : else
2123 1 : ret = fold_build2_loc(location.gcc_location(), COMPOUND_EXPR,
2124 : void_type_node, array_tree, index_tree);
2125 :
2126 66928 : return this->make_expression(ret);
2127 : }
2128 :
2129 : // Create an expression for a call to FN_EXPR with FN_ARGS.
2130 : Bexpression*
2131 1791771 : Gcc_backend::call_expression(Bfunction*, // containing fcn for call
2132 : Bexpression* fn_expr,
2133 : const std::vector<Bexpression*>& fn_args,
2134 : Bexpression* chain_expr,
2135 : Location location)
2136 : {
2137 1791771 : tree fn = fn_expr->get_tree();
2138 1791771 : if (fn == error_mark_node || TREE_TYPE(fn) == error_mark_node)
2139 4 : return this->error_expression();
2140 :
2141 1791767 : gcc_assert(FUNCTION_POINTER_TYPE_P(TREE_TYPE(fn)));
2142 1791767 : tree rettype = TREE_TYPE(TREE_TYPE(TREE_TYPE(fn)));
2143 :
2144 1791767 : size_t nargs = fn_args.size();
2145 1791767 : tree* args = nargs == 0 ? NULL : new tree[nargs];
2146 5003250 : for (size_t i = 0; i < nargs; ++i)
2147 : {
2148 3211493 : args[i] = fn_args.at(i)->get_tree();
2149 3211493 : if (args[i] == error_mark_node)
2150 10 : return this->error_expression();
2151 3211483 : if (TREE_TYPE(args[i]) == void_type_node)
2152 : {
2153 : // This can happen for a case like f(g()) where g returns a
2154 : // zero-sized type, because in that case we've changed g to
2155 : // return void.
2156 0 : tree t = TYPE_ARG_TYPES(TREE_TYPE(TREE_TYPE(fn)));
2157 0 : for (size_t j = 0; j < i; ++j)
2158 0 : t = TREE_CHAIN(t);
2159 0 : tree arg_type = TREE_TYPE(TREE_VALUE(t));
2160 0 : args[i] = fold_build2_loc(EXPR_LOCATION(args[i]), COMPOUND_EXPR,
2161 : arg_type, args[i],
2162 : build_zero_cst(arg_type));
2163 : }
2164 : }
2165 :
2166 1791757 : tree fndecl = fn;
2167 1791757 : if (TREE_CODE(fndecl) == ADDR_EXPR)
2168 1737489 : fndecl = TREE_OPERAND(fndecl, 0);
2169 :
2170 : // This is to support builtin math functions when using 80387 math.
2171 1791757 : tree excess_type = NULL_TREE;
2172 1791757 : if (optimize
2173 1632436 : && TREE_CODE(fndecl) == FUNCTION_DECL
2174 1578186 : && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
2175 59610 : && DECL_IS_UNDECLARED_BUILTIN (fndecl)
2176 59610 : && nargs > 0
2177 1850375 : && ((SCALAR_FLOAT_TYPE_P(rettype)
2178 341 : && SCALAR_FLOAT_TYPE_P(TREE_TYPE(args[0])))
2179 58277 : || (COMPLEX_FLOAT_TYPE_P(rettype)
2180 0 : && COMPLEX_FLOAT_TYPE_P(TREE_TYPE(args[0])))))
2181 : {
2182 341 : excess_type = excess_precision_type(TREE_TYPE(args[0]));
2183 341 : if (excess_type != NULL_TREE)
2184 : {
2185 164 : tree excess_fndecl = mathfn_built_in(excess_type,
2186 : DECL_FUNCTION_CODE(fndecl));
2187 164 : if (excess_fndecl == NULL_TREE)
2188 : excess_type = NULL_TREE;
2189 : else
2190 : {
2191 164 : fn = build_fold_addr_expr_loc(location.gcc_location(),
2192 : excess_fndecl);
2193 351 : for (size_t i = 0; i < nargs; ++i)
2194 : {
2195 187 : if (SCALAR_FLOAT_TYPE_P(TREE_TYPE(args[i]))
2196 187 : || COMPLEX_FLOAT_TYPE_P(TREE_TYPE(args[i])))
2197 176 : args[i] = ::convert(excess_type, args[i]);
2198 : }
2199 : }
2200 : }
2201 : }
2202 :
2203 1791757 : tree ret =
2204 1791757 : build_call_array_loc(location.gcc_location(),
2205 : excess_type != NULL_TREE ? excess_type : rettype,
2206 : fn, nargs, args);
2207 :
2208 1791757 : if (chain_expr)
2209 23187 : CALL_EXPR_STATIC_CHAIN (ret) = chain_expr->get_tree();
2210 :
2211 1791757 : if (excess_type != NULL_TREE)
2212 : {
2213 : // Calling convert here can undo our excess precision change.
2214 : // That may or may not be a bug in convert_to_real.
2215 164 : ret = build1_loc(location.gcc_location(), NOP_EXPR, rettype, ret);
2216 : }
2217 :
2218 1791757 : delete[] args;
2219 1791757 : return this->make_expression(ret);
2220 : }
2221 :
2222 : // An expression as a statement.
2223 :
2224 : Bstatement*
2225 1009936 : Gcc_backend::expression_statement(Bfunction*, Bexpression* expr)
2226 : {
2227 1009936 : return this->make_statement(expr->get_tree());
2228 : }
2229 :
2230 : // Variable initialization.
2231 :
2232 : Bstatement*
2233 645447 : Gcc_backend::init_statement(Bfunction*, Bvariable* var, Bexpression* init)
2234 : {
2235 645447 : tree var_tree = var->get_decl();
2236 645447 : tree init_tree = init->get_tree();
2237 645447 : if (var_tree == error_mark_node || init_tree == error_mark_node)
2238 6 : return this->error_statement();
2239 645441 : gcc_assert(TREE_CODE(var_tree) == VAR_DECL);
2240 :
2241 : // To avoid problems with GNU ld, we don't make zero-sized
2242 : // externally visible variables. That might lead us to doing an
2243 : // initialization of a zero-sized expression to a non-zero sized
2244 : // variable, or vice-versa. Avoid crashes by omitting the
2245 : // initializer. Such initializations don't mean anything anyhow.
2246 645441 : if (int_size_in_bytes(TREE_TYPE(var_tree)) != 0
2247 644129 : && init_tree != NULL_TREE
2248 644129 : && TREE_TYPE(init_tree) != void_type_node
2249 1289570 : && int_size_in_bytes(TREE_TYPE(init_tree)) != 0)
2250 : {
2251 644129 : DECL_INITIAL(var_tree) = init_tree;
2252 644129 : init_tree = NULL_TREE;
2253 : }
2254 :
2255 645441 : tree ret = build1_loc(DECL_SOURCE_LOCATION(var_tree), DECL_EXPR,
2256 : void_type_node, var_tree);
2257 645441 : if (init_tree != NULL_TREE)
2258 1312 : ret = build2_loc(DECL_SOURCE_LOCATION(var_tree), COMPOUND_EXPR,
2259 : void_type_node, init_tree, ret);
2260 :
2261 645441 : return this->make_statement(ret);
2262 : }
2263 :
2264 : // Assignment.
2265 :
2266 : Bstatement*
2267 1407135 : Gcc_backend::assignment_statement(Bfunction* bfn, Bexpression* lhs,
2268 : Bexpression* rhs, Location location)
2269 : {
2270 1407135 : tree lhs_tree = lhs->get_tree();
2271 1407135 : tree rhs_tree = rhs->get_tree();
2272 1407135 : if (lhs_tree == error_mark_node || rhs_tree == error_mark_node)
2273 121 : return this->error_statement();
2274 :
2275 : // To avoid problems with GNU ld, we don't make zero-sized
2276 : // externally visible variables. That might lead us to doing an
2277 : // assignment of a zero-sized expression to a non-zero sized
2278 : // expression; avoid crashes here by avoiding assignments of
2279 : // zero-sized expressions. Such assignments don't really mean
2280 : // anything anyhow.
2281 1407014 : if (TREE_TYPE(lhs_tree) == void_type_node
2282 1407014 : || int_size_in_bytes(TREE_TYPE(lhs_tree)) == 0
2283 1401596 : || TREE_TYPE(rhs_tree) == void_type_node
2284 2808610 : || int_size_in_bytes(TREE_TYPE(rhs_tree)) == 0)
2285 5418 : return this->compound_statement(this->expression_statement(bfn, lhs),
2286 10836 : this->expression_statement(bfn, rhs));
2287 :
2288 1401596 : rhs_tree = this->convert_tree(TREE_TYPE(lhs_tree), rhs_tree, location);
2289 :
2290 1401596 : return this->make_statement(fold_build2_loc(location.gcc_location(),
2291 : MODIFY_EXPR,
2292 : void_type_node,
2293 1401596 : lhs_tree, rhs_tree));
2294 : }
2295 :
2296 : // Return.
2297 :
2298 : Bstatement*
2299 378007 : Gcc_backend::return_statement(Bfunction* bfunction,
2300 : const std::vector<Bexpression*>& vals,
2301 : Location location)
2302 : {
2303 378007 : tree fntree = bfunction->get_tree();
2304 378007 : if (fntree == error_mark_node)
2305 0 : return this->error_statement();
2306 378007 : tree result = DECL_RESULT(fntree);
2307 378007 : if (result == error_mark_node)
2308 0 : return this->error_statement();
2309 :
2310 : // If the result size is zero bytes, we have set the function type
2311 : // to have a result type of void, so don't return anything.
2312 : // See the function_type method.
2313 378007 : tree res_type = TREE_TYPE(result);
2314 378007 : if (res_type == void_type_node || int_size_in_bytes(res_type) == 0)
2315 : {
2316 10956 : tree stmt_list = NULL_TREE;
2317 10970 : for (std::vector<Bexpression*>::const_iterator p = vals.begin();
2318 10970 : p != vals.end();
2319 14 : p++)
2320 : {
2321 14 : tree val = (*p)->get_tree();
2322 14 : if (val == error_mark_node)
2323 0 : return this->error_statement();
2324 14 : append_to_statement_list(val, &stmt_list);
2325 : }
2326 10956 : tree ret = fold_build1_loc(location.gcc_location(), RETURN_EXPR,
2327 : void_type_node, NULL_TREE);
2328 10956 : append_to_statement_list(ret, &stmt_list);
2329 10956 : return this->make_statement(stmt_list);
2330 : }
2331 :
2332 367051 : tree ret;
2333 367051 : if (vals.empty())
2334 0 : ret = fold_build1_loc(location.gcc_location(), RETURN_EXPR, void_type_node,
2335 : NULL_TREE);
2336 367051 : else if (vals.size() == 1)
2337 : {
2338 305276 : tree val = vals.front()->get_tree();
2339 305276 : if (val == error_mark_node)
2340 0 : return this->error_statement();
2341 305276 : tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
2342 : void_type_node, result,
2343 305276 : vals.front()->get_tree());
2344 305276 : ret = fold_build1_loc(location.gcc_location(), RETURN_EXPR,
2345 : void_type_node, set);
2346 : }
2347 : else
2348 : {
2349 : // To return multiple values, copy the values into a temporary
2350 : // variable of the right structure type, and then assign the
2351 : // temporary variable to the DECL_RESULT in the return
2352 : // statement.
2353 61775 : tree stmt_list = NULL_TREE;
2354 61775 : tree rettype = TREE_TYPE(result);
2355 :
2356 61775 : if (DECL_STRUCT_FUNCTION(fntree) == NULL)
2357 283 : push_struct_function(fntree);
2358 : else
2359 61492 : push_cfun(DECL_STRUCT_FUNCTION(fntree));
2360 61775 : tree rettmp = create_tmp_var(rettype, "RESULT");
2361 61775 : pop_cfun();
2362 :
2363 61775 : tree field = TYPE_FIELDS(rettype);
2364 61775 : for (std::vector<Bexpression*>::const_iterator p = vals.begin();
2365 198361 : p != vals.end();
2366 136586 : p++, field = DECL_CHAIN(field))
2367 : {
2368 136586 : gcc_assert(field != NULL_TREE);
2369 136586 : tree ref = fold_build3_loc(location.gcc_location(), COMPONENT_REF,
2370 136586 : TREE_TYPE(field), rettmp, field,
2371 : NULL_TREE);
2372 136586 : tree val = (*p)->get_tree();
2373 136586 : if (val == error_mark_node)
2374 0 : return this->error_statement();
2375 273172 : tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
2376 : void_type_node,
2377 136586 : ref, (*p)->get_tree());
2378 136586 : append_to_statement_list(set, &stmt_list);
2379 : }
2380 61775 : gcc_assert(field == NULL_TREE);
2381 61775 : tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
2382 : void_type_node,
2383 : result, rettmp);
2384 61775 : tree ret_expr = fold_build1_loc(location.gcc_location(), RETURN_EXPR,
2385 : void_type_node, set);
2386 61775 : append_to_statement_list(ret_expr, &stmt_list);
2387 61775 : ret = stmt_list;
2388 : }
2389 367051 : return this->make_statement(ret);
2390 : }
2391 :
2392 : // Create a statement that attempts to execute BSTAT and calls EXCEPT_STMT if an
2393 : // error occurs. EXCEPT_STMT may be NULL. FINALLY_STMT may be NULL and if not
2394 : // NULL, it will always be executed. This is used for handling defers in Go
2395 : // functions. In C++, the resulting code is of this form:
2396 : // try { BSTAT; } catch { EXCEPT_STMT; } finally { FINALLY_STMT; }
2397 :
2398 : Bstatement*
2399 8353 : Gcc_backend::exception_handler_statement(Bstatement* bstat,
2400 : Bstatement* except_stmt,
2401 : Bstatement* finally_stmt,
2402 : Location location)
2403 : {
2404 8353 : tree stat_tree = bstat->get_tree();
2405 8353 : tree except_tree = except_stmt == NULL ? NULL_TREE : except_stmt->get_tree();
2406 8353 : tree finally_tree = finally_stmt == NULL
2407 8353 : ? NULL_TREE
2408 8353 : : finally_stmt->get_tree();
2409 :
2410 8353 : if (stat_tree == error_mark_node
2411 8353 : || except_tree == error_mark_node
2412 8353 : || finally_tree == error_mark_node)
2413 0 : return this->error_statement();
2414 :
2415 8353 : if (except_tree != NULL_TREE)
2416 8353 : stat_tree = build2_loc(location.gcc_location(), TRY_CATCH_EXPR,
2417 : void_type_node, stat_tree,
2418 : build2_loc(location.gcc_location(), CATCH_EXPR,
2419 : void_type_node, NULL, except_tree));
2420 8353 : if (finally_tree != NULL_TREE)
2421 8353 : stat_tree = build2_loc(location.gcc_location(), TRY_FINALLY_EXPR,
2422 : void_type_node, stat_tree, finally_tree);
2423 8353 : return this->make_statement(stat_tree);
2424 : }
2425 :
2426 : // If.
2427 :
2428 : Bstatement*
2429 699649 : Gcc_backend::if_statement(Bfunction*, Bexpression* condition,
2430 : Bblock* then_block, Bblock* else_block,
2431 : Location location)
2432 : {
2433 699649 : tree cond_tree = condition->get_tree();
2434 699649 : tree then_tree = then_block->get_tree();
2435 699649 : tree else_tree = else_block == NULL ? NULL_TREE : else_block->get_tree();
2436 699649 : if (cond_tree == error_mark_node
2437 699645 : || then_tree == error_mark_node
2438 699645 : || else_tree == error_mark_node)
2439 4 : return this->error_statement();
2440 699645 : tree ret = build3_loc(location.gcc_location(), COND_EXPR, void_type_node,
2441 : cond_tree, then_tree, else_tree);
2442 699645 : return this->make_statement(ret);
2443 : }
2444 :
2445 : // Switch.
2446 :
2447 : Bstatement*
2448 7785 : Gcc_backend::switch_statement(
2449 : Bfunction* function,
2450 : Bexpression* value,
2451 : const std::vector<std::vector<Bexpression*> >& cases,
2452 : const std::vector<Bstatement*>& statements,
2453 : Location switch_location)
2454 : {
2455 7785 : gcc_assert(cases.size() == statements.size());
2456 :
2457 7785 : tree decl = function->get_tree();
2458 7785 : if (DECL_STRUCT_FUNCTION(decl) == NULL)
2459 2 : push_struct_function(decl);
2460 : else
2461 7783 : push_cfun(DECL_STRUCT_FUNCTION(decl));
2462 :
2463 7785 : tree stmt_list = NULL_TREE;
2464 7785 : std::vector<std::vector<Bexpression*> >::const_iterator pc = cases.begin();
2465 7785 : for (std::vector<Bstatement*>::const_iterator ps = statements.begin();
2466 39947 : ps != statements.end();
2467 32162 : ++ps, ++pc)
2468 : {
2469 32165 : if (pc->empty())
2470 : {
2471 4631 : location_t loc = (*ps != NULL
2472 4631 : ? EXPR_LOCATION((*ps)->get_tree())
2473 1994 : : UNKNOWN_LOCATION);
2474 4631 : tree label = create_artificial_label(loc);
2475 4631 : tree c = build_case_label(NULL_TREE, NULL_TREE, label);
2476 4631 : append_to_statement_list(c, &stmt_list);
2477 : }
2478 : else
2479 : {
2480 39894 : for (std::vector<Bexpression*>::const_iterator pcv = pc->begin();
2481 67428 : pcv != pc->end();
2482 39894 : ++pcv)
2483 : {
2484 39895 : tree t = (*pcv)->get_tree();
2485 39895 : if (t == error_mark_node)
2486 1 : return this->error_statement();
2487 39894 : location_t loc = EXPR_LOCATION(t);
2488 39894 : tree label = create_artificial_label(loc);
2489 39894 : tree c = build_case_label((*pcv)->get_tree(), NULL_TREE, label);
2490 39894 : append_to_statement_list(c, &stmt_list);
2491 : }
2492 : }
2493 :
2494 32164 : if (*ps != NULL)
2495 : {
2496 32147 : tree t = (*ps)->get_tree();
2497 32147 : if (t == error_mark_node)
2498 2 : return this->error_statement();
2499 32145 : append_to_statement_list(t, &stmt_list);
2500 : }
2501 : }
2502 7782 : pop_cfun();
2503 :
2504 7782 : tree tv = value->get_tree();
2505 7782 : if (tv == error_mark_node)
2506 0 : return this->error_statement();
2507 7782 : tree t = build2_loc(switch_location.gcc_location(), SWITCH_EXPR,
2508 : NULL_TREE, tv, stmt_list);
2509 7782 : return this->make_statement(t);
2510 : }
2511 :
2512 : // Pair of statements.
2513 :
2514 : Bstatement*
2515 674575 : Gcc_backend::compound_statement(Bstatement* s1, Bstatement* s2)
2516 : {
2517 674575 : tree stmt_list = NULL_TREE;
2518 674575 : tree t = s1->get_tree();
2519 674575 : if (t == error_mark_node)
2520 9 : return this->error_statement();
2521 674566 : append_to_statement_list(t, &stmt_list);
2522 674566 : t = s2->get_tree();
2523 674566 : if (t == error_mark_node)
2524 8 : return this->error_statement();
2525 674558 : append_to_statement_list(t, &stmt_list);
2526 :
2527 : // If neither statement has any side effects, stmt_list can be NULL
2528 : // at this point.
2529 674558 : if (stmt_list == NULL_TREE)
2530 5415 : stmt_list = integer_zero_node;
2531 :
2532 674558 : return this->make_statement(stmt_list);
2533 : }
2534 :
2535 : // List of statements.
2536 :
2537 : Bstatement*
2538 337478 : Gcc_backend::statement_list(const std::vector<Bstatement*>& statements)
2539 : {
2540 337478 : tree stmt_list = NULL_TREE;
2541 713228 : for (std::vector<Bstatement*>::const_iterator p = statements.begin();
2542 713228 : p != statements.end();
2543 375750 : ++p)
2544 : {
2545 375795 : tree t = (*p)->get_tree();
2546 375795 : if (t == error_mark_node)
2547 45 : return this->error_statement();
2548 375750 : append_to_statement_list(t, &stmt_list);
2549 : }
2550 337433 : return this->make_statement(stmt_list);
2551 : }
2552 :
2553 : // Make a block. For some reason gcc uses a dual structure for
2554 : // blocks: BLOCK tree nodes and BIND_EXPR tree nodes. Since the
2555 : // BIND_EXPR node points to the BLOCK node, we store the BIND_EXPR in
2556 : // the Bblock.
2557 :
2558 : Bblock*
2559 2862174 : Gcc_backend::block(Bfunction* function, Bblock* enclosing,
2560 : const std::vector<Bvariable*>& vars,
2561 : Location start_location,
2562 : Location)
2563 : {
2564 2862174 : tree block_tree = make_node(BLOCK);
2565 2862174 : if (enclosing == NULL)
2566 : {
2567 552028 : tree fndecl = function->get_tree();
2568 552028 : gcc_assert(fndecl != NULL_TREE);
2569 :
2570 : // We may have already created a block for local variables when
2571 : // we take the address of a parameter.
2572 552028 : if (DECL_INITIAL(fndecl) == NULL_TREE)
2573 : {
2574 299040 : BLOCK_SUPERCONTEXT(block_tree) = fndecl;
2575 299040 : DECL_INITIAL(fndecl) = block_tree;
2576 : }
2577 : else
2578 : {
2579 252988 : tree superblock_tree = DECL_INITIAL(fndecl);
2580 252988 : BLOCK_SUPERCONTEXT(block_tree) = superblock_tree;
2581 252988 : tree* pp;
2582 252988 : for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
2583 1565648 : *pp != NULL_TREE;
2584 1312660 : pp = &BLOCK_CHAIN(*pp))
2585 : ;
2586 252988 : *pp = block_tree;
2587 : }
2588 : }
2589 : else
2590 : {
2591 2310146 : tree superbind_tree = enclosing->get_tree();
2592 2310146 : tree superblock_tree = BIND_EXPR_BLOCK(superbind_tree);
2593 2310146 : gcc_assert(TREE_CODE(superblock_tree) == BLOCK);
2594 :
2595 2310146 : BLOCK_SUPERCONTEXT(block_tree) = superblock_tree;
2596 2310146 : tree* pp;
2597 2310146 : for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
2598 34321148 : *pp != NULL_TREE;
2599 32011002 : pp = &BLOCK_CHAIN(*pp))
2600 : ;
2601 2310146 : *pp = block_tree;
2602 : }
2603 :
2604 2862174 : tree* pp = &BLOCK_VARS(block_tree);
2605 3507671 : for (std::vector<Bvariable*>::const_iterator pv = vars.begin();
2606 3507671 : pv != vars.end();
2607 645497 : ++pv)
2608 : {
2609 645497 : *pp = (*pv)->get_decl();
2610 645497 : if (*pp != error_mark_node)
2611 645454 : pp = &DECL_CHAIN(*pp);
2612 : }
2613 2862174 : *pp = NULL_TREE;
2614 :
2615 2862174 : TREE_USED(block_tree) = 1;
2616 :
2617 2862174 : tree bind_tree = build3_loc(start_location.gcc_location(), BIND_EXPR,
2618 2862174 : void_type_node, BLOCK_VARS(block_tree),
2619 : NULL_TREE, block_tree);
2620 2862174 : TREE_SIDE_EFFECTS(bind_tree) = 1;
2621 2862174 : return new Bblock(bind_tree);
2622 : }
2623 :
2624 : // Add statements to a block.
2625 :
2626 : void
2627 2858725 : Gcc_backend::block_add_statements(Bblock* bblock,
2628 : const std::vector<Bstatement*>& statements)
2629 : {
2630 2858725 : tree stmt_list = NULL_TREE;
2631 10114307 : for (std::vector<Bstatement*>::const_iterator p = statements.begin();
2632 10114307 : p != statements.end();
2633 7255582 : ++p)
2634 : {
2635 7255582 : tree s = (*p)->get_tree();
2636 7255582 : if (s != error_mark_node)
2637 7251601 : append_to_statement_list(s, &stmt_list);
2638 : }
2639 :
2640 2858725 : tree bind_tree = bblock->get_tree();
2641 2858725 : gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
2642 2858725 : BIND_EXPR_BODY(bind_tree) = stmt_list;
2643 2858725 : }
2644 :
2645 : // Return a block as a statement.
2646 :
2647 : Bstatement*
2648 1923484 : Gcc_backend::block_statement(Bblock* bblock)
2649 : {
2650 1923484 : tree bind_tree = bblock->get_tree();
2651 1923484 : gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
2652 1923484 : return this->make_statement(bind_tree);
2653 : }
2654 :
2655 : // This is not static because we declare it with GTY(()) in go-c.h.
2656 : tree go_non_zero_struct;
2657 :
2658 : // Return a type corresponding to TYPE with non-zero size.
2659 :
2660 : tree
2661 415 : Gcc_backend::non_zero_size_type(tree type)
2662 : {
2663 415 : if (int_size_in_bytes(type) != 0)
2664 : return type;
2665 :
2666 413 : switch (TREE_CODE(type))
2667 : {
2668 410 : case RECORD_TYPE:
2669 410 : if (TYPE_FIELDS(type) != NULL_TREE)
2670 : {
2671 2 : tree ns = make_node(RECORD_TYPE);
2672 2 : tree field_trees = NULL_TREE;
2673 2 : tree *pp = &field_trees;
2674 2 : for (tree field = TYPE_FIELDS(type);
2675 4 : field != NULL_TREE;
2676 2 : field = DECL_CHAIN(field))
2677 : {
2678 2 : tree ft = TREE_TYPE(field);
2679 2 : if (field == TYPE_FIELDS(type))
2680 2 : ft = non_zero_size_type(ft);
2681 2 : tree f = build_decl(DECL_SOURCE_LOCATION(field), FIELD_DECL,
2682 2 : DECL_NAME(field), ft);
2683 2 : DECL_CONTEXT(f) = ns;
2684 2 : *pp = f;
2685 2 : pp = &DECL_CHAIN(f);
2686 : }
2687 2 : TYPE_FIELDS(ns) = field_trees;
2688 2 : layout_type(ns);
2689 2 : return ns;
2690 : }
2691 :
2692 408 : if (go_non_zero_struct == NULL_TREE)
2693 : {
2694 298 : type = make_node(RECORD_TYPE);
2695 298 : tree field = build_decl(UNKNOWN_LOCATION, FIELD_DECL,
2696 : get_identifier("dummy"),
2697 : boolean_type_node);
2698 298 : DECL_CONTEXT(field) = type;
2699 298 : TYPE_FIELDS(type) = field;
2700 298 : layout_type(type);
2701 298 : go_non_zero_struct = type;
2702 : }
2703 408 : return go_non_zero_struct;
2704 :
2705 3 : case ARRAY_TYPE:
2706 3 : {
2707 3 : tree element_type = non_zero_size_type(TREE_TYPE(type));
2708 3 : return build_array_type_nelts(element_type, 1);
2709 : }
2710 :
2711 0 : default:
2712 0 : gcc_unreachable();
2713 : }
2714 :
2715 : gcc_unreachable();
2716 : }
2717 :
2718 : // Convert EXPR_TREE to TYPE_TREE. Sometimes the same unnamed Go type
2719 : // can be created multiple times and thus have multiple tree
2720 : // representations. Make sure this does not confuse the middle-end.
2721 :
2722 : tree
2723 13329781 : Gcc_backend::convert_tree(tree type_tree, tree expr_tree, Location location)
2724 : {
2725 13329781 : if (type_tree == TREE_TYPE(expr_tree))
2726 : return expr_tree;
2727 :
2728 3364682 : if (type_tree == error_mark_node
2729 3364682 : || expr_tree == error_mark_node
2730 6729364 : || TREE_TYPE(expr_tree) == error_mark_node)
2731 : return error_mark_node;
2732 :
2733 3364682 : gcc_assert(TREE_CODE(type_tree) == TREE_CODE(TREE_TYPE(expr_tree)));
2734 3364682 : if (POINTER_TYPE_P(type_tree)
2735 3364682 : || INTEGRAL_TYPE_P(type_tree)
2736 233558 : || SCALAR_FLOAT_TYPE_P(type_tree)
2737 3598240 : || COMPLEX_FLOAT_TYPE_P(type_tree))
2738 3131126 : return fold_convert_loc(location.gcc_location(), type_tree, expr_tree);
2739 233556 : else if (TREE_CODE(type_tree) == RECORD_TYPE
2740 233556 : || TREE_CODE(type_tree) == ARRAY_TYPE)
2741 : {
2742 233556 : gcc_assert(int_size_in_bytes(type_tree)
2743 : == int_size_in_bytes(TREE_TYPE(expr_tree)));
2744 233556 : if (TYPE_MAIN_VARIANT(type_tree)
2745 233556 : == TYPE_MAIN_VARIANT(TREE_TYPE(expr_tree)))
2746 140587 : return fold_build1_loc(location.gcc_location(), NOP_EXPR,
2747 140587 : type_tree, expr_tree);
2748 92969 : return fold_build1_loc(location.gcc_location(), VIEW_CONVERT_EXPR,
2749 92969 : type_tree, expr_tree);
2750 : }
2751 :
2752 0 : gcc_unreachable();
2753 : }
2754 :
2755 : // Make a global variable.
2756 :
2757 : Bvariable*
2758 34342 : Gcc_backend::global_variable(const std::string& var_name,
2759 : const std::string& asm_name,
2760 : Btype* btype,
2761 : unsigned int flags,
2762 : Location location)
2763 : {
2764 34342 : tree type_tree = btype->get_tree();
2765 34342 : if (type_tree == error_mark_node)
2766 2 : return this->error_variable();
2767 :
2768 : // The GNU linker does not like dynamic variables with zero size.
2769 34340 : tree orig_type_tree = type_tree;
2770 34340 : bool is_external = (flags & variable_is_external) != 0;
2771 34340 : bool is_hidden = (flags & variable_is_hidden) != 0;
2772 34340 : if ((is_external || !is_hidden) && int_size_in_bytes(type_tree) == 0)
2773 410 : type_tree = this->non_zero_size_type(type_tree);
2774 :
2775 68680 : tree decl = build_decl(location.gcc_location(), VAR_DECL,
2776 : get_identifier_from_string(var_name),
2777 : type_tree);
2778 34340 : if ((flags & variable_is_external) != 0)
2779 : {
2780 9045 : DECL_EXTERNAL(decl) = 1;
2781 9045 : flags &=~ variable_is_external;
2782 : }
2783 : else
2784 25295 : TREE_STATIC(decl) = 1;
2785 :
2786 34340 : if ((flags & variable_is_hidden) == 0)
2787 16416 : TREE_PUBLIC(decl) = 1;
2788 : else
2789 17924 : flags &=~ variable_is_hidden;
2790 :
2791 34340 : if ((flags & variable_address_is_taken) != 0)
2792 : {
2793 3542 : TREE_ADDRESSABLE(decl) = 1;
2794 3542 : flags &=~ variable_address_is_taken;
2795 : }
2796 :
2797 : // We take the address in Bvariable::get_tree if orig_type_tree is
2798 : // different from type_tree.
2799 34340 : if (orig_type_tree != type_tree)
2800 410 : TREE_ADDRESSABLE(decl) = 1;
2801 :
2802 68680 : SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
2803 :
2804 34340 : TREE_USED(decl) = 1;
2805 :
2806 34340 : if ((flags & variable_in_unique_section) != 0)
2807 : {
2808 0 : resolve_unique_section (decl, 0, 1);
2809 0 : flags &=~ variable_in_unique_section;
2810 : }
2811 :
2812 34340 : gcc_assert(flags == 0);
2813 :
2814 34340 : go_preserve_from_gc(decl);
2815 :
2816 34340 : return new Bvariable(decl, orig_type_tree);
2817 : }
2818 :
2819 : // Set the initial value of a global variable.
2820 :
2821 : void
2822 7290 : Gcc_backend::global_variable_set_init(Bvariable* var, Bexpression* expr)
2823 : {
2824 7290 : tree expr_tree = expr->get_tree();
2825 7290 : if (expr_tree == error_mark_node)
2826 : return;
2827 7290 : gcc_assert(TREE_CONSTANT(expr_tree));
2828 7290 : tree var_decl = var->get_decl();
2829 7290 : if (var_decl == error_mark_node)
2830 : return;
2831 7290 : DECL_INITIAL(var_decl) = expr_tree;
2832 :
2833 : // If this variable goes in a unique section, it may need to go into
2834 : // a different one now that DECL_INITIAL is set.
2835 7290 : if (symtab_node::get(var_decl)
2836 7290 : && symtab_node::get(var_decl)->implicit_section)
2837 : {
2838 0 : set_decl_section_name (var_decl, (const char *) NULL);
2839 0 : resolve_unique_section (var_decl,
2840 : compute_reloc_for_constant (expr_tree),
2841 : 1);
2842 : }
2843 : }
2844 :
2845 : // Make a local variable.
2846 :
2847 : Bvariable*
2848 645463 : Gcc_backend::local_variable(Bfunction* function, const std::string& name,
2849 : Btype* btype, Bvariable* decl_var,
2850 : unsigned int flags, Location location)
2851 : {
2852 645463 : tree type_tree = btype->get_tree();
2853 645463 : if (type_tree == error_mark_node)
2854 4 : return this->error_variable();
2855 1290918 : tree decl = build_decl(location.gcc_location(), VAR_DECL,
2856 : get_identifier_from_string(name),
2857 : type_tree);
2858 645459 : DECL_CONTEXT(decl) = function->get_tree();
2859 645459 : TREE_USED(decl) = 1;
2860 645459 : if ((flags & variable_address_is_taken) != 0)
2861 : {
2862 25283 : TREE_ADDRESSABLE(decl) = 1;
2863 25283 : flags &=~ variable_address_is_taken;
2864 : }
2865 645459 : if (decl_var != NULL)
2866 : {
2867 6520 : DECL_HAS_VALUE_EXPR_P(decl) = 1;
2868 6520 : SET_DECL_VALUE_EXPR(decl, decl_var->get_decl());
2869 : }
2870 645459 : go_assert(flags == 0);
2871 645459 : go_preserve_from_gc(decl);
2872 645459 : return new Bvariable(decl);
2873 : }
2874 :
2875 : // Make a function parameter variable.
2876 :
2877 : Bvariable*
2878 474382 : Gcc_backend::parameter_variable(Bfunction* function, const std::string& name,
2879 : Btype* btype, unsigned int flags,
2880 : Location location)
2881 : {
2882 474382 : tree type_tree = btype->get_tree();
2883 474382 : if (type_tree == error_mark_node)
2884 6 : return this->error_variable();
2885 948752 : tree decl = build_decl(location.gcc_location(), PARM_DECL,
2886 : get_identifier_from_string(name),
2887 : type_tree);
2888 474376 : DECL_CONTEXT(decl) = function->get_tree();
2889 474376 : DECL_ARG_TYPE(decl) = type_tree;
2890 474376 : TREE_USED(decl) = 1;
2891 474376 : if ((flags & variable_address_is_taken) != 0)
2892 : {
2893 8144 : TREE_ADDRESSABLE(decl) = 1;
2894 8144 : flags &=~ variable_address_is_taken;
2895 : }
2896 474376 : go_assert(flags == 0);
2897 474376 : go_preserve_from_gc(decl);
2898 474376 : return new Bvariable(decl);
2899 : }
2900 :
2901 : // Make a static chain variable.
2902 :
2903 : Bvariable*
2904 14291 : Gcc_backend::static_chain_variable(Bfunction* function, const std::string& name,
2905 : Btype* btype, unsigned int flags,
2906 : Location location)
2907 : {
2908 14291 : tree type_tree = btype->get_tree();
2909 14291 : if (type_tree == error_mark_node)
2910 1 : return this->error_variable();
2911 28580 : tree decl = build_decl(location.gcc_location(), PARM_DECL,
2912 : get_identifier_from_string(name), type_tree);
2913 14290 : tree fndecl = function->get_tree();
2914 14290 : DECL_CONTEXT(decl) = fndecl;
2915 14290 : DECL_ARG_TYPE(decl) = type_tree;
2916 14290 : TREE_USED(decl) = 1;
2917 14290 : DECL_ARTIFICIAL(decl) = 1;
2918 14290 : DECL_IGNORED_P(decl) = 1;
2919 14290 : DECL_NAMELESS(decl) = 1;
2920 14290 : TREE_READONLY(decl) = 1;
2921 :
2922 14290 : struct function *f = DECL_STRUCT_FUNCTION(fndecl);
2923 14290 : if (f == NULL)
2924 : {
2925 14290 : push_struct_function(fndecl);
2926 14290 : pop_cfun();
2927 14290 : f = DECL_STRUCT_FUNCTION(fndecl);
2928 : }
2929 14290 : gcc_assert(f->static_chain_decl == NULL);
2930 14290 : f->static_chain_decl = decl;
2931 14290 : DECL_STATIC_CHAIN(fndecl) = 1;
2932 14290 : go_assert(flags == 0);
2933 :
2934 14290 : go_preserve_from_gc(decl);
2935 14290 : return new Bvariable(decl);
2936 : }
2937 :
2938 : // Make a temporary variable.
2939 :
2940 : Bvariable*
2941 2273528 : Gcc_backend::temporary_variable(Bfunction* function, Bblock* bblock,
2942 : Btype* btype, Bexpression* binit,
2943 : unsigned int flags,
2944 : Location location,
2945 : Bstatement** pstatement)
2946 : {
2947 2273528 : gcc_assert(function != NULL);
2948 2273528 : tree decl = function->get_tree();
2949 2273528 : tree type_tree = btype->get_tree();
2950 2273528 : tree init_tree = binit == NULL ? NULL_TREE : binit->get_tree();
2951 2273528 : if (type_tree == error_mark_node
2952 2273527 : || init_tree == error_mark_node
2953 2273522 : || decl == error_mark_node)
2954 : {
2955 6 : *pstatement = this->error_statement();
2956 6 : return this->error_variable();
2957 : }
2958 :
2959 2273522 : tree var;
2960 : // We can only use create_tmp_var if the type is not addressable.
2961 2273522 : if (!TREE_ADDRESSABLE(type_tree))
2962 : {
2963 2273522 : if (DECL_STRUCT_FUNCTION(decl) == NULL)
2964 230464 : push_struct_function(decl);
2965 : else
2966 2043058 : push_cfun(DECL_STRUCT_FUNCTION(decl));
2967 :
2968 2273522 : var = create_tmp_var(type_tree, "GOTMP");
2969 2273522 : pop_cfun();
2970 : }
2971 : else
2972 : {
2973 0 : gcc_assert(bblock != NULL);
2974 0 : var = build_decl(location.gcc_location(), VAR_DECL,
2975 : create_tmp_var_name("GOTMP"),
2976 : type_tree);
2977 0 : DECL_ARTIFICIAL(var) = 1;
2978 0 : DECL_IGNORED_P(var) = 1;
2979 0 : DECL_NAMELESS(var) = 1;
2980 0 : TREE_USED(var) = 1;
2981 0 : DECL_CONTEXT(var) = decl;
2982 :
2983 : // We have to add this variable to the BLOCK and the BIND_EXPR.
2984 0 : tree bind_tree = bblock->get_tree();
2985 0 : gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
2986 0 : tree block_tree = BIND_EXPR_BLOCK(bind_tree);
2987 0 : gcc_assert(TREE_CODE(block_tree) == BLOCK);
2988 0 : DECL_CHAIN(var) = BLOCK_VARS(block_tree);
2989 0 : BLOCK_VARS(block_tree) = var;
2990 0 : BIND_EXPR_VARS(bind_tree) = BLOCK_VARS(block_tree);
2991 : }
2992 :
2993 2273522 : if (this->type_size(btype) != 0
2994 2269963 : && init_tree != NULL_TREE
2995 4321441 : && TREE_TYPE(init_tree) != void_type_node)
2996 2047918 : DECL_INITIAL(var) = this->convert_tree(type_tree, init_tree, location);
2997 :
2998 2273522 : if ((flags & variable_address_is_taken) != 0)
2999 : {
3000 413098 : TREE_ADDRESSABLE(var) = 1;
3001 413098 : flags &=~ variable_address_is_taken;
3002 : }
3003 :
3004 2273522 : gcc_assert(flags == 0);
3005 :
3006 2273522 : *pstatement = this->make_statement(build1_loc(location.gcc_location(),
3007 : DECL_EXPR,
3008 : void_type_node, var));
3009 :
3010 : // For a zero sized type, don't initialize VAR with BINIT, but still
3011 : // evaluate BINIT for its side effects.
3012 2273522 : if (init_tree != NULL_TREE
3013 2273522 : && (this->type_size(btype) == 0
3014 2047919 : || TREE_TYPE(init_tree) == void_type_node))
3015 1372 : *pstatement =
3016 1372 : this->compound_statement(this->expression_statement(function, binit),
3017 : *pstatement);
3018 :
3019 2273522 : return new Bvariable(var);
3020 : }
3021 :
3022 : // Create an implicit variable that is compiler-defined. This is used when
3023 : // generating GC root variables and storing the values of a slice initializer.
3024 :
3025 : Bvariable*
3026 334389 : Gcc_backend::implicit_variable(const std::string& name,
3027 : const std::string& asm_name,
3028 : Btype* type, unsigned int flags,
3029 : int64_t alignment)
3030 : {
3031 334389 : tree type_tree = type->get_tree();
3032 334389 : if (type_tree == error_mark_node)
3033 0 : return this->error_variable();
3034 :
3035 668778 : tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
3036 : get_identifier_from_string(name), type_tree);
3037 334389 : DECL_EXTERNAL(decl) = 0;
3038 334389 : if ((flags & variable_is_hidden) != 0)
3039 306115 : flags &=~ variable_is_hidden;
3040 : else
3041 28274 : TREE_PUBLIC(decl) = 1;
3042 334389 : TREE_STATIC(decl) = 1;
3043 334389 : TREE_USED(decl) = 1;
3044 334389 : DECL_ARTIFICIAL(decl) = 1;
3045 334389 : if ((flags & variable_is_common) != 0)
3046 : {
3047 23630 : DECL_COMMON(decl) = 1;
3048 :
3049 : // When the initializer for one implicit_variable refers to another,
3050 : // it needs to know the visibility of the referenced struct so that
3051 : // compute_reloc_for_constant will return the right value. On many
3052 : // systems calling make_decl_one_only will mark the decl as weak,
3053 : // which will change the return value of compute_reloc_for_constant.
3054 : // We can't reliably call make_decl_one_only yet, because we don't
3055 : // yet know the initializer. This issue doesn't arise in C because
3056 : // Go initializers, unlike C initializers, can be indirectly
3057 : // recursive. To ensure that compute_reloc_for_constant computes
3058 : // the right value if some other initializer refers to this one, we
3059 : // mark this symbol as weak here. We undo that below in
3060 : // immutable_struct_set_init before calling mark_decl_one_only.
3061 23630 : DECL_WEAK(decl) = 1;
3062 :
3063 23630 : flags &=~ variable_is_common;
3064 : }
3065 334389 : if ((flags & variable_is_constant) != 0)
3066 : {
3067 323412 : TREE_READONLY(decl) = 1;
3068 323412 : TREE_CONSTANT(decl) = 1;
3069 323412 : flags &=~ variable_is_constant;
3070 : }
3071 334389 : if ((flags & variable_address_is_taken) != 0)
3072 : {
3073 304192 : TREE_ADDRESSABLE(decl) = 1;
3074 304192 : flags &=~ variable_address_is_taken;
3075 : }
3076 334389 : if (alignment != 0)
3077 : {
3078 3 : SET_DECL_ALIGN(decl, alignment * BITS_PER_UNIT);
3079 3 : DECL_USER_ALIGN(decl) = 1;
3080 : }
3081 334389 : if (! asm_name.empty())
3082 13066 : SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
3083 334389 : gcc_assert(flags == 0);
3084 :
3085 334389 : go_preserve_from_gc(decl);
3086 334389 : return new Bvariable(decl);
3087 : }
3088 :
3089 : // Set the initalizer for a variable created by implicit_variable.
3090 : // This is where we finish compiling the variable.
3091 :
3092 : void
3093 334389 : Gcc_backend::implicit_variable_set_init(Bvariable* var, const std::string&,
3094 : Btype*, unsigned int flags,
3095 : Bexpression* init)
3096 : {
3097 334389 : tree decl = var->get_decl();
3098 334389 : tree init_tree;
3099 334389 : if (init == NULL)
3100 : init_tree = NULL_TREE;
3101 : else
3102 334386 : init_tree = init->get_tree();
3103 334389 : if (decl == error_mark_node || init_tree == error_mark_node)
3104 : return;
3105 :
3106 334387 : DECL_INITIAL(decl) = init_tree;
3107 :
3108 : // Now that DECL_INITIAL is set, we can't call make_decl_one_only.
3109 : // See the comment where DECL_WEAK is set in implicit_variable.
3110 334387 : if ((flags & variable_is_common) != 0)
3111 : {
3112 23630 : DECL_WEAK(decl) = 0;
3113 23630 : make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
3114 : }
3115 :
3116 334387 : resolve_unique_section(decl, 2, 1);
3117 :
3118 334387 : rest_of_decl_compilation(decl, 1, 0);
3119 : }
3120 :
3121 : // Return a reference to an implicit variable defined in another package.
3122 :
3123 : Bvariable*
3124 64317 : Gcc_backend::implicit_variable_reference(const std::string& name,
3125 : const std::string& asm_name,
3126 : Btype* btype)
3127 : {
3128 64317 : tree type_tree = btype->get_tree();
3129 64317 : if (type_tree == error_mark_node)
3130 0 : return this->error_variable();
3131 :
3132 128634 : tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
3133 : get_identifier_from_string(name), type_tree);
3134 64317 : DECL_EXTERNAL(decl) = 1;
3135 64317 : TREE_PUBLIC(decl) = 1;
3136 64317 : TREE_STATIC(decl) = 0;
3137 64317 : DECL_ARTIFICIAL(decl) = 1;
3138 64317 : if (! asm_name.empty())
3139 128634 : SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
3140 64317 : go_preserve_from_gc(decl);
3141 64317 : return new Bvariable(decl);
3142 : }
3143 :
3144 : // Create a named immutable initialized data structure.
3145 :
3146 : Bvariable*
3147 1132645 : Gcc_backend::immutable_struct(const std::string& name,
3148 : const std::string& asm_name,
3149 : unsigned int flags, Btype* btype,
3150 : Location location)
3151 : {
3152 1132645 : tree type_tree = btype->get_tree();
3153 1132645 : if (type_tree == error_mark_node)
3154 5 : return this->error_variable();
3155 1132640 : gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
3156 2265280 : tree decl = build_decl(location.gcc_location(), VAR_DECL,
3157 : get_identifier_from_string(name),
3158 : build_qualified_type(type_tree, TYPE_QUAL_CONST));
3159 1132640 : TREE_STATIC(decl) = 1;
3160 1132640 : TREE_USED(decl) = 1;
3161 1132640 : TREE_READONLY(decl) = 1;
3162 1132640 : TREE_CONSTANT(decl) = 1;
3163 1132640 : DECL_ARTIFICIAL(decl) = 1;
3164 1132640 : if ((flags & variable_is_hidden) != 0)
3165 757499 : flags &=~ variable_is_hidden;
3166 : else
3167 375141 : TREE_PUBLIC(decl) = 1;
3168 1132640 : if (! asm_name.empty())
3169 485388 : SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
3170 1132640 : if ((flags & variable_address_is_taken) != 0)
3171 : {
3172 710668 : TREE_ADDRESSABLE(decl) = 1;
3173 710668 : flags &=~ variable_address_is_taken;
3174 : }
3175 :
3176 : // When the initializer for one immutable_struct refers to another,
3177 : // it needs to know the visibility of the referenced struct so that
3178 : // compute_reloc_for_constant will return the right value. On many
3179 : // systems calling make_decl_one_only will mark the decl as weak,
3180 : // which will change the return value of compute_reloc_for_constant.
3181 : // We can't reliably call make_decl_one_only yet, because we don't
3182 : // yet know the initializer. This issue doesn't arise in C because
3183 : // Go initializers, unlike C initializers, can be indirectly
3184 : // recursive. To ensure that compute_reloc_for_constant computes
3185 : // the right value if some other initializer refers to this one, we
3186 : // mark this symbol as weak here. We undo that below in
3187 : // immutable_struct_set_init before calling mark_decl_one_only.
3188 1132640 : if ((flags & variable_is_common) != 0)
3189 : {
3190 215339 : DECL_WEAK(decl) = 1;
3191 215339 : flags &=~ variable_is_common;
3192 : }
3193 :
3194 1132640 : gcc_assert(flags == 0);
3195 :
3196 : // We don't call rest_of_decl_compilation until we have the
3197 : // initializer.
3198 :
3199 1132640 : go_preserve_from_gc(decl);
3200 1132640 : return new Bvariable(decl);
3201 : }
3202 :
3203 : // Set the initializer for a variable created by immutable_struct.
3204 : // This is where we finish compiling the variable.
3205 :
3206 : void
3207 1132645 : Gcc_backend::immutable_struct_set_init(Bvariable* var, const std::string&,
3208 : unsigned int flags, Btype*, Location,
3209 : Bexpression* initializer)
3210 : {
3211 1132645 : tree decl = var->get_decl();
3212 1132645 : tree init_tree = initializer->get_tree();
3213 1132645 : if (decl == error_mark_node || init_tree == error_mark_node)
3214 : return;
3215 :
3216 1132639 : DECL_INITIAL(decl) = init_tree;
3217 :
3218 : // Now that DECL_INITIAL is set, we can't call make_decl_one_only.
3219 : // See the comment where DECL_WEAK is set in immutable_struct.
3220 1132639 : if ((flags & variable_is_common) != 0)
3221 : {
3222 215338 : DECL_WEAK(decl) = 0;
3223 215338 : make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
3224 : }
3225 :
3226 : // These variables are often unneeded in the final program, so put
3227 : // them in their own section so that linker GC can discard them.
3228 1132639 : resolve_unique_section(decl,
3229 : compute_reloc_for_constant (init_tree),
3230 : 1);
3231 :
3232 1132639 : rest_of_decl_compilation(decl, 1, 0);
3233 : }
3234 :
3235 : // Return a reference to an immutable initialized data structure
3236 : // defined in another package.
3237 :
3238 : Bvariable*
3239 189110 : Gcc_backend::immutable_struct_reference(const std::string& name,
3240 : const std::string& asm_name,
3241 : Btype* btype,
3242 : Location location)
3243 : {
3244 189110 : tree type_tree = btype->get_tree();
3245 189110 : if (type_tree == error_mark_node)
3246 0 : return this->error_variable();
3247 189110 : gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
3248 378220 : tree decl = build_decl(location.gcc_location(), VAR_DECL,
3249 : get_identifier_from_string(name),
3250 : build_qualified_type(type_tree, TYPE_QUAL_CONST));
3251 189110 : TREE_READONLY(decl) = 1;
3252 189110 : TREE_CONSTANT(decl) = 1;
3253 189110 : DECL_ARTIFICIAL(decl) = 1;
3254 189110 : TREE_PUBLIC(decl) = 1;
3255 189110 : DECL_EXTERNAL(decl) = 1;
3256 189110 : if (! asm_name.empty())
3257 69060 : SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
3258 189110 : go_preserve_from_gc(decl);
3259 189110 : return new Bvariable(decl);
3260 : }
3261 :
3262 : // Make a label.
3263 :
3264 : Blabel*
3265 193164 : Gcc_backend::label(Bfunction* function, const std::string& name,
3266 : Location location)
3267 : {
3268 193164 : tree decl;
3269 193164 : if (name.empty())
3270 : {
3271 182752 : tree func_tree = function->get_tree();
3272 182752 : if (DECL_STRUCT_FUNCTION(func_tree) == NULL)
3273 8399 : push_struct_function(func_tree);
3274 : else
3275 174353 : push_cfun(DECL_STRUCT_FUNCTION(func_tree));
3276 :
3277 182752 : decl = create_artificial_label(location.gcc_location());
3278 :
3279 182752 : pop_cfun();
3280 : }
3281 : else
3282 : {
3283 10412 : tree id = get_identifier_from_string(name);
3284 10412 : decl = build_decl(location.gcc_location(), LABEL_DECL, id,
3285 : void_type_node);
3286 10412 : DECL_CONTEXT(decl) = function->get_tree();
3287 : }
3288 193164 : return new Blabel(decl);
3289 : }
3290 :
3291 : // Make a statement which defines a label.
3292 :
3293 : Bstatement*
3294 193164 : Gcc_backend::label_definition_statement(Blabel* label)
3295 : {
3296 193164 : tree lab = label->get_tree();
3297 193164 : tree ret = fold_build1_loc(DECL_SOURCE_LOCATION(lab), LABEL_EXPR,
3298 : void_type_node, lab);
3299 193164 : return this->make_statement(ret);
3300 : }
3301 :
3302 : // Make a goto statement.
3303 :
3304 : Bstatement*
3305 242991 : Gcc_backend::goto_statement(Blabel* label, Location location)
3306 : {
3307 242991 : tree lab = label->get_tree();
3308 242991 : tree ret = fold_build1_loc(location.gcc_location(), GOTO_EXPR, void_type_node,
3309 : lab);
3310 242991 : return this->make_statement(ret);
3311 : }
3312 :
3313 : // Get the address of a label.
3314 :
3315 : Bexpression*
3316 8840 : Gcc_backend::label_address(Blabel* label, Location location)
3317 : {
3318 8840 : tree lab = label->get_tree();
3319 8840 : TREE_USED(lab) = 1;
3320 8840 : TREE_ADDRESSABLE(lab) = 1;
3321 8840 : tree ret = fold_convert_loc(location.gcc_location(), ptr_type_node,
3322 : build_fold_addr_expr_loc(location.gcc_location(),
3323 : lab));
3324 8840 : return this->make_expression(ret);
3325 : }
3326 :
3327 : // Declare or define a new function.
3328 :
3329 : Bfunction*
3330 611630 : Gcc_backend::function(Btype* fntype, const std::string& name,
3331 : const std::string& asm_name, unsigned int flags,
3332 : Location location)
3333 : {
3334 611630 : tree functype = fntype->get_tree();
3335 611630 : if (functype != error_mark_node)
3336 : {
3337 611616 : gcc_assert(FUNCTION_POINTER_TYPE_P(functype));
3338 611616 : functype = TREE_TYPE(functype);
3339 : }
3340 611630 : tree id = get_identifier_from_string(name);
3341 611630 : if (functype == error_mark_node || id == error_mark_node)
3342 14 : return this->error_function();
3343 :
3344 611616 : tree decl = build_decl(location.gcc_location(), FUNCTION_DECL, id, functype);
3345 611616 : if (! asm_name.empty())
3346 447520 : SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
3347 611616 : if ((flags & function_is_visible) != 0)
3348 528383 : TREE_PUBLIC(decl) = 1;
3349 611616 : if ((flags & function_is_declaration) != 0)
3350 312572 : DECL_EXTERNAL(decl) = 1;
3351 : else
3352 : {
3353 299044 : tree restype = TREE_TYPE(functype);
3354 299044 : tree resdecl =
3355 299044 : build_decl(location.gcc_location(), RESULT_DECL, NULL_TREE, restype);
3356 299044 : DECL_ARTIFICIAL(resdecl) = 1;
3357 299044 : DECL_IGNORED_P(resdecl) = 1;
3358 299044 : DECL_NAMELESS(resdecl) = 1;
3359 299044 : DECL_CONTEXT(resdecl) = decl;
3360 299044 : DECL_RESULT(decl) = resdecl;
3361 : }
3362 611616 : if ((flags & function_is_inlinable) == 0)
3363 10863 : DECL_UNINLINABLE(decl) = 1;
3364 611616 : if ((flags & function_no_split_stack) != 0)
3365 : {
3366 2264 : tree attr = get_identifier ("no_split_stack");
3367 2264 : DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
3368 : }
3369 611616 : if ((flags & function_does_not_return) != 0)
3370 16108 : TREE_THIS_VOLATILE(decl) = 1;
3371 611616 : if ((flags & function_in_unique_section) != 0)
3372 3 : resolve_unique_section(decl, 0, 1);
3373 611616 : if ((flags & function_only_inline) != 0)
3374 : {
3375 12247 : TREE_PUBLIC (decl) = 1;
3376 12247 : DECL_EXTERNAL(decl) = 1;
3377 12247 : DECL_DECLARED_INLINE_P(decl) = 1;
3378 : }
3379 :
3380 : // Optimize thunk functions for size. A thunk created for a defer
3381 : // statement that may call recover looks like:
3382 : // if runtime.setdeferretaddr(L1) {
3383 : // goto L1
3384 : // }
3385 : // realfn()
3386 : // L1:
3387 : // The idea is that L1 should be the address to which realfn
3388 : // returns. This only works if this little function is not over
3389 : // optimized. At some point GCC started duplicating the epilogue in
3390 : // the basic-block reordering pass, breaking this assumption.
3391 : // Optimizing the function for size avoids duplicating the epilogue.
3392 : // This optimization shouldn't matter for any thunk since all thunks
3393 : // are small.
3394 611616 : size_t pos = name.find("..thunk");
3395 611616 : if (pos != std::string::npos)
3396 : {
3397 44954 : for (pos += 7; pos < name.length(); ++pos)
3398 : {
3399 30007 : if (name[pos] < '0' || name[pos] > '9')
3400 : break;
3401 : }
3402 14947 : if (pos == name.length())
3403 : {
3404 14947 : struct cl_optimization cur_opts;
3405 14947 : cl_optimization_save(&cur_opts, &global_options,
3406 : &global_options_set);
3407 14947 : global_options.x_optimize_size = 1;
3408 14947 : global_options.x_optimize_fast = 0;
3409 14947 : global_options.x_optimize_debug = 0;
3410 29894 : DECL_FUNCTION_SPECIFIC_OPTIMIZATION(decl) =
3411 14947 : build_optimization_node(&global_options, &global_options_set);
3412 14947 : cl_optimization_restore(&global_options, &global_options_set,
3413 : &cur_opts);
3414 : }
3415 : }
3416 :
3417 611616 : go_preserve_from_gc(decl);
3418 611616 : return new Bfunction(decl);
3419 : }
3420 :
3421 : // Create a statement that runs all deferred calls for FUNCTION. This should
3422 : // be a statement that looks like this in C++:
3423 : // finish:
3424 : // try { UNDEFER; } catch { CHECK_DEFER; goto finish; }
3425 :
3426 : Bstatement*
3427 8353 : Gcc_backend::function_defer_statement(Bfunction* function, Bexpression* undefer,
3428 : Bexpression* defer, Location location)
3429 : {
3430 8353 : tree undefer_tree = undefer->get_tree();
3431 8353 : tree defer_tree = defer->get_tree();
3432 8353 : tree fntree = function->get_tree();
3433 :
3434 8353 : if (undefer_tree == error_mark_node
3435 8353 : || defer_tree == error_mark_node
3436 8353 : || fntree == error_mark_node)
3437 0 : return this->error_statement();
3438 :
3439 8353 : if (DECL_STRUCT_FUNCTION(fntree) == NULL)
3440 0 : push_struct_function(fntree);
3441 : else
3442 8353 : push_cfun(DECL_STRUCT_FUNCTION(fntree));
3443 :
3444 8353 : tree stmt_list = NULL;
3445 8353 : Blabel* blabel = this->label(function, "", location);
3446 8353 : Bstatement* label_def = this->label_definition_statement(blabel);
3447 8353 : append_to_statement_list(label_def->get_tree(), &stmt_list);
3448 :
3449 8353 : Bstatement* jump_stmt = this->goto_statement(blabel, location);
3450 8353 : tree jump = jump_stmt->get_tree();
3451 8353 : tree catch_body = build2(COMPOUND_EXPR, void_type_node, defer_tree, jump);
3452 8353 : catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
3453 8353 : tree try_catch =
3454 8353 : build2(TRY_CATCH_EXPR, void_type_node, undefer_tree, catch_body);
3455 8353 : append_to_statement_list(try_catch, &stmt_list);
3456 8353 : pop_cfun();
3457 :
3458 8353 : return this->make_statement(stmt_list);
3459 : }
3460 :
3461 : // Record PARAM_VARS as the variables to use for the parameters of FUNCTION.
3462 : // This will only be called for a function definition.
3463 :
3464 : bool
3465 295605 : Gcc_backend::function_set_parameters(Bfunction* function,
3466 : const std::vector<Bvariable*>& param_vars)
3467 : {
3468 295605 : tree func_tree = function->get_tree();
3469 295605 : if (func_tree == error_mark_node)
3470 : return false;
3471 :
3472 295591 : tree params = NULL_TREE;
3473 295591 : tree *pp = ¶ms;
3474 295591 : for (std::vector<Bvariable*>::const_iterator pv = param_vars.begin();
3475 769964 : pv != param_vars.end();
3476 474373 : ++pv)
3477 : {
3478 474373 : *pp = (*pv)->get_decl();
3479 474373 : gcc_assert(*pp != error_mark_node);
3480 474373 : pp = &DECL_CHAIN(*pp);
3481 : }
3482 295591 : *pp = NULL_TREE;
3483 295591 : DECL_ARGUMENTS(func_tree) = params;
3484 295591 : return true;
3485 : }
3486 :
3487 : // Set the function body for FUNCTION using the code in CODE_BLOCK.
3488 :
3489 : bool
3490 299040 : Gcc_backend::function_set_body(Bfunction* function, Bstatement* code_stmt)
3491 : {
3492 299040 : tree func_tree = function->get_tree();
3493 299040 : tree code = code_stmt->get_tree();
3494 :
3495 299040 : if (func_tree == error_mark_node || code == error_mark_node)
3496 : return false;
3497 298999 : DECL_SAVED_TREE(func_tree) = code;
3498 298999 : return true;
3499 : }
3500 :
3501 : // Look up a named built-in function in the current backend implementation.
3502 : // Returns NULL if no built-in function by that name exists.
3503 :
3504 : Bfunction*
3505 130338 : Gcc_backend::lookup_builtin(const std::string& name)
3506 : {
3507 130338 : if (this->builtin_functions_.count(name) != 0)
3508 5835 : return this->builtin_functions_[name];
3509 : return NULL;
3510 : }
3511 :
3512 : // Write the definitions for all TYPE_DECLS, CONSTANT_DECLS,
3513 : // FUNCTION_DECLS, and VARIABLE_DECLS declared globally, as well as
3514 : // emit early debugging information.
3515 :
3516 : void
3517 4215 : Gcc_backend::write_global_definitions(
3518 : const std::vector<Btype*>& type_decls,
3519 : const std::vector<Bexpression*>& constant_decls,
3520 : const std::vector<Bfunction*>& function_decls,
3521 : const std::vector<Bvariable*>& variable_decls)
3522 : {
3523 4215 : size_t count_definitions = type_decls.size() + constant_decls.size()
3524 4215 : + function_decls.size() + variable_decls.size();
3525 :
3526 4215 : tree* defs = new tree[count_definitions];
3527 :
3528 : // Convert all non-erroneous declarations into Gimple form.
3529 4215 : size_t i = 0;
3530 28703 : for (std::vector<Bvariable*>::const_iterator p = variable_decls.begin();
3531 28703 : p != variable_decls.end();
3532 24488 : ++p)
3533 : {
3534 24488 : tree v = (*p)->get_decl();
3535 24488 : if (v != error_mark_node)
3536 : {
3537 24488 : defs[i] = v;
3538 24488 : go_preserve_from_gc(defs[i]);
3539 24488 : ++i;
3540 : }
3541 : }
3542 :
3543 33898 : for (std::vector<Btype*>::const_iterator p = type_decls.begin();
3544 33898 : p != type_decls.end();
3545 29683 : ++p)
3546 : {
3547 29683 : tree type_tree = (*p)->get_tree();
3548 29683 : if (type_tree != error_mark_node
3549 29683 : && IS_TYPE_OR_DECL_P(type_tree))
3550 : {
3551 29683 : defs[i] = TYPE_NAME(type_tree);
3552 29683 : gcc_assert(defs[i] != NULL);
3553 29683 : go_preserve_from_gc(defs[i]);
3554 29683 : ++i;
3555 : }
3556 : }
3557 27560 : for (std::vector<Bexpression*>::const_iterator p = constant_decls.begin();
3558 27560 : p != constant_decls.end();
3559 23345 : ++p)
3560 : {
3561 23345 : if ((*p)->get_tree() != error_mark_node)
3562 : {
3563 23345 : defs[i] = (*p)->get_tree();
3564 23345 : go_preserve_from_gc(defs[i]);
3565 23345 : ++i;
3566 : }
3567 : }
3568 294847 : for (std::vector<Bfunction*>::const_iterator p = function_decls.begin();
3569 294847 : p != function_decls.end();
3570 290632 : ++p)
3571 : {
3572 290632 : tree decl = (*p)->get_tree();
3573 290632 : if (decl != error_mark_node)
3574 : {
3575 290632 : go_preserve_from_gc(decl);
3576 290632 : if (DECL_STRUCT_FUNCTION(decl) == NULL)
3577 44364 : allocate_struct_function(decl, false);
3578 290632 : cgraph_node::finalize_function(decl, true);
3579 :
3580 290632 : defs[i] = decl;
3581 290632 : ++i;
3582 : }
3583 : }
3584 :
3585 : // Pass everything back to the middle-end.
3586 :
3587 4215 : wrapup_global_declarations(defs, i);
3588 :
3589 4215 : delete[] defs;
3590 4215 : }
3591 :
3592 : void
3593 7161182 : Gcc_backend::write_export_data(const char* bytes, unsigned int size)
3594 : {
3595 7161182 : go_write_export_data(bytes, size);
3596 7161182 : }
3597 :
3598 :
3599 : // Define a builtin function. BCODE is the builtin function code
3600 : // defined by builtins.def. NAME is the name of the builtin function.
3601 : // LIBNAME is the name of the corresponding library function, and is
3602 : // NULL if there isn't one. FNTYPE is the type of the function.
3603 : // FLAGS are the attributes to add, a bitset of builtin_xxx consts.
3604 :
3605 : void
3606 385452 : Gcc_backend::define_builtin(built_in_function bcode, const char* name,
3607 : const char* libname, tree fntype, int flags)
3608 : {
3609 385452 : tree decl = add_builtin_function(name, fntype, bcode, BUILT_IN_NORMAL,
3610 : libname, NULL_TREE);
3611 385452 : this->set_attributes(decl, flags);
3612 385452 : set_builtin_decl(bcode, decl, true);
3613 385452 : this->builtin_functions_[name] = this->make_function(decl);
3614 385452 : if (libname != NULL)
3615 : {
3616 250776 : decl = add_builtin_function(libname, fntype, bcode, BUILT_IN_NORMAL,
3617 : NULL, NULL_TREE);
3618 250776 : this->set_attributes(decl, flags);
3619 250776 : this->builtin_functions_[libname] = this->make_function(decl);
3620 : }
3621 385452 : }
3622 :
3623 : // Set the attributes of DECL based on FLAGS.
3624 :
3625 : void
3626 636228 : Gcc_backend::set_attributes(tree decl, int flags)
3627 : {
3628 636228 : if ((flags & builtin_const) != 0)
3629 482976 : TREE_READONLY(decl) = 1;
3630 636228 : if ((flags & builtin_pure) != 0)
3631 9288 : DECL_PURE_P(decl) = 1;
3632 636228 : if ((flags & builtin_nothrow) != 0)
3633 143964 : TREE_NOTHROW (decl) = 1;
3634 636228 : if ((flags & builtin_noreturn) != 0)
3635 9288 : TREE_THIS_VOLATILE(decl) = 1;
3636 636228 : if ((flags & builtin_novops) != 0)
3637 4644 : DECL_IS_NOVOPS(decl) = 1;
3638 636228 : if ((flags & builtin_leaf) != 0)
3639 232200 : DECL_ATTRIBUTES(decl) = tree_cons(get_identifier("leaf"), NULL_TREE,
3640 232200 : DECL_ATTRIBUTES(decl));
3641 636228 : if ((flags & builtin_nonnull) != 0)
3642 27864 : DECL_ATTRIBUTES(decl) = tree_cons(get_identifier("nonnull"), NULL_TREE,
3643 27864 : DECL_ATTRIBUTES(decl));
3644 636228 : if ((flags & builtin_cold) != 0)
3645 9288 : DECL_ATTRIBUTES(decl) = tree_cons(get_identifier("cold"), NULL_TREE,
3646 9288 : DECL_ATTRIBUTES(decl));
3647 636228 : }
3648 :
3649 : // Return the backend generator.
3650 :
3651 : Backend*
3652 4644 : go_get_backend()
3653 : {
3654 4644 : return new Gcc_backend();
3655 : }
|
