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 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);
340 /* The back end needs them in reverse order. */
341 type_list = nreverse (type_list);
343 type_node = tree_code_get_type (ret_type);
344 fn_type = build_function_type (type_node, type_list);
346 id = get_identifier ((const char*)chars);
347 fn_decl = build_decl (FUNCTION_DECL, id, fn_type);
349 /* Nested functions not supported here. */
350 DECL_CONTEXT (fn_decl) = NULL_TREE;
351 DECL_SOURCE_LOCATION (fn_decl) = loc;
353 TREE_USED (fn_decl) = 1;
355 TREE_PUBLIC (fn_decl) = 0;
356 DECL_EXTERNAL (fn_decl) = 0;
357 TREE_STATIC (fn_decl) = 0;
358 switch (storage_class)
361 TREE_PUBLIC (fn_decl) = 0;
364 case EXTERNAL_DEFINITION_STORAGE:
365 TREE_PUBLIC (fn_decl) = 1;
366 TREE_STATIC (fn_decl) = 0;
367 DECL_EXTERNAL (fn_decl) = 0;
370 case EXTERNAL_REFERENCE_STORAGE:
371 TREE_PUBLIC (fn_decl) = 0;
372 DECL_EXTERNAL (fn_decl) = 1;
375 case AUTOMATIC_STORAGE:
380 /* Process declaration of function defined elsewhere. */
381 rest_of_decl_compilation (fn_decl, 1, 0);
387 /* Output code for start of function; the decl of the function is in
388 PREV_SAVED (as created by tree_code_create_function_prototype),
389 the function is at line number LINENO in file FILENAME. The
390 parameter details are in the lists PARMS. Returns nothing. */
392 tree_code_create_function_initial (tree prev_saved,
394 struct prod_token_parm_item* parms)
401 struct prod_token_parm_item* this_parm;
402 struct prod_token_parm_item* parm;
404 fn_decl = prev_saved;
405 gcc_assert (fn_decl);
407 /* Output message if not -quiet. */
408 announce_function (fn_decl);
410 /* This has something to do with forcing output also. */
413 /* Set current function for error msgs etc. */
414 current_function_decl = fn_decl;
415 DECL_INITIAL (fn_decl) = error_mark_node;
417 DECL_SOURCE_LOCATION (fn_decl) = loc;
419 /* Create a DECL for the functions result. */
421 build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (TREE_TYPE (fn_decl)));
422 DECL_CONTEXT (resultdecl) = fn_decl;
423 DECL_ARTIFICIAL (resultdecl) = 1;
424 DECL_IGNORED_P (resultdecl) = 1;
425 DECL_SOURCE_LOCATION (resultdecl) = loc;
426 DECL_RESULT (fn_decl) = resultdecl;
428 /* Make the argument variable decls. */
429 parm_list = NULL_TREE;
430 for (parm = parms; parm; parm = parm->tp.par.next)
432 parm_decl = build_decl (PARM_DECL, get_identifier
433 ((const char*) (parm->tp.par.variable_name)),
434 tree_code_get_type (parm->type));
436 /* Some languages have different nominal and real types. */
437 DECL_ARG_TYPE (parm_decl) = TREE_TYPE (parm_decl);
438 gcc_assert (DECL_ARG_TYPE (parm_decl));
439 gcc_assert (fn_decl);
440 DECL_CONTEXT (parm_decl) = fn_decl;
441 DECL_SOURCE_LOCATION (parm_decl) = loc;
442 parm_list = chainon (parm_decl, parm_list);
445 /* Back into reverse order as the back end likes them. */
446 parm_list = nreverse (parm_list);
448 DECL_ARGUMENTS (fn_decl) = parm_list;
450 /* Save the decls for use when the args are referred to. */
451 for (param_decl = DECL_ARGUMENTS (fn_decl),
454 param_decl = TREE_CHAIN (param_decl),
455 this_parm = this_parm->tp.par.next)
457 gcc_assert (this_parm); /* Too few. */
458 *this_parm->tp.par.where_to_put_var_tree = param_decl;
460 gcc_assert (!this_parm); /* Too many. */
462 /* Create a new level at the start of the function. */
466 /* Force it to be output, else may be solely inlined. */
467 TREE_ADDRESSABLE (fn_decl) = 1;
469 /* Stop -O3 from deleting it. */
470 TREE_USED (fn_decl) = 1;
473 /* Wrapup a function contained in file FILENAME, ending at line LINENO. */
475 tree_code_create_function_wrapup (location_t loc)
479 tree stmts = *getstmtlist ();
481 fn_decl = current_function_decl;
485 block = poplevel (1, 0, 1);
487 /* And attach it to the function. */
489 DECL_SAVED_TREE (fn_decl) = build3 (BIND_EXPR, void_type_node,
493 allocate_struct_function (fn_decl);
494 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);
516 The storage class is STORAGE_CLASS (eg LOCAL).
517 The name is CHARS/LENGTH.
518 The type is EXPRESSION_TYPE (eg UNSIGNED_TYPE).
519 The init tree is INIT.
523 tree_code_create_variable (unsigned int storage_class,
524 unsigned char* chars,
526 unsigned int expression_type,
534 /* 1. Build the type. */
535 var_type = tree_code_get_type (expression_type);
537 /* 2. Build the name. */
538 gcc_assert (chars[length] == 0); /* Should be null terminated. */
540 var_id = get_identifier ((const char*)chars);
542 /* 3. Build the decl and set up init. */
543 var_decl = build_decl (VAR_DECL, var_id, var_type);
545 /* 3a. Initialization. */
547 DECL_INITIAL (var_decl) = fold (build1 (CONVERT_EXPR, var_type, init));
549 DECL_INITIAL (var_decl) = NULL_TREE;
551 gcc_assert (TYPE_SIZE (var_type) != 0); /* Did not calculate size. */
553 DECL_CONTEXT (var_decl) = current_function_decl;
555 DECL_SOURCE_LOCATION (var_decl) = loc;
557 /* Set the storage mode and whether only visible in the same file. */
558 switch (storage_class)
561 TREE_STATIC (var_decl) = 1;
562 TREE_PUBLIC (var_decl) = 0;
565 case AUTOMATIC_STORAGE:
566 TREE_STATIC (var_decl) = 0;
567 TREE_PUBLIC (var_decl) = 0;
570 case EXTERNAL_DEFINITION_STORAGE:
571 TREE_STATIC (var_decl) = 0;
572 TREE_PUBLIC (var_decl) = 1;
575 case EXTERNAL_REFERENCE_STORAGE:
576 DECL_EXTERNAL (var_decl) = 1;
577 TREE_PUBLIC (var_decl) = 0;
584 /* This should really only be set if the variable is used. */
585 TREE_USED (var_decl) = 1;
587 /* Expand declaration and initial value if any. */
589 if (TREE_STATIC (var_decl))
590 rest_of_decl_compilation (var_decl, 0, 0);
592 TYPE_NAME (TREE_TYPE (var_decl)) = TYPE_NAME (var_type);
593 return pushdecl (copy_node (var_decl));
597 /* Generate code for return statement. Type is in TYPE, expression
598 is in EXP if present. */
601 tree_code_generate_return (tree type, tree exp)
604 #ifdef ENABLE_CHECKING
607 for (param = DECL_ARGUMENTS (current_function_decl);
609 param = TREE_CHAIN (param))
610 gcc_assert (DECL_CONTEXT (param) == current_function_decl);
613 if (exp && TREE_TYPE (TREE_TYPE (current_function_decl)) != void_type_node)
615 setret = fold (build2 (MODIFY_EXPR, type,
616 DECL_RESULT (current_function_decl),
617 fold (build1 (CONVERT_EXPR, type, exp))));
618 TREE_SIDE_EFFECTS (setret) = 1;
619 TREE_USED (setret) = 1;
620 setret = build1 (RETURN_EXPR, type, setret);
623 setret = build1 (RETURN_EXPR, type, NULL_TREE);
625 append_to_statement_list_force (setret, getstmtlist ());
629 /* Output the code for this expression statement CODE. */
632 tree_code_output_expression_statement (tree code, location_t loc)
634 /* Output the line number information. */
635 SET_EXPR_LOCATION (code, loc);
636 TREE_USED (code) = 1;
637 TREE_SIDE_EFFECTS (code) = 1;
638 /* put CODE into the code list. */
639 append_to_statement_list_force (code, getstmtlist ());
642 /* Return a tree for a constant integer value in the token TOK. No
643 size checking is done. */
646 tree_code_get_integer_value (unsigned char* chars, unsigned int length)
648 long long int val = 0;
650 unsigned int start = 0;
654 case (unsigned char)'-':
659 case (unsigned char)'+':
666 for (ix = start; ix < length; ix++)
667 val = val * 10 + chars[ix] - (unsigned char)'0';
669 return build_int_cst_wide (NULL_TREE,
670 val & 0xffffffff, (val >> 32) & 0xffffffff);
673 /* Return the tree for an expresssion, type EXP_TYPE (see treetree.h)
674 with tree type TYPE and with operands1 OP1, OP2 (maybe), OP3 (maybe). */
676 tree_code_get_expression (unsigned int exp_type,
677 tree type, tree op1, tree op2,
678 tree op3 ATTRIBUTE_UNUSED)
686 gcc_assert (op1 && op2);
687 operator = MODIFY_EXPR;
688 ret1 = fold (build2 (operator, void_type_node, op1,
689 fold (build1 (CONVERT_EXPR, TREE_TYPE (op1),
695 operator = PLUS_EXPR;
696 goto binary_expression;
699 operator = MINUS_EXPR;
700 goto binary_expression;
704 goto binary_expression;
706 /* Expand a binary expression. Ensure the operands are the right type. */
708 gcc_assert (op1 && op2);
709 ret1 = fold (build2 (operator, type,
710 fold (build1 (CONVERT_EXPR, type, op1)),
711 fold (build1 (CONVERT_EXPR, type, op2))));
714 /* Reference to a variable. This is dead easy, just return the
715 decl for the variable. If the TYPE is different than the
716 variable type, convert it. */
719 if (type == TREE_TYPE (op1))
722 ret1 = fold (build1 (CONVERT_EXPR, type, op1));
725 case EXP_FUNCTION_INVOCATION:
726 gcc_assert (op1 && op2);
729 fun_ptr = fold (build1 (ADDR_EXPR,
730 build_pointer_type (TREE_TYPE (op1)), op1));
731 ret1 = build3 (CALL_EXPR, type, fun_ptr, nreverse (op2), NULL_TREE);
742 /* Init parameter list and return empty list. */
745 tree_code_init_parameters (void)
750 /* Add a parameter EXP whose expression type is EXP_PROTO to list
751 LIST, returning the new list. */
754 tree_code_add_parameter (tree list, tree proto_exp, tree exp)
757 new_exp = tree_cons (NULL_TREE,
758 fold (build1 (CONVERT_EXPR, TREE_TYPE (proto_exp),
762 return chainon (new_exp, list);
765 /* Get a stringpool entry for a string S of length L. This is needed
766 because the GTY routines don't mark strings, forcing you to put
767 them into stringpool, which is never freed. */
770 get_string (const char *s, size_t l)
773 t = get_identifier_with_length (s, l);
774 return IDENTIFIER_POINTER(t);
777 /* Save typing debug_tree all the time. Dump a tree T pretty and
788 /* Routines Expected by gcc: */
790 /* These are used to build types for various sizes. The code below
791 is a simplified version of that of GNAT. */
793 #ifndef MAX_BITS_PER_WORD
794 #define MAX_BITS_PER_WORD BITS_PER_WORD
797 /* This variable keeps a table for types for each precision so that we only
798 allocate each of them once. Signed and unsigned types are kept separate. */
799 static GTY(()) tree signed_and_unsigned_types[MAX_BITS_PER_WORD + 1][2];
801 /* XXX is this definition OK? */
803 tree_lang_truthvalue_conversion (tree expr)
808 /* Mark EXP saying that we need to be able to take the
809 address of it; it should not be allocated in a register.
810 Value is 1 if successful.
812 This implementation was copied from c-decl.c. */
815 tree_mark_addressable (tree exp)
817 register tree x = exp;
819 switch (TREE_CODE (x))
826 x = TREE_OPERAND (x, 0);
830 TREE_ADDRESSABLE (x) = 1;
837 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
838 && DECL_NONLOCAL (x))
842 error ("Global register variable %qD used in nested function.",
846 pedwarn ("Register variable %qD used in nested function.", x);
848 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
852 error ("Address of global register variable %qD requested.",
857 pedwarn ("Address of register variable %qD requested.", x);
862 TREE_ADDRESSABLE (x) = 1;
869 /* Return an integer type with the number of bits of precision given by
870 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
871 it is a signed type. */
874 tree_lang_type_for_size (unsigned precision, int unsignedp)
878 if (precision <= MAX_BITS_PER_WORD
879 && signed_and_unsigned_types[precision][unsignedp] != 0)
880 return signed_and_unsigned_types[precision][unsignedp];
883 t = signed_and_unsigned_types[precision][1]
884 = make_unsigned_type (precision);
886 t = signed_and_unsigned_types[precision][0]
887 = make_signed_type (precision);
892 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
893 an unsigned type; otherwise a signed type is returned. */
896 tree_lang_type_for_mode (enum machine_mode mode, int unsignedp)
898 return tree_lang_type_for_size (GET_MODE_BITSIZE (mode), unsignedp);
901 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
904 tree_lang_unsigned_type (tree type_node)
906 return tree_lang_type_for_size (TYPE_PRECISION (type_node), 1);
909 /* Return the signed version of a TYPE_NODE, a scalar type. */
912 tree_lang_signed_type (tree type_node)
914 return tree_lang_type_for_size (TYPE_PRECISION (type_node), 0);
917 /* Return a type the same as TYPE except unsigned or signed according to
921 tree_lang_signed_or_unsigned_type (int unsignedp, tree type)
923 if (! INTEGRAL_TYPE_P (type) || TYPE_UNSIGNED (type) == unsignedp)
926 return tree_lang_type_for_size (TYPE_PRECISION (type), unsignedp);
929 /* These functions and variables deal with binding contours. We only
930 need these functions for the list of PARM_DECLs, but we leave the
931 functions more general; these are a simplified version of the
932 functions from GNAT. */
934 /* For each binding contour we allocate a binding_level structure which records
935 the entities defined or declared in that contour. Contours include:
938 one for each subprogram definition
939 one for each compound statement (declare block)
941 Binding contours are used to create GCC tree BLOCK nodes. */
945 /* A chain of ..._DECL nodes for all variables, constants, functions,
946 parameters and type declarations. These ..._DECL nodes are chained
947 through the TREE_CHAIN field. Note that these ..._DECL nodes are stored
948 in the reverse of the order supplied to be compatible with the
951 /* For each level (except the global one), a chain of BLOCK nodes for all
952 the levels that were entered and exited one level down from this one. */
956 /* The binding level containing this one (the enclosing binding level). */
957 struct binding_level *level_chain;
960 /* The binding level currently in effect. */
961 static struct binding_level *current_binding_level = NULL;
963 /* The outermost binding level. This binding level is created when the
964 compiler is started and it will exist through the entire compilation. */
965 static struct binding_level *global_binding_level;
967 /* Binding level structures are initialized by copying this one. */
968 static struct binding_level clear_binding_level = {NULL, NULL, NULL, NULL };
970 /* Return non-zero if we are currently in the global binding level. */
973 global_bindings_p (void)
975 return current_binding_level == global_binding_level ? -1 : 0;
979 /* Return the list of declarations in the current level. Note that this list
980 is in reverse order (it has to be so for back-end compatibility). */
985 return current_binding_level->names;
988 /* Return a STATMENT_LIST for the current block. */
993 return ¤t_binding_level->stmts;
996 /* Enter a new binding level. The input parameter is ignored, but has to be
997 specified for back-end compatibility. */
1000 pushlevel (int ignore ATTRIBUTE_UNUSED)
1002 struct binding_level *newlevel = xmalloc (sizeof (struct binding_level));
1004 *newlevel = clear_binding_level;
1006 /* Add this level to the front of the chain (stack) of levels that are
1008 newlevel->level_chain = current_binding_level;
1009 current_binding_level = newlevel;
1010 current_binding_level->stmts = alloc_stmt_list ();
1013 /* Exit a binding level.
1014 Pop the level off, and restore the state of the identifier-decl mappings
1015 that were in effect when this level was entered.
1017 If KEEP is nonzero, this level had explicit declarations, so
1018 and create a "block" (a BLOCK node) for the level
1019 to record its declarations and subblocks for symbol table output.
1021 If FUNCTIONBODY is nonzero, this level is the body of a function,
1022 so create a block as if KEEP were set and also clear out all
1025 If REVERSE is nonzero, reverse the order of decls before putting
1026 them into the BLOCK. */
1029 poplevel (int keep, int reverse, int functionbody)
1031 /* Points to a BLOCK tree node. This is the BLOCK node construted for the
1032 binding level that we are about to exit and which is returned by this
1034 tree block_node = NULL_TREE;
1036 tree subblock_chain = current_binding_level->blocks;
1039 /* Reverse the list of *_DECL nodes if desired. Note that the ..._DECL
1040 nodes chained through the `names' field of current_binding_level are in
1041 reverse order except for PARM_DECL node, which are explicitely stored in
1043 decl_chain = (reverse) ? nreverse (current_binding_level->names)
1044 : current_binding_level->names;
1046 /* If there were any declarations in the current binding level, or if this
1047 binding level is a function body, or if there are any nested blocks then
1048 create a BLOCK node to record them for the life of this function. */
1049 if (keep || functionbody)
1050 block_node = build_block (keep ? decl_chain : 0, 0, subblock_chain, 0, 0);
1052 /* Record the BLOCK node just built as the subblock its enclosing scope. */
1053 for (subblock_node = subblock_chain; subblock_node;
1054 subblock_node = TREE_CHAIN (subblock_node))
1055 BLOCK_SUPERCONTEXT (subblock_node) = block_node;
1057 /* Clear out the meanings of the local variables of this level. */
1059 for (subblock_node = decl_chain; subblock_node;
1060 subblock_node = TREE_CHAIN (subblock_node))
1061 if (DECL_NAME (subblock_node) != 0)
1062 /* If the identifier was used or addressed via a local extern decl,
1063 don't forget that fact. */
1064 if (DECL_EXTERNAL (subblock_node))
1066 if (TREE_USED (subblock_node))
1067 TREE_USED (DECL_NAME (subblock_node)) = 1;
1070 /* Pop the current level. */
1071 current_binding_level = current_binding_level->level_chain;
1075 /* This is the top level block of a function. */
1076 DECL_INITIAL (current_function_decl) = block_node;
1078 else if (block_node)
1080 current_binding_level->blocks
1081 = chainon (current_binding_level->blocks, block_node);
1084 /* If we did not make a block for the level just exited, any blocks made for
1085 inner levels (since they cannot be recorded as subblocks in that level)
1086 must be carried forward so they will later become subblocks of something
1088 else if (subblock_chain)
1089 current_binding_level->blocks
1090 = chainon (current_binding_level->blocks, subblock_chain);
1092 TREE_USED (block_node) = 1;
1097 /* Insert BLOCK at the end of the list of subblocks of the
1098 current binding level. This is used when a BIND_EXPR is expanded,
1099 to handle the BLOCK node inside the BIND_EXPR. */
1102 insert_block (tree block)
1104 TREE_USED (block) = 1;
1105 current_binding_level->blocks
1106 = chainon (current_binding_level->blocks, block);
1110 /* Records a ..._DECL node DECL as belonging to the current lexical scope.
1111 Returns the ..._DECL node. */
1114 pushdecl (tree decl)
1116 /* External objects aren't nested, other objects may be. */
1118 if ((DECL_EXTERNAL (decl)) || (decl==current_function_decl))
1119 DECL_CONTEXT (decl) = 0;
1121 DECL_CONTEXT (decl) = current_function_decl;
1123 /* Put the declaration on the list. The list of declarations is in reverse
1124 order. The list will be reversed later if necessary. This needs to be
1125 this way for compatibility with the back-end. */
1127 TREE_CHAIN (decl) = current_binding_level->names;
1128 current_binding_level->names = decl;
1130 /* For the declartion of a type, set its name if it is not already set. */
1132 if (TREE_CODE (decl) == TYPE_DECL
1133 && TYPE_NAME (TREE_TYPE (decl)) == 0)
1134 TYPE_NAME (TREE_TYPE (decl)) = DECL_NAME (decl);
1141 tree_push_type_decl(tree id, tree type_node)
1143 tree decl = build_decl (TYPE_DECL, id, type_node);
1144 TYPE_NAME (type_node) = id;
1148 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
1150 /* Create the predefined scalar types of C,
1151 and some nodes representing standard constants (0, 1, (void *) 0).
1152 Initialize the global binding level.
1153 Make definitions for built-in primitive functions. */
1156 treelang_init_decl_processing (void)
1158 current_function_decl = NULL;
1159 current_binding_level = NULL_BINDING_LEVEL;
1160 pushlevel (0); /* make the binding_level structure for global names */
1161 global_binding_level = current_binding_level;
1163 build_common_tree_nodes (flag_signed_char, false);
1165 /* set standard type names */
1167 /* Define `int' and `char' last so that they are not overwritten. */
1168 tree_push_type_decl (NULL_TREE, intQI_type_node);
1169 tree_push_type_decl (NULL_TREE, intHI_type_node);
1170 tree_push_type_decl (NULL_TREE, intSI_type_node);
1171 tree_push_type_decl (NULL_TREE, intDI_type_node);
1172 #if HOST_BITS_PER_WIDE_INT >= 64
1173 tree_push_type_decl (NULL_TREE, intTI_type_node);
1175 tree_push_type_decl (NULL_TREE, unsigned_intQI_type_node);
1176 tree_push_type_decl (NULL_TREE, unsigned_intHI_type_node);
1177 tree_push_type_decl (NULL_TREE, unsigned_intSI_type_node);
1178 tree_push_type_decl (NULL_TREE, unsigned_intDI_type_node);
1179 #if HOST_BITS_PER_WIDE_INT >= 64
1180 tree_push_type_decl (NULL_TREE, unsigned_intTI_type_node);
1183 tree_push_type_decl (get_identifier ("int"), integer_type_node);
1184 tree_push_type_decl (get_identifier ("char"), char_type_node);
1185 tree_push_type_decl (get_identifier ("long int"),
1186 long_integer_type_node);
1187 tree_push_type_decl (get_identifier ("unsigned int"),
1188 unsigned_type_node);
1189 tree_push_type_decl (get_identifier ("long unsigned int"),
1190 long_unsigned_type_node);
1191 tree_push_type_decl (get_identifier ("long long int"),
1192 long_long_integer_type_node);
1193 tree_push_type_decl (get_identifier ("long long unsigned int"),
1194 long_long_unsigned_type_node);
1195 tree_push_type_decl (get_identifier ("short int"),
1196 short_integer_type_node);
1197 tree_push_type_decl (get_identifier ("short unsigned int"),
1198 short_unsigned_type_node);
1199 tree_push_type_decl (get_identifier ("signed char"),
1200 signed_char_type_node);
1201 tree_push_type_decl (get_identifier ("unsigned char"),
1202 unsigned_char_type_node);
1203 size_type_node = make_unsigned_type (POINTER_SIZE);
1204 tree_push_type_decl (get_identifier ("size_t"), size_type_node);
1205 set_sizetype (size_type_node);
1207 build_common_tree_nodes_2 (/* short_double= */ 0);
1209 tree_push_type_decl (get_identifier ("float"), float_type_node);
1210 tree_push_type_decl (get_identifier ("double"), double_type_node);
1211 tree_push_type_decl (get_identifier ("long double"), long_double_type_node);
1212 tree_push_type_decl (get_identifier ("void"), void_type_node);
1214 /* Add any target-specific builtin functions. */
1215 (*targetm.init_builtins) ();
1217 pedantic_lvalues = pedantic;
1220 /* Return a definition for a builtin function named NAME and whose data type
1221 is TYPE. TYPE should be a function type with argument types.
1222 FUNCTION_CODE tells later passes how to compile calls to this function.
1223 See tree.h for its possible values.
1225 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
1226 the name to be called if we can't opencode the function. If
1227 ATTRS is nonzero, use that for the function's attribute list.
1229 copied from gcc/c-decl.c
1233 builtin_function (const char *name, tree type, int function_code,
1234 enum built_in_class class, const char *library_name,
1237 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
1238 DECL_EXTERNAL (decl) = 1;
1239 TREE_PUBLIC (decl) = 1;
1241 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
1243 DECL_BUILT_IN_CLASS (decl) = class;
1244 DECL_FUNCTION_CODE (decl) = function_code;
1246 /* Possibly apply some default attributes to this built-in function. */
1248 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
1250 decl_attributes (&decl, NULL_TREE, 0);
1255 /* Treelang expand function langhook. */
1258 treelang_expand_function (tree fndecl)
1260 /* We have nothing special to do while expanding functions for treelang. */
1261 tree_rest_of_compilation (fndecl);
1264 #include "debug.h" /* for debug_hooks, needed by gt-treelang-treetree.h */
1265 #include "gt-treelang-treetree.h"