3 TREELANG Compiler back end interface (treetree.c)
6 If you want a working example of how to write a front end to GCC,
7 you are in the right place.
9 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
10 2001, 2002 Free Software Foundation, Inc.
12 This code is based on toy.c written by Richard Kenner.
14 It was later modified by Jonathan Bartlett whose changes have all
15 been removed (by Tim Josling).
17 Various bits and pieces were cloned from the GCC main tree, as
18 GCC evolved, for COBOLForGCC, by Tim Josling.
20 It was adapted to TREELANG by Tim Josling 2001.
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 ---------------------------------------------------------------------------
48 Assumption: garbage collection is never called implicitly. It will
49 not be called 'at any time' when short of memory. It will only be
50 called explicitly at the end of each function. This removes the
51 need for a *lot* of bother to ensure everything is in the mark trees
54 /* Note it is OK to use GCC extensions such as long long in a compiler front end.
55 This is because the GCC front ends are built using GCC. */
57 /* Standard/OS headers. */
61 #include "safe-ctype.h"
84 #include "langhooks-def.h"
85 #include "langhooks.h"
90 extern int option_main
;
91 extern char **file_names
;
93 /* The front end language hooks (addresses of code for this front
94 end). Mostly just use the C routines. */
96 #undef LANG_HOOKS_TRUTHVALUE_CONVERSION
97 #define LANG_HOOKS_TRUTHVALUE_CONVERSION c_common_truthvalue_conversion
98 #undef LANG_HOOKS_MARK_ADDRESSABLE
99 #define LANG_HOOKS_MARK_ADDRESSABLE c_mark_addressable
100 #undef LANG_HOOKS_SIGNED_TYPE
101 #define LANG_HOOKS_SIGNED_TYPE c_common_signed_type
102 #undef LANG_HOOKS_UNSIGNED_TYPE
103 #define LANG_HOOKS_UNSIGNED_TYPE c_common_unsigned_type
104 #undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE
105 #define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE c_common_signed_or_unsigned_type
106 #undef LANG_HOOKS_TYPE_FOR_MODE
107 #define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode
108 #undef LANG_HOOKS_TYPE_FOR_SIZE
109 #define LANG_HOOKS_TYPE_FOR_SIZE c_common_type_for_size
110 #undef LANG_HOOKS_PARSE_FILE
111 #define LANG_HOOKS_PARSE_FILE treelang_parse_file
112 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
113 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE c_common_attribute_table
114 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
115 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE c_common_format_attribute_table
116 #undef LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES
117 #define LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES c_insert_default_attributes
119 /* Hook routines and data unique to treelang. */
121 #undef LANG_HOOKS_INIT
122 #define LANG_HOOKS_INIT treelang_init
123 #undef LANG_HOOKS_NAME
124 #define LANG_HOOKS_NAME "GNU treelang"
125 #undef LANG_HOOKS_FINISH
126 #define LANG_HOOKS_FINISH treelang_finish
127 #undef LANG_HOOKS_DECODE_OPTION
128 #define LANG_HOOKS_DECODE_OPTION treelang_decode_option
129 const struct lang_hooks lang_hooks
= LANG_HOOKS_INITIALIZER
;
131 /* Tree code type/name/code tables. */
133 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
135 const char tree_code_type
[] = {
141 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
143 const unsigned char tree_code_length
[] = {
149 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
151 const char *const tree_code_name
[] = {
157 /* Number of bits in int and char - accessed by front end. */
159 unsigned int tree_code_int_size
= 0;
160 unsigned int tree_code_char_size
= 0;
162 /* Return the tree stuff for this type TYPE_NUM. */
165 tree_code_get_type (int type_num
)
170 return signed_char_type_node
;
173 return unsigned_char_type_node
;
176 return integer_type_node
;
179 return unsigned_type_node
;
182 return void_type_node
;
189 /* Output the code for the start of an if statement. The test
190 expression is EXP (true if not zero), and the stmt occurred at line
191 LINENO in file FILENAME. */
194 tree_code_if_start (tree exp
, unsigned char* filename
, int lineno
)
197 cond_exp
= build (NE_EXPR
,
200 build1 (CONVERT_EXPR
, TREE_TYPE (exp
), integer_zero_node
));
201 emit_line_note ((const char *)filename
, lineno
); /* Output the line number information. */
202 expand_start_cond (cond_exp
, /* Exit-able if nonzero. */ 0);
205 /* Output the code for the else of an if statement. The else occurred
206 at line LINENO in file FILENAME. */
209 tree_code_if_else (unsigned char* filename
, int lineno
)
211 emit_line_note ((const char *)filename
, lineno
); /* Output the line number information. */
212 expand_start_else ();
215 /* Output the code for the end_if an if statement. The end_if (final brace) occurred
216 at line LINENO in file FILENAME. */
219 tree_code_if_end (unsigned char* filename
, int lineno
)
221 emit_line_note ((const char *)filename
, lineno
); /* Output the line number information. */
225 /* Create a function. The prototype name is NAME, storage class is
226 STORAGE_CLASS, type of return variable is RET_TYPE, parameter lists
227 is PARMS, returns decl for this function. */
230 tree_code_create_function_prototype (unsigned char* chars
,
231 unsigned int storage_class
,
232 unsigned int ret_type
,
233 struct prod_token_parm_item
* parms
,
234 unsigned char* filename
,
239 struct prod_token_parm_item
* parm
;
240 tree type_list
= NULL_TREE
;
245 /* Build the type. */
246 id
= get_identifier ((const char*)chars
);
247 for (parm
= parms
; parm
; parm
= parm
->tp
.par
.next
)
249 type_node
= get_type_for_numeric_type (parm
->type
);
250 type_list
= tree_cons (NULL_TREE
, type_node
, type_list
);
252 /* Last parm if void indicates fixed length list (as opposed to
253 printf style va_* list). */
254 type_list
= tree_cons (NULL_TREE
, void_type_node
, type_list
);
255 /* The back end needs them in reverse order. */
256 type_list
= nreverse (type_list
);
258 type_node
= get_type_for_numeric_type (ret_type
);
259 fn_type
= build_function_type (type_node
, type_list
);
261 id
= get_identifier ((const char*)chars
);
262 fn_decl
= build_decl (FUNCTION_DECL
, id
, fn_type
);
264 DECL_CONTEXT (fn_decl
) = NULL_TREE
; /* Nested functions not supported here. */
265 DECL_SOURCE_FILE (fn_decl
) = (const char *)filename
;
266 /* if (lineno > 1000000)
267 ; */ /* Probably the line # is rubbish because someone forgot to set
268 the line number - and unfortunately impossible line #s are used as
269 magic flags at various times. The longest known function for
270 example is about 550,000 lines (it was written in COBOL). */
271 DECL_SOURCE_LINE (fn_decl
) = lineno
;
273 TREE_USED (fn_decl
) = 1;
275 /* Real name (optional). */
276 SET_DECL_ASSEMBLER_NAME (fn_decl
, DECL_NAME (fn_decl
));
278 TREE_PUBLIC (fn_decl
) = 0;
279 DECL_EXTERNAL (fn_decl
) = 0;
280 TREE_STATIC (fn_decl
) = 0;
281 switch (storage_class
)
284 TREE_PUBLIC (fn_decl
) = 0;
287 case EXTERNAL_DEFINITION_STORAGE
:
288 TREE_PUBLIC (fn_decl
) = 1;
289 TREE_STATIC (fn_decl
) = 0;
290 DECL_EXTERNAL (fn_decl
) = 0;
293 case EXTERNAL_REFERENCE_STORAGE
:
294 TREE_PUBLIC (fn_decl
) = 0;
295 DECL_EXTERNAL (fn_decl
) = 1;
299 case AUTOMATIC_STORAGE
:
304 /* Process declaration of function defined elsewhere. */
305 rest_of_decl_compilation (fn_decl
, NULL
, 1, 0);
311 /* Output code for start of function; the decl of the function is in
312 PREV_SAVED (as created by tree_code_create_function_prototype),
313 the function is at line number LINENO in file FILENAME. The
314 parameter details are in the lists PARMS. Returns nothing. */
316 tree_code_create_function_initial (tree prev_saved
,
317 unsigned char* filename
,
319 struct prod_token_parm_item
* parms
)
328 struct prod_token_parm_item
* this_parm
;
329 struct prod_token_parm_item
* parm
;
331 fn_decl
= prev_saved
;
335 /* Output message if not -quiet. */
336 announce_function (fn_decl
);
338 /* This has something to do with forcing output also. */
341 /* Set current function for error msgs etc. */
342 current_function_decl
= fn_decl
;
343 DECL_INITIAL (fn_decl
) = error_mark_node
;
345 DECL_SOURCE_FILE (fn_decl
) = (const char *)filename
;
346 DECL_SOURCE_LINE (fn_decl
) = lineno
;
348 /* Prepare creation of rtl for a new function. */
350 resultdecl
= DECL_RESULT (fn_decl
) = build_decl (RESULT_DECL
, NULL_TREE
, TREE_TYPE (TREE_TYPE (fn_decl
)));
351 DECL_CONTEXT (DECL_RESULT (fn_decl
)) = fn_decl
;
352 DECL_SOURCE_FILE (resultdecl
) = (const char *)filename
;
353 DECL_SOURCE_LINE (resultdecl
) = lineno
;
354 /* Work out the size. ??? is this needed. */
355 layout_decl (DECL_RESULT (fn_decl
), 0);
357 /* Make the argument variable decls. */
358 parm_list
= NULL_TREE
;
359 for (parm
= parms
; parm
; parm
= parm
->tp
.par
.next
)
361 parm_decl
= build_decl (PARM_DECL
, get_identifier
362 ((const char*) (parm
->tp
.par
.variable_name
)),
363 get_type_for_numeric_type (parm
->type
));
365 /* Some languages have different nominal and real types. */
366 DECL_ARG_TYPE (parm_decl
) = TREE_TYPE (parm_decl
);
367 if (!DECL_ARG_TYPE (parm_decl
))
371 DECL_CONTEXT (parm_decl
) = fn_decl
;
372 DECL_SOURCE_FILE (parm_decl
) = (const char *)filename
;
373 DECL_SOURCE_LINE (parm_decl
) = lineno
;
374 parm_list
= chainon (parm_decl
, parm_list
);
377 /* Back into reverse order as the back end likes them. */
378 parm_list
= nreverse (parm_list
);
380 DECL_ARGUMENTS (fn_decl
) = parm_list
;
382 /* Save the decls for use when the args are referred to. */
383 for (param_decl
= DECL_ARGUMENTS (fn_decl
),
386 param_decl
= TREE_CHAIN (param_decl
),
387 this_parm
= this_parm
->tp
.par
.next
)
390 abort (); /* Too few. */
391 *this_parm
->tp
.par
.where_to_put_var_tree
= param_decl
;
394 abort (); /* Too many. */
396 /* Output the decl rtl (not the rtl for the function code). ???.
397 If the function is not defined in this file, when should you
399 make_decl_rtl (fn_decl
, NULL
);
401 /* Use filename/lineno from above. */
402 init_function_start (fn_decl
, (const char *)filename
, lineno
);
404 /* Create rtl for startup code of function, such as saving registers. */
406 expand_function_start (fn_decl
, 0);
408 /* Function.c requires a push at the start of the function. that
409 looks like a bug to me but let's make it happy. */
411 (*lang_hooks
.decls
.pushlevel
) (0);
413 /* Create rtl for the start of a new scope. */
415 expand_start_bindings (2);
417 /* Put the parameters into the symbol table. */
419 for (first_param
= param_decl
= nreverse (DECL_ARGUMENTS (fn_decl
));
421 param_decl
= next_param
)
423 next_param
= TREE_CHAIN (param_decl
);
424 TREE_CHAIN (param_decl
) = NULL
;
425 /* layout_decl (param_decl, 0); Already done in build_decl tej 13/4/2002. */
426 pushdecl (param_decl
);
427 if (DECL_CONTEXT (param_decl
) != current_function_decl
)
431 /* Store back the PARM_DECL nodes. They appear in the right order. */
432 DECL_ARGUMENTS (fn_decl
) = getdecls ();
434 /* Force it to be output, else may be solely inlined. */
435 TREE_ADDRESSABLE (fn_decl
) = 1;
437 /* Stop -O3 from deleting it. */
438 TREE_USED (fn_decl
) = 1;
440 /* Add a new level to the debugger symbol table. */
442 (*lang_hooks
.decls
.pushlevel
) (0);
444 /* Create rtl for the start of a new scope. */
446 expand_start_bindings (0);
448 emit_line_note ((const char *)filename
, lineno
); /* Output the line number information. */
451 /* Wrapup a function contained in file FILENAME, ending at line LINENO. */
453 tree_code_create_function_wrapup (unsigned char* filename
,
459 fn_decl
= current_function_decl
;
461 emit_line_note ((const char *)filename
, lineno
); /* Output the line number information. */
463 /* Get completely built level from debugger symbol table. */
465 block
= (*lang_hooks
.decls
.poplevel
) (1, 0, 0);
467 /* Emit rtl for end of scope. */
469 expand_end_bindings (block
, 0, 1);
471 /* Emit rtl for end of function. */
473 expand_function_end ((const char *)filename
, lineno
, 0);
477 block
= (*lang_hooks
.decls
.poplevel
) (1, 0, 1);
479 /* And attach it to the function. */
481 DECL_INITIAL (fn_decl
) = block
;
483 /* Emit rtl for end of scope. */
485 expand_end_bindings (block
, 0, 1);
487 /* Call optimization and convert optimized rtl to assembly code. */
489 rest_of_compilation (fn_decl
);
491 /* We are not inside of any scope now. */
493 current_function_decl
= NULL_TREE
;
499 The storage class is STORAGE_CLASS (eg LOCAL).
500 The name is CHARS/LENGTH.
501 The type is EXPRESSION_TYPE (eg UNSIGNED_TYPE).
502 The init tree is INIT.
506 tree_code_create_variable (unsigned int storage_class
,
507 unsigned char* chars
,
509 unsigned int expression_type
,
511 unsigned char* filename
,
518 /* 1. Build the type. */
519 var_type
= get_type_for_numeric_type (expression_type
);
521 /* 2. Build the name. */
522 if (chars
[length
] != 0)
523 abort (); /* Should be null terminated. */
525 var_id
= get_identifier ((const char*)chars
);
527 /* 3. Build the decl and set up init. */
528 var_decl
= build_decl (VAR_DECL
, var_id
, var_type
);
530 /* 3a. Initialization. */
532 DECL_INITIAL (var_decl
) = build1 (CONVERT_EXPR
, var_type
, init
);
534 DECL_INITIAL (var_decl
) = NULL_TREE
;
536 /* 4. Compute size etc. */
537 layout_decl (var_decl
, 0);
539 if (TYPE_SIZE (var_type
) == 0)
540 abort (); /* Did not calculate size. */
542 DECL_CONTEXT (var_decl
) = current_function_decl
;
544 DECL_SOURCE_FILE (var_decl
) = (const char *)filename
;
545 DECL_SOURCE_LINE (var_decl
) = lineno
;
547 /* Set the storage mode and whether only visible in the same file. */
548 switch (storage_class
)
551 TREE_STATIC (var_decl
) = 1;
552 TREE_PUBLIC (var_decl
) = 0;
555 case AUTOMATIC_STORAGE
:
556 TREE_STATIC (var_decl
) = 0;
557 TREE_PUBLIC (var_decl
) = 0;
560 case EXTERNAL_DEFINITION_STORAGE
:
561 TREE_STATIC (var_decl
) = 0;
562 TREE_PUBLIC (var_decl
) = 1;
565 case EXTERNAL_REFERENCE_STORAGE
:
566 DECL_EXTERNAL (var_decl
) = 1;
567 TREE_PUBLIC (var_decl
) = 0;
574 /* This should really only be set if the variable is used. */
575 TREE_USED (var_decl
) = 1;
577 /* Expand declaration and initial value if any. */
579 if (TREE_STATIC (var_decl
))
580 rest_of_decl_compilation (var_decl
, 0, 0, 0);
583 expand_decl (var_decl
);
584 if (DECL_INITIAL (var_decl
))
585 expand_decl_init (var_decl
);
588 return pushdecl (copy_node (var_decl
));
593 /* Generate code for return statement. Type is in TYPE, expression
594 is in EXP if present. */
597 tree_code_generate_return (tree type
, tree exp
)
602 for (param
= DECL_ARGUMENTS (current_function_decl
);
604 param
= TREE_CHAIN (param
))
606 if (DECL_CONTEXT (param
) != current_function_decl
)
612 setret
= build (MODIFY_EXPR
, type
, DECL_RESULT (current_function_decl
),
613 build1 (CONVERT_EXPR
, type
, exp
));
614 TREE_SIDE_EFFECTS (setret
) = 1;
615 TREE_USED (setret
) = 1;
616 expand_expr_stmt (setret
);
618 expand_return (DECL_RESULT (current_function_decl
));
621 /* Output the code for this expression statement CODE. */
625 tree_code_output_expression_statement (tree code
,
626 unsigned char* filename
, int lineno
)
628 /* Output the line number information. */
629 emit_line_note ((const char *)filename
, lineno
);
630 TREE_USED (code
) = 1;
631 TREE_SIDE_EFFECTS (code
) = 1;
632 expand_expr_stmt (code
);
635 /* Return a tree for a constant integer value in the token TOK. No
636 size checking is done. */
639 tree_code_get_integer_value (unsigned char* chars
, unsigned int length
)
641 long long int val
= 0;
643 unsigned int start
= 0;
647 case (unsigned char)'-':
652 case (unsigned char)'+':
659 for (ix
= start
; ix
< length
; ix
++)
660 val
= val
* 10 + chars
[ix
] - (unsigned char)'0';
662 return build_int_2 (val
& 0xffffffff, (val
>> 32) & 0xffffffff);
665 /* Return the tree for an expresssion, type EXP_TYPE (see treetree.h)
666 with tree type TYPE and with operands1 OP1, OP2 (maybe), OP3 (maybe). */
668 tree_code_get_expression (unsigned int exp_type
,
669 tree type
, tree op1
, tree op2
, tree op3 ATTRIBUTE_UNUSED
)
679 operator = MODIFY_EXPR
;
680 ret1
= build (operator, type
,
682 build1 (CONVERT_EXPR
, type
, op2
));
687 operator = PLUS_EXPR
;
688 goto binary_expression
;
691 operator = MINUS_EXPR
;
692 goto binary_expression
;
696 goto binary_expression
;
698 /* Expand a binary expression. Ensure the operands are the right type. */
702 ret1
= build (operator, type
,
703 build1 (CONVERT_EXPR
, type
, op1
),
704 build1 (CONVERT_EXPR
, type
, op2
));
707 /* Reference to a variable. This is dead easy, just return the
708 decl for the variable. If the TYPE is different than the
709 variable type, convert it. */
713 if (type
== TREE_TYPE (op1
))
716 ret1
= build1 (CONVERT_EXPR
, type
, op1
);
719 case EXP_FUNCTION_INVOCATION
:
724 fun_ptr
= build1 (ADDR_EXPR
, build_pointer_type (type
), op1
);
725 ret1
= build (CALL_EXPR
, type
, fun_ptr
, nreverse (op2
));
736 /* Init parameter list and return empty list. */
739 tree_code_init_parameters (void)
744 /* Add a parameter EXP whose expression type is EXP_PROTO to list
745 LIST, returning the new list. */
748 tree_code_add_parameter (tree list
, tree proto_exp
, tree exp
)
751 new_exp
= tree_cons (NULL_TREE
,
752 build1 (CONVERT_EXPR
, TREE_TYPE (proto_exp
), exp
),
756 return chainon (new_exp
, list
);
759 /* Get the tree type for this type whose number is NUMERIC_TYPE. */
762 get_type_for_numeric_type (unsigned int numeric_type
)
767 switch (numeric_type
)
770 return void_type_node
;
773 size1
= tree_code_int_size
;
778 size1
= tree_code_int_size
;
783 size1
= tree_code_char_size
;
788 size1
= tree_code_char_size
;
796 return tree_code_get_numeric_type (size1
, sign1
);
800 /* Return tree representing a numeric type of size SIZE1 bits and
801 signed if SIGN1 != 0. */
803 tree_code_get_numeric_type (unsigned int size1
, unsigned int sign1
)
806 if (size1
== tree_code_int_size
)
809 ret1
= integer_type_node
;
811 ret1
= unsigned_type_node
;
814 if (size1
== tree_code_char_size
)
817 ret1
= signed_char_type_node
;
819 ret1
= unsigned_char_type_node
;
827 /* Garbage Collection. */
829 /* Callback to mark storage M as used always. */
832 tree_ggc_storage_always_used (void * m
)
834 void **mm
; /* Actually M is a pointer to a pointer to the memory. */
841 /* Following from c-lang.c. */
843 /* Used by c-typeck.c (build_external_ref), but only for objc. */
846 lookup_objc_ivar (tree id ATTRIBUTE_UNUSED
)
851 /* Dummy routines called from c code. Save copying c-decl.c, c-common.c etc. */
854 objc_is_id (tree arg ATTRIBUTE_UNUSED
)
860 check_function_format (int *status ATTRIBUTE_UNUSED
,
861 tree attrs ATTRIBUTE_UNUSED
,
862 tree params ATTRIBUTE_UNUSED
)
867 /* Tell the c code we are not objective C. */
870 objc_comptypes (tree lhs ATTRIBUTE_UNUSED
,
871 tree rhs ATTRIBUTE_UNUSED
,
872 int reflexive ATTRIBUTE_UNUSED
)
877 /* Should not be called for treelang. */
880 build_stmt
VPARAMS ((enum tree_code code ATTRIBUTE_UNUSED
, ...))
885 /* Should not be called for treelang. */
888 add_stmt (tree t ATTRIBUTE_UNUSED
)
893 /* Should not be called for treelang. */
896 build_return_stmt (tree expr ATTRIBUTE_UNUSED
)
901 /* C warning, ignore. */
904 pedwarn_c99
VPARAMS ((const char *msgid ATTRIBUTE_UNUSED
, ...))
909 /* Should not be called for treelang. */
912 build_case_label (tree low_value ATTRIBUTE_UNUSED
,
913 tree high_value ATTRIBUTE_UNUSED
,
914 tree label_decl ATTRIBUTE_UNUSED
)
919 /* Should not be called for treelang. */
922 emit_local_var (tree decl ATTRIBUTE_UNUSED
)
927 /* Should not be called for treelang. */
930 expand_stmt (tree t ATTRIBUTE_UNUSED
)
935 /* Should not be called for treelang. */
938 cpp_create_reader (enum c_lang lang ATTRIBUTE_UNUSED
)
943 /* Should not be called for treelang. */
946 init_c_lex (const char *filename ATTRIBUTE_UNUSED
)
951 /* Should not be called for treelang. */
953 void init_pragma (void);
961 /* Should not be called for treelang. */
964 cpp_finish (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f ATTRIBUTE_UNUSED
)
969 /* Should not be called for treelang. */
972 cpp_errors (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
977 /* Dummy called by C. */
980 handle_format_attribute (tree
*node ATTRIBUTE_UNUSED
,
981 tree name ATTRIBUTE_UNUSED
,
982 tree args ATTRIBUTE_UNUSED
,
983 int flags ATTRIBUTE_UNUSED
,
984 bool *no_add_attrs ATTRIBUTE_UNUSED
)
989 /* Should not be called for treelang. */
992 handle_format_arg_attribute (tree
*node ATTRIBUTE_UNUSED
,
993 tree name ATTRIBUTE_UNUSED
,
994 tree args ATTRIBUTE_UNUSED
,
995 int flags ATTRIBUTE_UNUSED
,
996 bool *no_add_attrs ATTRIBUTE_UNUSED
)
1001 /* Should not be called for treelang. */
1004 cpp_handle_option (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1005 int argc ATTRIBUTE_UNUSED
,
1006 char **argv ATTRIBUTE_UNUSED
)
1011 /* Should not be called for treelang. */
1014 cpp_assert (cpp_reader
* cr ATTRIBUTE_UNUSED
,
1015 const char *s ATTRIBUTE_UNUSED
)
1020 /* Should not be called for treelang. */
1023 set_Wformat (int setting ATTRIBUTE_UNUSED
)
1028 /* Used for objective C. */
1031 objc_check_decl (tree decl ATTRIBUTE_UNUSED
);
1034 objc_check_decl (tree decl ATTRIBUTE_UNUSED
)
1039 /* Tell the c code we are not objective C. */
1042 objc_message_selector (void);
1045 objc_message_selector ()
1050 /* Should not be called for treelang. */
1053 gen_aux_info_record (tree fndecl ATTRIBUTE_UNUSED
,
1054 int is_definition ATTRIBUTE_UNUSED
,
1055 int is_implicit ATTRIBUTE_UNUSED
,
1056 int is_prototyped ATTRIBUTE_UNUSED
)
1061 /* Should not be called for treelang, but it is. */
1069 /* Should not be called for treelang. */
1071 void maybe_apply_pragma_weak (tree decl
);
1074 maybe_apply_pragma_weak (tree decl ATTRIBUTE_UNUSED
)
1079 /* Should not be called for treelang. */
1082 add_decl_stmt (tree decl ATTRIBUTE_UNUSED
)
1087 /* Should not be called for treelang. */
1090 maybe_apply_renaming_pragma (tree decl
, tree asmname
);
1092 /* Should not be called for treelang. */
1095 maybe_apply_renaming_pragma (tree decl ATTRIBUTE_UNUSED
, tree asmname ATTRIBUTE_UNUSED
)
1100 /* Should not be called for treelang. */
1103 begin_stmt_tree (tree
*t ATTRIBUTE_UNUSED
)
1108 /* Should not be called for treelang. */
1111 finish_stmt_tree (tree
*t ATTRIBUTE_UNUSED
)
1116 /* Should not be called for treelang. */
1119 defer_fn (tree fn ATTRIBUTE_UNUSED
)
1124 /* Should not be called for treelang. */
1127 *cpp_get_options (cpp_reader
* cr ATTRIBUTE_UNUSED
)
1132 /* Should not be called for treelang. */
1135 cpp_define (cpp_reader
* cr ATTRIBUTE_UNUSED
, const char * c ATTRIBUTE_UNUSED
)
1140 /* Should not be called for treelang. */
1143 cpp_get_callbacks (cpp_reader
* cr ATTRIBUTE_UNUSED
)
1148 /* Create the predefined scalar types of C,
1149 and some nodes representing standard constants (0, 1, (void *) 0).
1150 Initialize the global binding level.
1151 Make definitions for built-in primitive functions. */
1153 /* `unsigned long' is the standard type for sizeof.
1154 Note that stddef.h uses `unsigned long',
1155 and this must agree, even if long and int are the same size. */
1157 /* The reserved keyword table. */
1161 ENUM_BITFIELD(rid
) rid
: 16;
1162 unsigned int disable
: 16;
1165 static const struct resword reswords
[] =
1167 { "_Bool", RID_BOOL
, 0 },
1168 { "_Complex", RID_COMPLEX
, 0 },
1169 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
1170 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
1171 { "__alignof", RID_ALIGNOF
, 0 },
1172 { "__alignof__", RID_ALIGNOF
, 0 },
1173 { "__asm", RID_ASM
, 0 },
1174 { "__asm__", RID_ASM
, 0 },
1175 { "__attribute", RID_ATTRIBUTE
, 0 },
1176 { "__attribute__", RID_ATTRIBUTE
, 0 },
1177 { "__bounded", RID_BOUNDED
, 0 },
1178 { "__bounded__", RID_BOUNDED
, 0 },
1179 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, 0 },
1180 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, 0 },
1181 { "__builtin_va_arg", RID_VA_ARG
, 0 },
1182 { "__complex", RID_COMPLEX
, 0 },
1183 { "__complex__", RID_COMPLEX
, 0 },
1184 { "__const", RID_CONST
, 0 },
1185 { "__const__", RID_CONST
, 0 },
1186 { "__extension__", RID_EXTENSION
, 0 },
1187 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
1188 { "__imag", RID_IMAGPART
, 0 },
1189 { "__imag__", RID_IMAGPART
, 0 },
1190 { "__inline", RID_INLINE
, 0 },
1191 { "__inline__", RID_INLINE
, 0 },
1192 { "__label__", RID_LABEL
, 0 },
1193 { "__ptrbase", RID_PTRBASE
, 0 },
1194 { "__ptrbase__", RID_PTRBASE
, 0 },
1195 { "__ptrextent", RID_PTREXTENT
, 0 },
1196 { "__ptrextent__", RID_PTREXTENT
, 0 },
1197 { "__ptrvalue", RID_PTRVALUE
, 0 },
1198 { "__ptrvalue__", RID_PTRVALUE
, 0 },
1199 { "__real", RID_REALPART
, 0 },
1200 { "__real__", RID_REALPART
, 0 },
1201 { "__restrict", RID_RESTRICT
, 0 },
1202 { "__restrict__", RID_RESTRICT
, 0 },
1203 { "__signed", RID_SIGNED
, 0 },
1204 { "__signed__", RID_SIGNED
, 0 },
1205 { "__typeof", RID_TYPEOF
, 0 },
1206 { "__typeof__", RID_TYPEOF
, 0 },
1207 { "__unbounded", RID_UNBOUNDED
, 0 },
1208 { "__unbounded__", RID_UNBOUNDED
, 0 },
1209 { "__volatile", RID_VOLATILE
, 0 },
1210 { "__volatile__", RID_VOLATILE
, 0 },
1211 { "asm", RID_ASM
, 0 },
1212 { "auto", RID_AUTO
, 0 },
1213 { "break", RID_BREAK
, 0 },
1214 { "case", RID_CASE
, 0 },
1215 { "char", RID_CHAR
, 0 },
1216 { "const", RID_CONST
, 0 },
1217 { "continue", RID_CONTINUE
, 0 },
1218 { "default", RID_DEFAULT
, 0 },
1219 { "do", RID_DO
, 0 },
1220 { "double", RID_DOUBLE
, 0 },
1221 { "else", RID_ELSE
, 0 },
1222 { "enum", RID_ENUM
, 0 },
1223 { "extern", RID_EXTERN
, 0 },
1224 { "float", RID_FLOAT
, 0 },
1225 { "for", RID_FOR
, 0 },
1226 { "goto", RID_GOTO
, 0 },
1227 { "if", RID_IF
, 0 },
1228 { "inline", RID_INLINE
, 0 },
1229 { "int", RID_INT
, 0 },
1230 { "long", RID_LONG
, 0 },
1231 { "register", RID_REGISTER
, 0 },
1232 { "restrict", RID_RESTRICT
, 0 },
1233 { "return", RID_RETURN
, 0 },
1234 { "short", RID_SHORT
, 0 },
1235 { "signed", RID_SIGNED
, 0 },
1236 { "sizeof", RID_SIZEOF
, 0 },
1237 { "static", RID_STATIC
, 0 },
1238 { "struct", RID_STRUCT
, 0 },
1239 { "switch", RID_SWITCH
, 0 },
1240 { "typedef", RID_TYPEDEF
, 0 },
1241 { "typeof", RID_TYPEOF
, 0 },
1242 { "union", RID_UNION
, 0 },
1243 { "unsigned", RID_UNSIGNED
, 0 },
1244 { "void", RID_VOID
, 0 },
1245 { "volatile", RID_VOLATILE
, 0 },
1246 { "while", RID_WHILE
, 0 },
1248 #define N_reswords (sizeof reswords / sizeof (struct resword))
1250 /* Init enough to allow the C decl code to work, then clean up
1254 treelang_init_decl_processing ()
1259 /* It is not necessary to register ridpointers as a GC root, because
1260 all the trees it points to are permanently interned in the
1261 get_identifier hash anyway. */
1262 ridpointers
= (tree
*) xcalloc ((int) RID_MAX
, sizeof (tree
));
1264 for (i
= 0; i
< N_reswords
; i
++)
1266 id
= get_identifier (reswords
[i
].word
);
1267 C_RID_CODE (id
) = reswords
[i
].rid
;
1268 C_IS_RESERVED_WORD (id
) = 1;
1269 ridpointers
[(int) reswords
[i
].rid
] = id
;
1272 c_init_decl_processing ();
1274 /* ix86_return_pops_args takes the type of these so need to patch
1275 their own type as themselves. */
1277 for (i
= 0; i
< itk_none
; i
++)
1279 if (integer_types
[i
])
1280 TREE_TYPE (integer_types
[i
]) = integer_types
[i
];
1283 /* Probably these ones too. */
1284 TREE_TYPE (float_type_node
) = float_type_node
;
1285 TREE_TYPE (double_type_node
) = double_type_node
;
1286 TREE_TYPE (long_double_type_node
) = long_double_type_node
;
1290 /* Save typing debug_tree all the time. Dump a tree T pretty and