1 /* TREELANG Compiler interface to GCC's middle end (treetree.c)
4 If you want a working example of how to write a front end to GCC,
5 you are in the right place.
7 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
8 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
10 This code is based on toy.c written by Richard Kenner.
12 It was later modified by Jonathan Bartlett whose changes have all
13 been removed (by Tim Josling).
15 Various bits and pieces were cloned from the GCC main tree, as
16 GCC evolved, for COBOLForGCC, by Tim Josling.
18 It was adapted to TREELANG by Tim Josling 2001.
20 Updated to function-at-a-time by James A. Morrison, 2004.
22 -----------------------------------------------------------------------
24 This program is free software; you can redistribute it and/or modify it
25 under the terms of the GNU General Public License as published by the
26 Free Software Foundation; either version 2, or (at your option) any
29 This program is distributed in the hope that it will be useful,
30 but WITHOUT ANY WARRANTY; without even the implied warranty of
31 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 GNU General Public License for more details.
34 You should have received a copy of the GNU General Public License
35 along with this program; if not, write to the Free Software
36 Foundation, 59 Temple Place - Suite 330,
37 Boston, MA 02111-1307, USA.
39 In other words, you are welcome to use, share and improve this program.
40 You are forbidden to forbid anyone else to use, share and improve
41 what you give them. Help stamp out software-hoarding!
43 ----------------------------------------------------------------------- */
45 /* Assumption: garbage collection is never called implicitly. It will
46 not be called 'at any time' when short of memory. It will only be
47 called explicitly at the end of each function. This removes the
48 need for a *lot* of bother to ensure everything is in the mark trees
51 /* Note, it is OK to use GCC extensions such as long long in a compiler front
52 end. This is because the GCC front ends are built using GCC. */
58 #include "coretypes.h"
61 #include "tree-dump.h"
62 #include "tree-iterator.h"
63 #include "tree-gimple.h"
70 #include "langhooks-def.h"
71 #include "langhooks.h"
80 extern int option_main;
81 extern char **file_names;
83 /* Types expected by gcc's garbage collector.
84 These types exist to allow language front-ends to
85 add extra information in gcc's parse tree data structure.
86 But the treelang front end doesn't use them -- it has
87 its own parse tree data structure.
88 We define them here only to satisfy gcc's garbage collector. */
90 /* Language-specific identifier information. */
92 struct lang_identifier GTY(())
94 struct tree_identifier common;
97 /* Language-specific tree node information. */
100 GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE")))
102 union tree_node GTY ((tag ("0"),
103 desc ("tree_node_structure (&%h)")))
105 struct lang_identifier GTY ((tag ("1"))) identifier;
108 /* Language-specific type information. */
110 struct lang_type GTY(())
112 char junk; /* dummy field to ensure struct is not empty */
115 /* Language-specific declaration information. */
117 struct lang_decl GTY(())
119 char junk; /* dummy field to ensure struct is not empty */
122 struct language_function GTY(())
124 char junk; /* dummy field to ensure struct is not empty */
127 static tree tree_lang_truthvalue_conversion (tree expr);
128 static bool tree_mark_addressable (tree exp);
129 static tree tree_lang_type_for_size (unsigned precision, int unsignedp);
130 static tree tree_lang_type_for_mode (enum machine_mode mode, int unsignedp);
131 static tree tree_lang_unsigned_type (tree type_node);
132 static tree tree_lang_signed_type (tree type_node);
133 static tree tree_lang_signed_or_unsigned_type (int unsignedp, tree type);
135 /* Functions to keep track of the current scope. */
136 static void pushlevel (int ignore);
137 static tree poplevel (int keep, int reverse, int functionbody);
138 static tree pushdecl (tree decl);
139 static tree* getstmtlist (void);
142 static tree builtin_function (const char *name, tree type, int function_code,
143 enum built_in_class class, const char *library_name,
145 static tree getdecls (void);
146 static int global_bindings_p (void);
147 static void insert_block (tree);
149 static void tree_push_type_decl (tree id, tree type_node);
150 static void treelang_expand_function (tree fndecl);
152 /* The front end language hooks (addresses of code for this front
153 end). These are not really very language-dependent, i.e.
154 treelang, C, Mercury, etc. can all use almost the same definitions. */
156 #undef LANG_HOOKS_TRUTHVALUE_CONVERSION
157 #define LANG_HOOKS_TRUTHVALUE_CONVERSION tree_lang_truthvalue_conversion
158 #undef LANG_HOOKS_MARK_ADDRESSABLE
159 #define LANG_HOOKS_MARK_ADDRESSABLE tree_mark_addressable
160 #undef LANG_HOOKS_SIGNED_TYPE
161 #define LANG_HOOKS_SIGNED_TYPE tree_lang_signed_type
162 #undef LANG_HOOKS_UNSIGNED_TYPE
163 #define LANG_HOOKS_UNSIGNED_TYPE tree_lang_unsigned_type
164 #undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE
165 #define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE tree_lang_signed_or_unsigned_type
166 #undef LANG_HOOKS_TYPE_FOR_MODE
167 #define LANG_HOOKS_TYPE_FOR_MODE tree_lang_type_for_mode
168 #undef LANG_HOOKS_TYPE_FOR_SIZE
169 #define LANG_HOOKS_TYPE_FOR_SIZE tree_lang_type_for_size
170 #undef LANG_HOOKS_PARSE_FILE
171 #define LANG_HOOKS_PARSE_FILE treelang_parse_file
173 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
174 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION treelang_expand_function
176 /* #undef LANG_HOOKS_TYPES_COMPATIBLE_P
177 #define LANG_HOOKS_TYPES_COMPATIBLE_P hook_bool_tree_tree_true
179 /* Hook routines and data unique to treelang. */
181 #undef LANG_HOOKS_INIT
182 #define LANG_HOOKS_INIT treelang_init
183 #undef LANG_HOOKS_NAME
184 #define LANG_HOOKS_NAME "GNU treelang"
185 #undef LANG_HOOKS_FINISH
186 #define LANG_HOOKS_FINISH treelang_finish
187 #undef LANG_HOOKS_INIT_OPTIONS
188 #define LANG_HOOKS_INIT_OPTIONS treelang_init_options
189 #undef LANG_HOOKS_HANDLE_OPTION
190 #define LANG_HOOKS_HANDLE_OPTION treelang_handle_option
191 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
193 /* Tree code type/name/code tables. */
195 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
197 const enum tree_code_class tree_code_type[] = {
203 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
205 const unsigned char tree_code_length[] = {
211 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
213 const char *const tree_code_name[] = {
219 /* Number of bits in int and char - accessed by front end. */
221 unsigned int tree_code_int_size = SIZEOF_INT * HOST_BITS_PER_CHAR;
223 unsigned int tree_code_char_size = HOST_BITS_PER_CHAR;
225 /* Return the tree stuff for this type TYPE_NUM. */
228 tree_code_get_type (int type_num)
233 return signed_char_type_node;
236 return unsigned_char_type_node;
239 return integer_type_node;
242 return unsigned_type_node;
245 return void_type_node;
252 /* Output the code for the start of an if statement. The test
253 expression is EXP (true if not zero), and the stmt occurred at line
254 LINENO in file FILENAME. */
257 tree_code_if_start (tree exp, location_t loc)
260 cond_exp = fold (build2 (NE_EXPR, boolean_type_node, exp,
261 fold (build1 (CONVERT_EXPR, TREE_TYPE (exp),
262 integer_zero_node))));
263 SET_EXPR_LOCATION (cond_exp, loc);
264 cond = build3 (COND_EXPR, void_type_node, cond_exp, NULL_TREE,
266 SET_EXPR_LOCATION (cond, loc);
267 append_to_statement_list_force (cond, getstmtlist ());
271 /* Output the code for the else of an if statement. The else occurred
272 at line LINENO in file FILENAME. */
275 tree_code_if_else (location_t loc ATTRIBUTE_UNUSED)
277 tree stmts = *getstmtlist ();
278 tree block = poplevel (1, 0, 0);
279 if (BLOCK_VARS (block))
281 tree bindexpr = build3 (BIND_EXPR, void_type_node, BLOCK_VARS (block),
283 stmts = alloc_stmt_list ();
284 append_to_statement_list (bindexpr, &stmts);
287 TREE_OPERAND (STATEMENT_LIST_TAIL (*getstmtlist ())->stmt, 1) = stmts;
291 /* Output the code for the end_if an if statement. The end_if (final brace)
292 occurred at line LINENO in file FILENAME. */
295 tree_code_if_end (location_t loc ATTRIBUTE_UNUSED)
297 tree stmts = *getstmtlist ();
298 tree block = poplevel (1, 0, 0);
299 if (BLOCK_VARS (block))
301 tree bindexpr = build3 (BIND_EXPR, void_type_node, BLOCK_VARS (block),
303 stmts = alloc_stmt_list ();
304 append_to_statement_list (bindexpr, &stmts);
307 TREE_OPERAND (STATEMENT_LIST_TAIL (*getstmtlist ())->stmt, 2) = stmts;
310 /* Create a function. The prototype name is NAME, storage class is
311 STORAGE_CLASS, type of return variable is RET_TYPE, parameter lists
312 is PARMS, returns decl for this function. */
315 tree_code_create_function_prototype (unsigned char* chars,
316 unsigned int storage_class,
317 unsigned int ret_type,
318 struct prod_token_parm_item* parms,
323 struct prod_token_parm_item* parm;
324 tree type_list = NULL_TREE;
329 /* Build the type. */
330 id = get_identifier ((const char*)chars);
331 for (parm = parms; parm; parm = parm->tp.par.next)
333 gcc_assert (parm->category == parameter_category);
334 type_node = tree_code_get_type (parm->type);
335 type_list = tree_cons (NULL_TREE, type_node, type_list);
337 /* Last parm if void indicates fixed length list (as opposed to
338 printf style va_* list). */
339 type_list = tree_cons (NULL_TREE, void_type_node, type_list);
341 /* The back end needs them in reverse order. */
342 type_list = nreverse (type_list);
344 type_node = tree_code_get_type (ret_type);
345 fn_type = build_function_type (type_node, type_list);
347 id = get_identifier ((const char*)chars);
348 fn_decl = build_decl (FUNCTION_DECL, id, fn_type);
350 /* Nested functions not supported here. */
351 DECL_CONTEXT (fn_decl) = NULL_TREE;
352 DECL_SOURCE_LOCATION (fn_decl) = loc;
354 TREE_USED (fn_decl) = 1;
356 TREE_PUBLIC (fn_decl) = 0;
357 DECL_EXTERNAL (fn_decl) = 0;
358 TREE_STATIC (fn_decl) = 0;
359 switch (storage_class)
362 TREE_PUBLIC (fn_decl) = 0;
365 case EXTERNAL_DEFINITION_STORAGE:
366 TREE_PUBLIC (fn_decl) = 1;
367 TREE_STATIC (fn_decl) = 0;
368 DECL_EXTERNAL (fn_decl) = 0;
371 case EXTERNAL_REFERENCE_STORAGE:
372 TREE_PUBLIC (fn_decl) = 0;
373 DECL_EXTERNAL (fn_decl) = 1;
376 case AUTOMATIC_STORAGE:
381 /* Process declaration of function defined elsewhere. */
382 rest_of_decl_compilation (fn_decl, 1, 0);
388 /* Output code for start of function; the decl of the function is in
389 PREV_SAVED (as created by tree_code_create_function_prototype),
390 the function is at line number LINENO in file FILENAME. The
391 parameter details are in the lists PARMS. Returns nothing. */
393 tree_code_create_function_initial (tree prev_saved,
395 struct prod_token_parm_item* parms)
402 struct prod_token_parm_item* this_parm;
403 struct prod_token_parm_item* parm;
405 fn_decl = prev_saved;
406 gcc_assert (fn_decl);
408 /* Output message if not -quiet. */
409 announce_function (fn_decl);
411 /* This has something to do with forcing output also. */
414 /* Set current function for error msgs etc. */
415 current_function_decl = fn_decl;
416 DECL_INITIAL (fn_decl) = error_mark_node;
418 DECL_SOURCE_LOCATION (fn_decl) = loc;
420 /* Create a DECL for the functions result. */
422 build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (TREE_TYPE (fn_decl)));
423 DECL_CONTEXT (resultdecl) = fn_decl;
424 DECL_ARTIFICIAL (resultdecl) = 1;
425 DECL_IGNORED_P (resultdecl) = 1;
426 DECL_SOURCE_LOCATION (resultdecl) = loc;
427 DECL_RESULT (fn_decl) = resultdecl;
429 /* Make the argument variable decls. */
430 parm_list = NULL_TREE;
431 for (parm = parms; parm; parm = parm->tp.par.next)
433 parm_decl = build_decl (PARM_DECL, get_identifier
434 ((const char*) (parm->tp.par.variable_name)),
435 tree_code_get_type (parm->type));
437 /* Some languages have different nominal and real types. */
438 DECL_ARG_TYPE (parm_decl) = TREE_TYPE (parm_decl);
439 gcc_assert (DECL_ARG_TYPE (parm_decl));
440 gcc_assert (fn_decl);
441 DECL_CONTEXT (parm_decl) = fn_decl;
442 DECL_SOURCE_LOCATION (parm_decl) = loc;
443 parm_list = chainon (parm_decl, parm_list);
446 /* Back into reverse order as the back end likes them. */
447 parm_list = nreverse (parm_list);
449 DECL_ARGUMENTS (fn_decl) = parm_list;
451 /* Save the decls for use when the args are referred to. */
452 for (param_decl = DECL_ARGUMENTS (fn_decl),
455 param_decl = TREE_CHAIN (param_decl),
456 this_parm = this_parm->tp.par.next)
458 gcc_assert (this_parm); /* Too few. */
459 *this_parm->tp.par.where_to_put_var_tree = param_decl;
461 gcc_assert (!this_parm); /* Too many. */
463 /* Create a new level at the start of the function. */
467 /* Force it to be output, else may be solely inlined. */
468 TREE_ADDRESSABLE (fn_decl) = 1;
470 /* Stop -O3 from deleting it. */
471 TREE_USED (fn_decl) = 1;
474 /* Wrapup a function contained in file FILENAME, ending at line LINENO. */
476 tree_code_create_function_wrapup (location_t loc)
480 tree stmts = *getstmtlist ();
482 fn_decl = current_function_decl;
486 block = poplevel (1, 0, 1);
488 /* And attach it to the function. */
490 DECL_SAVED_TREE (fn_decl) = build3 (BIND_EXPR, void_type_node,
494 allocate_struct_function (fn_decl);
495 cfun->function_end_locus = loc;
497 /* Dump the original tree to a file. */
498 dump_function (TDI_original, fn_decl);
500 /* Convert current function to GIMPLE for the middle end. */
501 gimplify_function_tree (fn_decl);
502 dump_function (TDI_generic, fn_decl);
504 /* We are not inside of any scope now. */
505 current_function_decl = NULL_TREE;
508 /* Pass the current function off to the middle end. */
509 (void)cgraph_node (fn_decl);
510 cgraph_finalize_function (fn_decl, false);
513 /* Create a variable.
515 The storage class is STORAGE_CLASS (eg LOCAL).
516 The name is CHARS/LENGTH.
517 The type is EXPRESSION_TYPE (eg UNSIGNED_TYPE).
518 The init tree is INIT. */
521 tree_code_create_variable (unsigned int storage_class,
522 unsigned char* chars,
524 unsigned int expression_type,
532 /* 1. Build the type. */
533 var_type = tree_code_get_type (expression_type);
535 /* 2. Build the name. */
536 gcc_assert (chars[length] == 0); /* Should be null terminated. */
538 var_id = get_identifier ((const char*)chars);
540 /* 3. Build the decl and set up init. */
541 var_decl = build_decl (VAR_DECL, var_id, var_type);
543 /* 3a. Initialization. */
545 DECL_INITIAL (var_decl) = fold (build1 (CONVERT_EXPR, var_type, init));
547 DECL_INITIAL (var_decl) = NULL_TREE;
549 gcc_assert (TYPE_SIZE (var_type) != 0); /* Did not calculate size. */
551 DECL_CONTEXT (var_decl) = current_function_decl;
553 DECL_SOURCE_LOCATION (var_decl) = loc;
555 /* Set the storage mode and whether only visible in the same file. */
556 switch (storage_class)
559 TREE_STATIC (var_decl) = 1;
560 TREE_PUBLIC (var_decl) = 0;
563 case AUTOMATIC_STORAGE:
564 TREE_STATIC (var_decl) = 0;
565 TREE_PUBLIC (var_decl) = 0;
568 case EXTERNAL_DEFINITION_STORAGE:
569 TREE_STATIC (var_decl) = 0;
570 TREE_PUBLIC (var_decl) = 1;
573 case EXTERNAL_REFERENCE_STORAGE:
574 DECL_EXTERNAL (var_decl) = 1;
575 TREE_PUBLIC (var_decl) = 0;
582 /* This should really only be set if the variable is used. */
583 TREE_USED (var_decl) = 1;
585 /* Expand declaration and initial value if any. */
587 if (TREE_STATIC (var_decl))
588 rest_of_decl_compilation (var_decl, 0, 0);
590 TYPE_NAME (TREE_TYPE (var_decl)) = TYPE_NAME (var_type);
591 return pushdecl (copy_node (var_decl));
595 /* Generate code for return statement. Type is in TYPE, expression
596 is in EXP if present. */
599 tree_code_generate_return (tree type, tree exp)
602 #ifdef ENABLE_CHECKING
605 for (param = DECL_ARGUMENTS (current_function_decl);
607 param = TREE_CHAIN (param))
608 gcc_assert (DECL_CONTEXT (param) == current_function_decl);
611 if (exp && TREE_TYPE (TREE_TYPE (current_function_decl)) != void_type_node)
613 setret = fold (build2 (MODIFY_EXPR, type,
614 DECL_RESULT (current_function_decl),
615 fold (build1 (CONVERT_EXPR, type, exp))));
616 TREE_SIDE_EFFECTS (setret) = 1;
617 TREE_USED (setret) = 1;
618 setret = build1 (RETURN_EXPR, type, setret);
621 setret = build1 (RETURN_EXPR, type, NULL_TREE);
623 append_to_statement_list_force (setret, getstmtlist ());
627 /* Output the code for this expression statement CODE. */
630 tree_code_output_expression_statement (tree code, location_t loc)
632 /* Output the line number information. */
633 SET_EXPR_LOCATION (code, loc);
634 TREE_USED (code) = 1;
635 TREE_SIDE_EFFECTS (code) = 1;
636 /* put CODE into the code list. */
637 append_to_statement_list_force (code, getstmtlist ());
640 /* Return a tree for a constant integer value in the token TOK. No
641 size checking is done. */
644 tree_code_get_integer_value (unsigned char* chars, unsigned int length)
646 long long int val = 0;
648 unsigned int start = 0;
652 case (unsigned char)'-':
657 case (unsigned char)'+':
664 for (ix = start; ix < length; ix++)
665 val = val * 10 + chars[ix] - (unsigned char)'0';
667 return build_int_cst_wide (NULL_TREE,
668 val & 0xffffffff, (val >> 32) & 0xffffffff);
671 /* Return the tree for an expresssion, type EXP_TYPE (see treetree.h)
672 with tree type TYPE and with operands1 OP1, OP2 (maybe), OP3 (maybe). */
674 tree_code_get_expression (unsigned int exp_type,
675 tree type, tree op1, tree op2,
676 tree op3 ATTRIBUTE_UNUSED)
684 gcc_assert (op1 && op2);
685 operator = MODIFY_EXPR;
686 ret1 = fold (build2 (operator, void_type_node, op1,
687 fold (build1 (CONVERT_EXPR, TREE_TYPE (op1),
693 operator = PLUS_EXPR;
694 goto binary_expression;
697 operator = MINUS_EXPR;
698 goto binary_expression;
702 goto binary_expression;
704 /* Expand a binary expression. Ensure the operands are the right type. */
706 gcc_assert (op1 && op2);
707 ret1 = fold (build2 (operator, type,
708 fold (build1 (CONVERT_EXPR, type, op1)),
709 fold (build1 (CONVERT_EXPR, type, op2))));
712 /* Reference to a variable. This is dead easy, just return the
713 decl for the variable. If the TYPE is different than the
714 variable type, convert it. */
717 if (type == TREE_TYPE (op1))
720 ret1 = fold (build1 (CONVERT_EXPR, type, op1));
723 case EXP_FUNCTION_INVOCATION:
724 gcc_assert (op1 && op2);
727 fun_ptr = fold (build1 (ADDR_EXPR,
728 build_pointer_type (TREE_TYPE (op1)), op1));
729 ret1 = build3 (CALL_EXPR, type, fun_ptr, nreverse (op2), NULL_TREE);
740 /* Init parameter list and return empty list. */
743 tree_code_init_parameters (void)
748 /* Add a parameter EXP whose expression type is EXP_PROTO to list
749 LIST, returning the new list. */
752 tree_code_add_parameter (tree list, tree proto_exp, tree exp)
755 new_exp = tree_cons (NULL_TREE,
756 fold (build1 (CONVERT_EXPR, TREE_TYPE (proto_exp),
760 return chainon (new_exp, list);
763 /* Get a stringpool entry for a string S of length L. This is needed
764 because the GTY routines don't mark strings, forcing you to put
765 them into stringpool, which is never freed. */
768 get_string (const char *s, size_t l)
771 t = get_identifier_with_length (s, l);
772 return IDENTIFIER_POINTER(t);
775 /* Save typing debug_tree all the time. Dump a tree T pretty and
786 /* Routines Expected by gcc: */
788 /* These are used to build types for various sizes. The code below
789 is a simplified version of that of GNAT. */
791 #ifndef MAX_BITS_PER_WORD
792 #define MAX_BITS_PER_WORD BITS_PER_WORD
795 /* This variable keeps a table for types for each precision so that we only
796 allocate each of them once. Signed and unsigned types are kept separate. */
797 static GTY(()) tree signed_and_unsigned_types[MAX_BITS_PER_WORD + 1][2];
799 /* XXX is this definition OK? */
801 tree_lang_truthvalue_conversion (tree expr)
806 /* Mark EXP saying that we need to be able to take the
807 address of it; it should not be allocated in a register.
808 Value is 1 if successful.
810 This implementation was copied from c-decl.c. */
813 tree_mark_addressable (tree exp)
815 register tree x = exp;
817 switch (TREE_CODE (x))
824 x = TREE_OPERAND (x, 0);
828 TREE_ADDRESSABLE (x) = 1;
835 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
836 && DECL_NONLOCAL (x))
840 error ("Global register variable %qD used in nested function.",
844 pedwarn ("Register variable %qD used in nested function.", x);
846 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
850 error ("Address of global register variable %qD requested.",
855 pedwarn ("Address of register variable %qD requested.", x);
860 TREE_ADDRESSABLE (x) = 1;
867 /* Return an integer type with the number of bits of precision given by
868 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
869 it is a signed type. */
872 tree_lang_type_for_size (unsigned precision, int unsignedp)
876 if (precision <= MAX_BITS_PER_WORD
877 && signed_and_unsigned_types[precision][unsignedp] != 0)
878 return signed_and_unsigned_types[precision][unsignedp];
881 t = signed_and_unsigned_types[precision][1]
882 = make_unsigned_type (precision);
884 t = signed_and_unsigned_types[precision][0]
885 = make_signed_type (precision);
890 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
891 an unsigned type; otherwise a signed type is returned. */
894 tree_lang_type_for_mode (enum machine_mode mode, int unsignedp)
896 if (SCALAR_INT_MODE_P (mode))
897 return tree_lang_type_for_size (GET_MODE_BITSIZE (mode), unsignedp);
902 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
905 tree_lang_unsigned_type (tree type_node)
907 return tree_lang_type_for_size (TYPE_PRECISION (type_node), 1);
910 /* Return the signed version of a TYPE_NODE, a scalar type. */
913 tree_lang_signed_type (tree type_node)
915 return tree_lang_type_for_size (TYPE_PRECISION (type_node), 0);
918 /* Return a type the same as TYPE except unsigned or signed according to
922 tree_lang_signed_or_unsigned_type (int unsignedp, tree type)
924 if (! INTEGRAL_TYPE_P (type) || TYPE_UNSIGNED (type) == unsignedp)
927 return tree_lang_type_for_size (TYPE_PRECISION (type), unsignedp);
930 /* These functions and variables deal with binding contours. We only
931 need these functions for the list of PARM_DECLs, but we leave the
932 functions more general; these are a simplified version of the
933 functions from GNAT. */
935 /* For each binding contour we allocate a binding_level structure which records
936 the entities defined or declared in that contour. Contours include:
939 one for each subprogram definition
940 one for each compound statement (declare block)
942 Binding contours are used to create GCC tree BLOCK nodes. */
946 /* A chain of ..._DECL nodes for all variables, constants, functions,
947 parameters and type declarations. These ..._DECL nodes are chained
948 through the TREE_CHAIN field. Note that these ..._DECL nodes are stored
949 in the reverse of the order supplied to be compatible with the
952 /* For each level (except the global one), a chain of BLOCK nodes for all
953 the levels that were entered and exited one level down from this one. */
957 /* The binding level containing this one (the enclosing binding level). */
958 struct binding_level *level_chain;
961 /* The binding level currently in effect. */
962 static struct binding_level *current_binding_level = NULL;
964 /* The outermost binding level. This binding level is created when the
965 compiler is started and it will exist through the entire compilation. */
966 static struct binding_level *global_binding_level;
968 /* Binding level structures are initialized by copying this one. */
969 static struct binding_level clear_binding_level = {NULL, NULL, NULL, NULL };
971 /* Return non-zero if we are currently in the global binding level. */
974 global_bindings_p (void)
976 return current_binding_level == global_binding_level ? -1 : 0;
980 /* Return the list of declarations in the current level. Note that this list
981 is in reverse order (it has to be so for back-end compatibility). */
986 return current_binding_level->names;
989 /* Return a STATMENT_LIST for the current block. */
994 return ¤t_binding_level->stmts;
997 /* Enter a new binding level. The input parameter is ignored, but has to be
998 specified for back-end compatibility. */
1001 pushlevel (int ignore ATTRIBUTE_UNUSED)
1003 struct binding_level *newlevel = xmalloc (sizeof (struct binding_level));
1005 *newlevel = clear_binding_level;
1007 /* Add this level to the front of the chain (stack) of levels that are
1009 newlevel->level_chain = current_binding_level;
1010 current_binding_level = newlevel;
1011 current_binding_level->stmts = alloc_stmt_list ();
1014 /* Exit a binding level.
1015 Pop the level off, and restore the state of the identifier-decl mappings
1016 that were in effect when this level was entered.
1018 If KEEP is nonzero, this level had explicit declarations, so
1019 and create a "block" (a BLOCK node) for the level
1020 to record its declarations and subblocks for symbol table output.
1022 If FUNCTIONBODY is nonzero, this level is the body of a function,
1023 so create a block as if KEEP were set and also clear out all
1026 If REVERSE is nonzero, reverse the order of decls before putting
1027 them into the BLOCK. */
1030 poplevel (int keep, int reverse, int functionbody)
1032 /* Points to a BLOCK tree node. This is the BLOCK node construted for the
1033 binding level that we are about to exit and which is returned by this
1035 tree block_node = NULL_TREE;
1037 tree subblock_chain = current_binding_level->blocks;
1040 /* Reverse the list of *_DECL nodes if desired. Note that the ..._DECL
1041 nodes chained through the `names' field of current_binding_level are in
1042 reverse order except for PARM_DECL node, which are explicitely stored in
1044 decl_chain = (reverse) ? nreverse (current_binding_level->names)
1045 : current_binding_level->names;
1047 /* If there were any declarations in the current binding level, or if this
1048 binding level is a function body, or if there are any nested blocks then
1049 create a BLOCK node to record them for the life of this function. */
1050 if (keep || functionbody)
1051 block_node = build_block (keep ? decl_chain : 0, 0, subblock_chain, 0, 0);
1053 /* Record the BLOCK node just built as the subblock its enclosing scope. */
1054 for (subblock_node = subblock_chain; subblock_node;
1055 subblock_node = TREE_CHAIN (subblock_node))
1056 BLOCK_SUPERCONTEXT (subblock_node) = block_node;
1058 /* Clear out the meanings of the local variables of this level. */
1060 for (subblock_node = decl_chain; subblock_node;
1061 subblock_node = TREE_CHAIN (subblock_node))
1062 if (DECL_NAME (subblock_node) != 0)
1063 /* If the identifier was used or addressed via a local extern decl,
1064 don't forget that fact. */
1065 if (DECL_EXTERNAL (subblock_node))
1067 if (TREE_USED (subblock_node))
1068 TREE_USED (DECL_NAME (subblock_node)) = 1;
1071 /* Pop the current level. */
1072 current_binding_level = current_binding_level->level_chain;
1076 /* This is the top level block of a function. */
1077 DECL_INITIAL (current_function_decl) = block_node;
1079 else if (block_node)
1081 current_binding_level->blocks
1082 = chainon (current_binding_level->blocks, block_node);
1085 /* If we did not make a block for the level just exited, any blocks made for
1086 inner levels (since they cannot be recorded as subblocks in that level)
1087 must be carried forward so they will later become subblocks of something
1089 else if (subblock_chain)
1090 current_binding_level->blocks
1091 = chainon (current_binding_level->blocks, subblock_chain);
1093 TREE_USED (block_node) = 1;
1098 /* Insert BLOCK at the end of the list of subblocks of the
1099 current binding level. This is used when a BIND_EXPR is expanded,
1100 to handle the BLOCK node inside the BIND_EXPR. */
1103 insert_block (tree block)
1105 TREE_USED (block) = 1;
1106 current_binding_level->blocks
1107 = chainon (current_binding_level->blocks, block);
1111 /* Records a ..._DECL node DECL as belonging to the current lexical scope.
1112 Returns the ..._DECL node. */
1115 pushdecl (tree decl)
1117 /* External objects aren't nested, other objects may be. */
1119 if ((DECL_EXTERNAL (decl)) || (decl==current_function_decl))
1120 DECL_CONTEXT (decl) = 0;
1122 DECL_CONTEXT (decl) = current_function_decl;
1124 /* Put the declaration on the list. The list of declarations is in reverse
1125 order. The list will be reversed later if necessary. This needs to be
1126 this way for compatibility with the back-end. */
1128 TREE_CHAIN (decl) = current_binding_level->names;
1129 current_binding_level->names = decl;
1131 /* For the declartion of a type, set its name if it is not already set. */
1133 if (TREE_CODE (decl) == TYPE_DECL
1134 && TYPE_NAME (TREE_TYPE (decl)) == 0)
1135 TYPE_NAME (TREE_TYPE (decl)) = DECL_NAME (decl);
1142 tree_push_type_decl(tree id, tree type_node)
1144 tree decl = build_decl (TYPE_DECL, id, type_node);
1145 TYPE_NAME (type_node) = id;
1149 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
1151 /* Create the predefined scalar types of C,
1152 and some nodes representing standard constants (0, 1, (void *) 0).
1153 Initialize the global binding level.
1154 Make definitions for built-in primitive functions. */
1157 treelang_init_decl_processing (void)
1159 current_function_decl = NULL;
1160 current_binding_level = NULL_BINDING_LEVEL;
1161 pushlevel (0); /* make the binding_level structure for global names */
1162 global_binding_level = current_binding_level;
1164 build_common_tree_nodes (flag_signed_char, false);
1166 /* set standard type names */
1168 /* Define `int' and `char' last so that they are not overwritten. */
1169 tree_push_type_decl (NULL_TREE, intQI_type_node);
1170 tree_push_type_decl (NULL_TREE, intHI_type_node);
1171 tree_push_type_decl (NULL_TREE, intSI_type_node);
1172 tree_push_type_decl (NULL_TREE, intDI_type_node);
1173 #if HOST_BITS_PER_WIDE_INT >= 64
1174 tree_push_type_decl (NULL_TREE, intTI_type_node);
1176 tree_push_type_decl (NULL_TREE, unsigned_intQI_type_node);
1177 tree_push_type_decl (NULL_TREE, unsigned_intHI_type_node);
1178 tree_push_type_decl (NULL_TREE, unsigned_intSI_type_node);
1179 tree_push_type_decl (NULL_TREE, unsigned_intDI_type_node);
1180 #if HOST_BITS_PER_WIDE_INT >= 64
1181 tree_push_type_decl (NULL_TREE, unsigned_intTI_type_node);
1184 tree_push_type_decl (get_identifier ("int"), integer_type_node);
1185 tree_push_type_decl (get_identifier ("char"), char_type_node);
1186 tree_push_type_decl (get_identifier ("long int"),
1187 long_integer_type_node);
1188 tree_push_type_decl (get_identifier ("unsigned int"),
1189 unsigned_type_node);
1190 tree_push_type_decl (get_identifier ("long unsigned int"),
1191 long_unsigned_type_node);
1192 tree_push_type_decl (get_identifier ("long long int"),
1193 long_long_integer_type_node);
1194 tree_push_type_decl (get_identifier ("long long unsigned int"),
1195 long_long_unsigned_type_node);
1196 tree_push_type_decl (get_identifier ("short int"),
1197 short_integer_type_node);
1198 tree_push_type_decl (get_identifier ("short unsigned int"),
1199 short_unsigned_type_node);
1200 tree_push_type_decl (get_identifier ("signed char"),
1201 signed_char_type_node);
1202 tree_push_type_decl (get_identifier ("unsigned char"),
1203 unsigned_char_type_node);
1204 size_type_node = make_unsigned_type (POINTER_SIZE);
1205 tree_push_type_decl (get_identifier ("size_t"), size_type_node);
1206 set_sizetype (size_type_node);
1208 build_common_tree_nodes_2 (/* short_double= */ 0);
1210 tree_push_type_decl (get_identifier ("float"), float_type_node);
1211 tree_push_type_decl (get_identifier ("double"), double_type_node);
1212 tree_push_type_decl (get_identifier ("long double"), long_double_type_node);
1213 tree_push_type_decl (get_identifier ("void"), void_type_node);
1215 build_common_builtin_nodes ();
1216 (*targetm.init_builtins) ();
1218 pedantic_lvalues = pedantic;
1221 /* Return a definition for a builtin function named NAME and whose data type
1222 is TYPE. TYPE should be a function type with argument types.
1223 FUNCTION_CODE tells later passes how to compile calls to this function.
1224 See tree.h for its possible values.
1226 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
1227 the name to be called if we can't opencode the function. If
1228 ATTRS is nonzero, use that for the function's attribute list.
1230 copied from gcc/c-decl.c
1234 builtin_function (const char *name, tree type, int function_code,
1235 enum built_in_class class, const char *library_name,
1238 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
1239 DECL_EXTERNAL (decl) = 1;
1240 TREE_PUBLIC (decl) = 1;
1242 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
1244 DECL_BUILT_IN_CLASS (decl) = class;
1245 DECL_FUNCTION_CODE (decl) = function_code;
1247 /* Possibly apply some default attributes to this built-in function. */
1249 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
1251 decl_attributes (&decl, NULL_TREE, 0);
1256 /* Treelang expand function langhook. */
1259 treelang_expand_function (tree fndecl)
1261 /* We have nothing special to do while expanding functions for treelang. */
1262 tree_rest_of_compilation (fndecl);
1265 #include "debug.h" /* for debug_hooks, needed by gt-treelang-treetree.h */
1266 #include "gt-treelang-treetree.h"