gcc/treelang/treetree.c

   1 /*
   2
   3     TREELANG Compiler back end interface (treetree.c)
   4     Called by the parser.
   5
   6     If you want a working example of how to write a front end to GCC,
   7     you are in the right place.
   8
   9     Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
  10     1999, 2000, 2001, 2002, 2003, Free Software Foundation, Inc.
  11
  12     This code is based on toy.c written by Richard Kenner.
  13
  14     It was later modified by Jonathan Bartlett whose changes have all
  15     been removed (by Tim Josling).
  16
  17     Various bits and pieces were cloned from the GCC main tree, as
  18     GCC evolved, for COBOLForGCC, by Tim Josling.
  19
  20     It was adapted to TREELANG by Tim Josling 2001.
  21
  22     ---------------------------------------------------------------------------
  23
  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
  27     later version.
  28
  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.
  33
  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.
  38
  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!
  42
  43     ---------------------------------------------------------------------------
  44
  45  */
  46
  47 /*
  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
  52   at all times.  */
  53
  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. */
  56
  57 /* GCC headers.  */
  58
  59 #include "config.h"
  60 #include "system.h"
  61 #include "coretypes.h"
  62 #include "tm.h"
  63 #include "tree.h"
  64 #include "flags.h"
  65 #include "output.h"
  66 #include "c-tree.h"
  67 #include "rtl.h"
  68 #include "ggc.h"
  69 #include "toplev.h"
  70 #include "varray.h"
  71 #include "langhooks-def.h"
  72 #include "langhooks.h"
  73
  74 #include "treelang.h"
  75 #include "treetree.h"
  76 #include "opts.h"
  77
  78 extern int option_main;
  79 extern char **file_names;
  80
  81 /* The front end language hooks (addresses of code for this front
  82    end).  Mostly just use the C routines.  */
  83
  84 #undef LANG_HOOKS_TRUTHVALUE_CONVERSION
  85 #define LANG_HOOKS_TRUTHVALUE_CONVERSION c_common_truthvalue_conversion
  86 #undef LANG_HOOKS_MARK_ADDRESSABLE
  87 #define LANG_HOOKS_MARK_ADDRESSABLE c_mark_addressable
  88 #undef LANG_HOOKS_SIGNED_TYPE
  89 #define LANG_HOOKS_SIGNED_TYPE c_common_signed_type
  90 #undef LANG_HOOKS_UNSIGNED_TYPE
  91 #define LANG_HOOKS_UNSIGNED_TYPE c_common_unsigned_type
  92 #undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE
  93 #define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE c_common_signed_or_unsigned_type
  94 #undef LANG_HOOKS_TYPE_FOR_MODE
  95 #define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode
  96 #undef LANG_HOOKS_TYPE_FOR_SIZE
  97 #define LANG_HOOKS_TYPE_FOR_SIZE c_common_type_for_size
  98 #undef LANG_HOOKS_PARSE_FILE
  99 #define LANG_HOOKS_PARSE_FILE treelang_parse_file
 100 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
 101 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE c_common_attribute_table
 102 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
 103 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE c_common_format_attribute_table
 104 #undef LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES
 105 #define LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES c_insert_default_attributes
 106
 107 /* Hook routines and data unique to treelang.  */
 108
 109 #undef LANG_HOOKS_INIT
 110 #define LANG_HOOKS_INIT treelang_init
 111 #undef LANG_HOOKS_NAME
 112 #define LANG_HOOKS_NAME "GNU treelang"
 113 #undef LANG_HOOKS_FINISH
 114 #define LANG_HOOKS_FINISH               treelang_finish
 115 #undef LANG_HOOKS_INIT_OPTIONS
 116 #define LANG_HOOKS_INIT_OPTIONS  treelang_init_options
 117 #undef LANG_HOOKS_HANDLE_OPTION
 118 #define LANG_HOOKS_HANDLE_OPTION treelang_handle_option
 119 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 120
 121 /* Tree code type/name/code tables.  */
 122
 123 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
 124
 125 const char tree_code_type[] = {
 126 #include "tree.def"
 127   'x'
 128 };
 129 #undef DEFTREECODE
 130
 131 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
 132
 133 const unsigned char tree_code_length[] = {
 134 #include "tree.def"
 135   0
 136 };
 137 #undef DEFTREECODE
 138
 139 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
 140
 141 const char *const tree_code_name[] = {
 142 #include "tree.def"
 143   "@@dummy"
 144 };
 145 #undef DEFTREECODE
 146
 147 /* Number of bits in int and char - accessed by front end.  */
 148
 149 unsigned int tree_code_int_size = SIZEOF_INT * HOST_BITS_PER_CHAR;
 150
 151 unsigned int tree_code_char_size = HOST_BITS_PER_CHAR;
 152
 153 /* Return the tree stuff for this type TYPE_NUM.  */
 154
 155 tree
 156 tree_code_get_type (int type_num)
 157 {
 158   switch (type_num)
 159     {
 160     case SIGNED_CHAR:
 161       return signed_char_type_node;
 162
 163     case UNSIGNED_CHAR:
 164       return unsigned_char_type_node;
 165
 166     case SIGNED_INT:
 167       return integer_type_node;
 168
 169     case UNSIGNED_INT:
 170       return unsigned_type_node;
 171
 172     case VOID_TYPE:
 173       return void_type_node;
 174
 175     default:
 176       abort ();
 177     }
 178 }
 179
 180 /* Output the code for the start of an if statement.  The test
 181    expression is EXP (true if not zero), and the stmt occurred at line
 182    LINENO in file FILENAME.  */
 183
 184 void
 185 tree_code_if_start (tree exp, location_t loc)
 186 {
 187   tree cond_exp;
 188   cond_exp = build (NE_EXPR,
 189                  TREE_TYPE (exp),
 190                  exp,
 191                  build1 (CONVERT_EXPR, TREE_TYPE (exp), integer_zero_node));
 192   emit_line_note (loc.file, loc.line); /* Output the line number information.  */
 193   expand_start_cond (cond_exp, /* Exit-able if nonzero.  */ 0);
 194 }
 195
 196 /* Output the code for the else of an if statement.  The else occurred
 197    at line LINENO in file FILENAME.  */
 198
 199 void
 200 tree_code_if_else (location_t loc)
 201 {
 202   emit_line_note (loc.file, loc.line); /* Output the line number information.  */
 203   expand_start_else ();
 204 }
 205
 206 /* Output the code for the end_if an if statement.  The end_if (final brace) occurred
 207    at line LINENO in file FILENAME.  */
 208
 209 void
 210 tree_code_if_end (location_t loc)
 211 {
 212   emit_line_note (loc.file, loc.line); /* Output the line number information.  */
 213   expand_end_cond ();
 214 }
 215
 216 /* Create a function.  The prototype name is NAME, storage class is
 217    STORAGE_CLASS, type of return variable is RET_TYPE, parameter lists
 218    is PARMS, returns decl for this function.  */
 219
 220 tree
 221 tree_code_create_function_prototype (unsigned char* chars,
 222                                      unsigned int storage_class,
 223                                      unsigned int ret_type,
 224                                      struct prod_token_parm_item* parms,
 225                                      location_t loc)
 226 {
 227
 228   tree id;
 229   struct prod_token_parm_item* parm;
 230   tree type_list = NULL_TREE;
 231   tree type_node;
 232   tree fn_type;
 233   tree fn_decl;
 234
 235   /* Build the type.  */
 236   id = get_identifier ((const char*)chars);
 237   for (parm = parms; parm; parm = parm->tp.par.next)
 238     {
 239       if (parm->category != parameter_category)
 240         abort ();
 241       type_node = get_type_for_numeric_type (parm->type);
 242       type_list = tree_cons (NULL_TREE, type_node, type_list);
 243     }
 244   /* Last parm if void indicates fixed length list (as opposed to
 245      printf style va_* list).  */
 246   type_list = tree_cons (NULL_TREE, void_type_node, type_list);
 247   /* The back end needs them in reverse order.  */
 248   type_list = nreverse (type_list);
 249
 250   type_node = get_type_for_numeric_type (ret_type);
 251   fn_type = build_function_type (type_node, type_list);
 252
 253   id = get_identifier ((const char*)chars);
 254   fn_decl = build_decl (FUNCTION_DECL, id, fn_type);
 255
 256   DECL_CONTEXT (fn_decl) = NULL_TREE; /* Nested functions not supported here.  */
 257   DECL_SOURCE_LOCATION (fn_decl) = loc;
 258
 259   TREE_USED (fn_decl) = 1;
 260
 261   /* Real name (optional).  */
 262   SET_DECL_ASSEMBLER_NAME (fn_decl, DECL_NAME (fn_decl));
 263
 264   TREE_PUBLIC (fn_decl) = 0;
 265   DECL_EXTERNAL (fn_decl) = 0;
 266   TREE_STATIC (fn_decl) = 0;
 267   switch (storage_class)
 268     {
 269     case STATIC_STORAGE:
 270       TREE_PUBLIC (fn_decl) = 0;
 271       break;
 272
 273     case EXTERNAL_DEFINITION_STORAGE:
 274       TREE_PUBLIC (fn_decl) = 1;
 275       TREE_STATIC (fn_decl) = 0;
 276       DECL_EXTERNAL (fn_decl) = 0;
 277       break;
 278
 279     case EXTERNAL_REFERENCE_STORAGE:
 280       TREE_PUBLIC (fn_decl) = 0;
 281       DECL_EXTERNAL (fn_decl) = 1;
 282       break;
 283
 284
 285     case AUTOMATIC_STORAGE:
 286     default:
 287       abort ();
 288     }
 289
 290   /* Process declaration of function defined elsewhere.  */
 291   rest_of_decl_compilation (fn_decl, NULL, 1, 0);
 292
 293   return fn_decl;
 294 }
 295
 296
 297 /* Output code for start of function; the decl of the function is in
 298     PREV_SAVED (as created by tree_code_create_function_prototype),
 299     the function is at line number LINENO in file FILENAME.  The
 300     parameter details are in the lists PARMS. Returns nothing.  */
 301 void
 302 tree_code_create_function_initial (tree prev_saved,
 303                                    location_t loc,
 304                                    struct prod_token_parm_item* parms)
 305 {
 306   tree fn_decl;
 307   tree param_decl;
 308   tree next_param;
 309   tree first_param;
 310   tree parm_decl;
 311   tree parm_list;
 312   tree resultdecl;
 313   struct prod_token_parm_item* this_parm;
 314   struct prod_token_parm_item* parm;
 315
 316   fn_decl = prev_saved;
 317   if (!fn_decl)
 318     abort ();
 319
 320   /* Output message if not -quiet.  */
 321   announce_function (fn_decl);
 322
 323   /* This has something to do with forcing output also.  */
 324   pushdecl (fn_decl);
 325
 326   /* Set current function for error msgs etc.  */
 327   current_function_decl = fn_decl;
 328   DECL_INITIAL (fn_decl) = error_mark_node;
 329
 330   DECL_SOURCE_LOCATION (fn_decl) = loc;
 331
 332   /* Prepare creation of rtl for a new function.  */
 333
 334   resultdecl = DECL_RESULT (fn_decl)
 335     = build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (TREE_TYPE (fn_decl)));
 336   DECL_CONTEXT (DECL_RESULT (fn_decl)) = fn_decl;
 337   DECL_SOURCE_LOCATION (resultdecl) = loc;
 338
 339   /* Work out the size. ??? is this needed.  */
 340   layout_decl (DECL_RESULT (fn_decl), 0);
 341
 342   /* Make the argument variable decls.  */
 343   parm_list = NULL_TREE;
 344   for (parm = parms; parm; parm = parm->tp.par.next)
 345     {
 346       parm_decl = build_decl (PARM_DECL, get_identifier
 347                               ((const char*) (parm->tp.par.variable_name)),
 348                               get_type_for_numeric_type (parm->type));
 349
 350       /* Some languages have different nominal and real types.  */
 351       DECL_ARG_TYPE (parm_decl) = TREE_TYPE (parm_decl);
 352       if (!DECL_ARG_TYPE (parm_decl))
 353         abort ();
 354       if (!fn_decl)
 355         abort ();
 356       DECL_CONTEXT (parm_decl) = fn_decl;
 357       DECL_SOURCE_LOCATION (parm_decl) = loc;
 358       parm_list = chainon (parm_decl, parm_list);
 359     }
 360
 361   /* Back into reverse order as the back end likes them.  */
 362   parm_list = nreverse (parm_list);
 363
 364   DECL_ARGUMENTS (fn_decl) = parm_list;
 365
 366   /* Save the decls for use when the args are referred to.  */
 367   for (param_decl = DECL_ARGUMENTS (fn_decl),
 368          this_parm = parms;
 369        param_decl;
 370        param_decl = TREE_CHAIN (param_decl),
 371          this_parm = this_parm->tp.par.next)
 372     {
 373       if (!this_parm)
 374         abort (); /* Too few.  */
 375       *this_parm->tp.par.where_to_put_var_tree = param_decl;
 376     }
 377   if (this_parm)
 378     abort (); /* Too many.  */
 379
 380   /* Output the decl rtl (not the rtl for the function code).  ???.
 381      If the function is not defined in this file, when should you
 382      execute this?  */
 383   make_decl_rtl (fn_decl, NULL);
 384
 385   init_function_start (fn_decl);
 386
 387   /* Create rtl for startup code of function, such as saving registers.  */
 388
 389   expand_function_start (fn_decl, 0);
 390
 391   /* Function.c requires a push at the start of the function. that
 392      looks like a bug to me but let's make it happy.  */
 393
 394   (*lang_hooks.decls.pushlevel) (0);
 395
 396   /* Create rtl for the start of a new scope.  */
 397
 398   expand_start_bindings (2);
 399
 400   /* Put the parameters into the symbol table.  */
 401
 402   for (first_param = param_decl = nreverse (DECL_ARGUMENTS (fn_decl));
 403        param_decl;
 404        param_decl = next_param)
 405     {
 406       next_param = TREE_CHAIN (param_decl);
 407       TREE_CHAIN (param_decl) = NULL;
 408       /* layout_decl (param_decl, 0);  Already done in build_decl tej 13/4/2002.  */
 409       pushdecl (param_decl);
 410       if (DECL_CONTEXT (param_decl) != current_function_decl)
 411         abort ();
 412     }
 413
 414   /* Store back the PARM_DECL nodes.  They appear in the right order.  */
 415   DECL_ARGUMENTS (fn_decl) = getdecls ();
 416
 417   /* Force it to be output, else may be solely inlined.  */
 418   TREE_ADDRESSABLE (fn_decl) = 1;
 419
 420   /* Stop -O3 from deleting it.  */
 421   TREE_USED (fn_decl) = 1;
 422
 423   /* Add a new level to the debugger symbol table.  */
 424
 425   (*lang_hooks.decls.pushlevel) (0);
 426
 427   /* Create rtl for the start of a new scope.  */
 428
 429   expand_start_bindings (0);
 430
 431   emit_line_note (loc.file, loc.line); /* Output the line number information.  */
 432 }
 433
 434 /* Wrapup a function contained in file FILENAME, ending at line LINENO.  */
 435 void
 436 tree_code_create_function_wrapup (location_t loc)
 437 {
 438   tree block;
 439   tree fn_decl;
 440
 441   fn_decl = current_function_decl;
 442
 443   emit_line_note (loc.file, loc.line); /* Output the line number information.  */
 444
 445   /* Get completely built level from debugger symbol table.  */
 446
 447   block = (*lang_hooks.decls.poplevel) (1, 0, 0);
 448
 449   /* Emit rtl for end of scope.  */
 450
 451   expand_end_bindings (block, 0, 1);
 452
 453   /* Emit rtl for end of function.  */
 454
 455   expand_function_end ();
 456
 457   /* Pop the level.  */
 458
 459   block = (*lang_hooks.decls.poplevel) (1, 0, 1);
 460
 461   /* And attach it to the function.  */
 462
 463   DECL_INITIAL (fn_decl) = block;
 464
 465   /* Emit rtl for end of scope.  */
 466
 467   expand_end_bindings (block, 0, 1);
 468
 469   /* Call optimization and convert optimized rtl to assembly code.  */
 470
 471   rest_of_compilation (fn_decl);
 472
 473   /* We are not inside of any scope now.  */
 474
 475   current_function_decl = NULL_TREE;
 476 }
 477
 478 /*
 479    Create a variable.
 480
 481    The storage class is STORAGE_CLASS (eg LOCAL).
 482    The name is CHARS/LENGTH.
 483    The type is EXPRESSION_TYPE (eg UNSIGNED_TYPE).
 484    The init tree is INIT.
 485 */
 486
 487 tree
 488 tree_code_create_variable (unsigned int storage_class,
 489                            unsigned char* chars,
 490                            unsigned int length,
 491                            unsigned int expression_type,
 492                            tree init,
 493                            location_t loc)
 494 {
 495   tree var_type;
 496   tree var_id;
 497   tree var_decl;
 498
 499   /* 1. Build the type.  */
 500   var_type = get_type_for_numeric_type (expression_type);
 501
 502   /* 2. Build the name.  */
 503   if (chars[length] != 0)
 504     abort (); /* Should be null terminated.  */
 505
 506   var_id = get_identifier ((const char*)chars);
 507
 508   /* 3. Build the decl and set up init.  */
 509   var_decl = build_decl (VAR_DECL, var_id, var_type);
 510
 511   /* 3a. Initialization.  */
 512   if (init)
 513     DECL_INITIAL (var_decl) = build1 (CONVERT_EXPR, var_type, init);
 514   else
 515     DECL_INITIAL (var_decl) = NULL_TREE;
 516
 517   /* 4. Compute size etc.  */
 518   layout_decl (var_decl, 0);
 519
 520   if (TYPE_SIZE (var_type) == 0)
 521     abort (); /* Did not calculate size.  */
 522
 523   DECL_CONTEXT (var_decl) = current_function_decl;
 524
 525   DECL_SOURCE_LOCATION (var_decl) = loc;
 526
 527   /* Set the storage mode and whether only visible in the same file.  */
 528   switch (storage_class)
 529     {
 530     case STATIC_STORAGE:
 531       TREE_STATIC (var_decl) = 1;
 532       TREE_PUBLIC (var_decl) = 0;
 533       break;
 534
 535     case AUTOMATIC_STORAGE:
 536       TREE_STATIC (var_decl) = 0;
 537       TREE_PUBLIC (var_decl) = 0;
 538       break;
 539
 540     case EXTERNAL_DEFINITION_STORAGE:
 541       TREE_STATIC (var_decl) = 0;
 542       TREE_PUBLIC (var_decl) = 1;
 543       break;
 544
 545     case EXTERNAL_REFERENCE_STORAGE:
 546       DECL_EXTERNAL (var_decl) = 1;
 547       TREE_PUBLIC (var_decl) = 0;
 548       break;
 549
 550     default:
 551       abort ();
 552     }
 553
 554   /* This should really only be set if the variable is used.  */
 555   TREE_USED (var_decl) = 1;
 556
 557   /* Expand declaration and initial value if any.  */
 558
 559   if (TREE_STATIC (var_decl))
 560     rest_of_decl_compilation (var_decl, 0, 0, 0);
 561   else
 562     {
 563       expand_decl (var_decl);
 564       if (DECL_INITIAL (var_decl))
 565         expand_decl_init (var_decl);
 566     }
 567
 568   return pushdecl (copy_node (var_decl));
 569
 570 }
 571
 572
 573 /* Generate code for return statement.  Type is in TYPE, expression
 574    is in EXP if present.  */
 575
 576 void
 577 tree_code_generate_return (tree type, tree exp)
 578 {
 579   tree setret;
 580   tree param;
 581
 582   for (param = DECL_ARGUMENTS (current_function_decl);
 583        param;
 584        param = TREE_CHAIN (param))
 585     {
 586       if (DECL_CONTEXT (param) != current_function_decl)
 587         abort ();
 588     }
 589
 590   if (exp)
 591     {
 592       setret = build (MODIFY_EXPR, type, DECL_RESULT (current_function_decl),
 593                      build1 (CONVERT_EXPR, type, exp));
 594       TREE_SIDE_EFFECTS (setret) = 1;
 595       TREE_USED (setret) = 1;
 596       expand_expr_stmt (setret);
 597     }
 598   expand_return (DECL_RESULT (current_function_decl));
 599 }
 600
 601 /* Output the code for this expression statement CODE.  */
 602
 603
 604 void
 605 tree_code_output_expression_statement (tree code,
 606                                        location_t loc)
 607 {
 608   /* Output the line number information.  */
 609   emit_line_note (loc.file, loc.line);
 610   TREE_USED (code) = 1;
 611   TREE_SIDE_EFFECTS (code) = 1;
 612   expand_expr_stmt (code);
 613 }
 614
 615 /* Return a tree for a constant integer value in the token TOK.  No
 616    size checking is done.  */
 617
 618 tree
 619 tree_code_get_integer_value (unsigned char* chars, unsigned int length)
 620 {
 621   long long int val = 0;
 622   unsigned int ix;
 623   unsigned int start = 0;
 624   int negative = 1;
 625   switch (chars[0])
 626     {
 627     case (unsigned char)'-':
 628       negative = -1;
 629       start = 1;
 630       break;
 631
 632     case (unsigned char)'+':
 633       start = 1;
 634       break;
 635
 636     default:
 637       break;
 638     }
 639   for (ix = start; ix < length; ix++)
 640     val = val * 10 + chars[ix] - (unsigned char)'0';
 641   val = val*negative;
 642   return build_int_2 (val & 0xffffffff, (val >> 32) & 0xffffffff);
 643 }
 644
 645 /* Return the tree for an expresssion, type EXP_TYPE (see treetree.h)
 646    with tree type TYPE and with operands1 OP1, OP2 (maybe), OP3 (maybe).  */
 647 tree
 648 tree_code_get_expression (unsigned int exp_type,
 649                           tree type, tree op1, tree op2, tree op3 ATTRIBUTE_UNUSED)
 650 {
 651   tree ret1;
 652   int operator;
 653
 654   switch (exp_type)
 655     {
 656     case EXP_ASSIGN:
 657       if (!op1 || !op2)
 658         abort ();
 659       operator = MODIFY_EXPR;
 660       ret1 = build (operator, type,
 661                  op1,
 662                  build1 (CONVERT_EXPR, type, op2));
 663
 664       break;
 665
 666     case EXP_PLUS:
 667       operator = PLUS_EXPR;
 668       goto binary_expression;
 669
 670     case EXP_MINUS:
 671       operator = MINUS_EXPR;
 672       goto binary_expression;
 673
 674     case EXP_EQUALS:
 675       operator = EQ_EXPR;
 676       goto binary_expression;
 677
 678       /* Expand a binary expression.  Ensure the operands are the right type.  */
 679     binary_expression:
 680       if (!op1 || !op2)
 681         abort ();
 682       ret1  =  build (operator, type,
 683                    build1 (CONVERT_EXPR, type, op1),
 684                    build1 (CONVERT_EXPR, type, op2));
 685       break;
 686
 687       /* Reference to a variable.  This is dead easy, just return the
 688          decl for the variable.  If the TYPE is different than the
 689          variable type, convert it.  */
 690     case EXP_REFERENCE:
 691       if (!op1)
 692         abort ();
 693       if (type == TREE_TYPE (op1))
 694         ret1 = op1;
 695       else
 696         ret1 = build1 (CONVERT_EXPR, type, op1);
 697       break;
 698
 699     case EXP_FUNCTION_INVOCATION:
 700       if (!op1 || !op2)
 701         abort ();
 702       {
 703         tree fun_ptr;
 704         fun_ptr = build1 (ADDR_EXPR, build_pointer_type (type), op1);
 705         ret1 = build (CALL_EXPR, type, fun_ptr, nreverse (op2));
 706       }
 707       break;
 708
 709     default:
 710       abort ();
 711     }
 712
 713   return ret1;
 714 }
 715
 716 /* Init parameter list and return empty list.  */
 717
 718 tree
 719 tree_code_init_parameters (void)
 720 {
 721   return NULL_TREE;
 722 }
 723
 724 /* Add a parameter EXP whose expression type is EXP_PROTO to list
 725    LIST, returning the new list.  */
 726
 727 tree
 728 tree_code_add_parameter (tree list, tree proto_exp, tree exp)
 729 {
 730   tree new_exp;
 731   new_exp = tree_cons (NULL_TREE,
 732                     build1 (CONVERT_EXPR, TREE_TYPE (proto_exp), exp),
 733                     NULL_TREE);
 734   if (!list)
 735     return new_exp;
 736   return chainon (new_exp, list);
 737 }
 738
 739 /* Get the tree type for this type whose number is NUMERIC_TYPE.  */
 740
 741 tree
 742 get_type_for_numeric_type (unsigned int numeric_type)
 743 {
 744
 745   int size1;
 746   int sign1;
 747   switch (numeric_type)
 748     {
 749     case VOID_TYPE:
 750       return void_type_node;
 751
 752     case SIGNED_INT:
 753       size1 = tree_code_int_size;
 754       sign1 = 1;
 755       break;
 756
 757     case UNSIGNED_INT:
 758       size1 = tree_code_int_size;
 759       sign1 = 0;
 760       break;
 761
 762     case SIGNED_CHAR:
 763       size1 = tree_code_char_size;
 764       sign1 = 1;
 765       break;
 766
 767     case UNSIGNED_CHAR:
 768       size1 = tree_code_char_size;
 769       sign1 = 0;
 770       break;
 771
 772     default:
 773       abort ();
 774     }
 775
 776   return tree_code_get_numeric_type (size1, sign1);
 777
 778 }
 779
 780 /* Return tree representing a numeric type of size SIZE1 bits and
 781    signed if SIGN1 !=  0.  */
 782 tree
 783 tree_code_get_numeric_type (unsigned int size1, unsigned int sign1)
 784 {
 785   tree ret1;
 786   if (!size1)
 787     abort ();
 788   if (size1 == tree_code_int_size)
 789     {
 790       if (sign1)
 791         ret1 = integer_type_node;
 792       else
 793         ret1 = unsigned_type_node;
 794     }
 795   else
 796     if (size1 == tree_code_char_size)
 797       {
 798         if (sign1)
 799           ret1 = signed_char_type_node;
 800         else
 801           ret1 = unsigned_char_type_node;
 802       }
 803     else
 804       abort ();
 805
 806   return ret1;
 807 }
 808
 809 /* Garbage Collection.  */
 810
 811 /* Callback to mark storage M as used always.  */
 812
 813 void
 814 tree_ggc_storage_always_used (void * m)
 815 {
 816   void **mm; /* Actually M is a pointer to a pointer to the memory.  */
 817   mm = (void**)m;
 818
 819   if (*mm)
 820     ggc_mark (*mm);
 821 }
 822
 823 /* Following  from c-lang.c.  */
 824
 825 /* Used by c-typeck.c (build_external_ref), but only for objc.  */
 826
 827 tree
 828 lookup_objc_ivar (tree id ATTRIBUTE_UNUSED)
 829 {
 830   return 0;
 831 }
 832
 833 /* Dummy routines called from c code. Save copying c-decl.c, c-common.c etc.  */
 834
 835 tree
 836 objc_is_id (tree arg ATTRIBUTE_UNUSED)
 837 {
 838   return 0;
 839 }
 840
 841 void
 842 check_function_format (int *status ATTRIBUTE_UNUSED,
 843                        tree attrs ATTRIBUTE_UNUSED,
 844                        tree params ATTRIBUTE_UNUSED)
 845 {
 846   return;
 847 }
 848
 849 /* Tell the c code we are not objective C.  */
 850
 851 int
 852 objc_comptypes (tree lhs ATTRIBUTE_UNUSED,
 853                 tree rhs ATTRIBUTE_UNUSED,
 854                 int reflexive ATTRIBUTE_UNUSED)
 855 {
 856   return 0;
 857 }
 858
 859 /* Should not be called for treelang.  Needed by RS6000 backend.  */
 860
 861 int c_lex (tree *value);
 862
 863 int
 864 c_lex (tree *value ATTRIBUTE_UNUSED)
 865 {
 866   abort ();
 867 }
 868
 869 /* Should not be called for treelang.   */
 870
 871 tree
 872 build_stmt (enum tree_code code  ATTRIBUTE_UNUSED, ...)
 873 {
 874   abort ();
 875 }
 876
 877 /* Should not be called for treelang.   */
 878
 879 tree
 880 add_stmt (tree t ATTRIBUTE_UNUSED)
 881 {
 882   abort ();
 883 }
 884
 885 /* Should not be called for treelang.   */
 886
 887 tree
 888 build_return_stmt (tree expr ATTRIBUTE_UNUSED)
 889 {
 890   abort ();
 891 }
 892
 893 /* C warning, ignore.  */
 894
 895 void
 896 pedwarn_c99 (const char *msgid ATTRIBUTE_UNUSED, ...)
 897 {
 898   return;
 899 }
 900
 901 /* Should not be called for treelang.   */
 902
 903 tree
 904 build_case_label (tree low_value ATTRIBUTE_UNUSED,
 905                   tree high_value ATTRIBUTE_UNUSED,
 906                   tree label_decl ATTRIBUTE_UNUSED)
 907 {
 908   abort ();
 909 }
 910
 911 /* Should not be called for treelang.   */
 912
 913 void
 914 emit_local_var (tree decl ATTRIBUTE_UNUSED)
 915 {
 916   abort ();
 917 }
 918
 919 /* Should not be called for treelang.   */
 920
 921 void
 922 expand_stmt (tree t ATTRIBUTE_UNUSED)
 923 {
 924   abort ();
 925 }
 926
 927 /* Should not be called for treelang.   */
 928
 929 cpp_reader *
 930 cpp_create_reader (enum c_lang lang ATTRIBUTE_UNUSED,
 931                    struct ht *table ATTRIBUTE_UNUSED)
 932 {
 933   abort ();
 934 }
 935
 936 /* Should not be called for treelang.   */
 937
 938 void
 939 init_c_lex (void)
 940 {
 941   abort ();
 942 }
 943
 944 /* Should not be called for treelang.   */
 945
 946 void init_pragma (void);
 947
 948 void
 949 init_pragma ()
 950 {
 951   abort ();
 952 }
 953
 954 /* Should not be called for treelang.   */
 955
 956 int
 957 cpp_finish (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f ATTRIBUTE_UNUSED)
 958 {
 959   abort ();
 960 }
 961
 962 /* Should not be called for treelang.   */
 963
 964 unsigned int
 965 cpp_errors (cpp_reader *pfile ATTRIBUTE_UNUSED)
 966 {
 967   abort ();
 968 }
 969
 970 /* Dummy called by C.   */
 971
 972 tree
 973 handle_format_attribute (tree *node ATTRIBUTE_UNUSED,
 974                          tree name ATTRIBUTE_UNUSED,
 975                          tree args ATTRIBUTE_UNUSED,
 976                          int flags ATTRIBUTE_UNUSED,
 977                          bool *no_add_attrs ATTRIBUTE_UNUSED)
 978 {
 979   return NULL_TREE;
 980 }
 981
 982 /* Should not be called for treelang.   */
 983
 984 tree
 985 handle_format_arg_attribute (tree *node ATTRIBUTE_UNUSED,
 986      tree name ATTRIBUTE_UNUSED,
 987      tree args ATTRIBUTE_UNUSED,
 988      int flags ATTRIBUTE_UNUSED,
 989      bool *no_add_attrs ATTRIBUTE_UNUSED)
 990 {
 991   abort ();
 992 }
 993
 994 /* Should not be called for treelang.   */
 995
 996 void
 997 cpp_assert (cpp_reader * cr ATTRIBUTE_UNUSED,
 998             const char *s ATTRIBUTE_UNUSED)
 999 {
1000   abort ();
1001 }
1002
1003 /* Should not be called for treelang.   */
1004
1005 void
1006 set_Wformat (int setting ATTRIBUTE_UNUSED)
1007 {
1008   abort ();
1009 }
1010
1011 /* Used for objective C.  */
1012
1013 void
1014 objc_check_decl (tree decl ATTRIBUTE_UNUSED);
1015
1016 void
1017 objc_check_decl (tree decl ATTRIBUTE_UNUSED)
1018 {
1019   abort ();
1020 }
1021
1022 /* Tell the c code we are not objective C.  */
1023
1024 tree
1025 objc_message_selector (void);
1026
1027 tree
1028 objc_message_selector ()
1029 {
1030   return 0;
1031 }
1032
1033 /* Should not be called for treelang.   */
1034
1035 void
1036 gen_aux_info_record (tree fndecl ATTRIBUTE_UNUSED,
1037                      int is_definition ATTRIBUTE_UNUSED,
1038                      int is_implicit ATTRIBUTE_UNUSED,
1039                      int is_prototyped ATTRIBUTE_UNUSED)
1040 {
1041   abort ();
1042 }
1043
1044 /* Should not be called for treelang, but it is.   */
1045
1046 void
1047 c_parse_init ()
1048 {
1049   return;
1050 }
1051
1052 /* Should not be called for treelang.   */
1053
1054 void maybe_apply_pragma_weak (tree decl);
1055
1056 void
1057 maybe_apply_pragma_weak (tree decl ATTRIBUTE_UNUSED)
1058 {
1059   abort ();
1060 }
1061
1062 /* Should not be called for treelang.   */
1063
1064 void
1065 add_decl_stmt (tree decl ATTRIBUTE_UNUSED)
1066 {
1067   abort ();
1068 }
1069
1070 /* Should not be called for treelang.   */
1071
1072 tree
1073 maybe_apply_renaming_pragma (tree decl, tree asmname);
1074
1075 /* Should not be called for treelang.   */
1076
1077 tree
1078 maybe_apply_renaming_pragma (tree decl ATTRIBUTE_UNUSED, tree asmname ATTRIBUTE_UNUSED)
1079 {
1080   abort ();
1081 }
1082
1083 /* Should not be called for treelang.   */
1084
1085 void
1086 begin_stmt_tree (tree *t ATTRIBUTE_UNUSED)
1087 {
1088   abort ();
1089 }
1090
1091 /* Should not be called for treelang.   */
1092
1093 void
1094 finish_stmt_tree (tree *t ATTRIBUTE_UNUSED)
1095 {
1096   abort ();
1097 }
1098
1099 /* Should not be called for treelang.   */
1100
1101 int
1102 defer_fn (tree fn ATTRIBUTE_UNUSED)
1103 {
1104   abort ();
1105 }
1106
1107 /* Should not be called for treelang.   */
1108
1109 cpp_options
1110 *cpp_get_options (cpp_reader * cr ATTRIBUTE_UNUSED)
1111 {
1112   abort ();
1113 }
1114
1115 /* Should not be called for treelang.   */
1116
1117 void
1118 cpp_define (cpp_reader * cr ATTRIBUTE_UNUSED, const char * c ATTRIBUTE_UNUSED)
1119 {
1120   abort ();
1121 }
1122
1123 /* Should not be called for treelang.   */
1124
1125 cpp_callbacks *
1126 cpp_get_callbacks (cpp_reader * cr ATTRIBUTE_UNUSED)
1127 {
1128   abort ();
1129 }
1130
1131 /* Create the predefined scalar types of C,
1132    and some nodes representing standard constants (0, 1, (void *) 0).
1133    Initialize the global binding level.
1134    Make definitions for built-in primitive functions.  */
1135
1136   /* `unsigned long' is the standard type for sizeof.
1137      Note that stddef.h uses `unsigned long',
1138      and this must agree, even if long and int are the same size.  */
1139
1140 /* The reserved keyword table.  */
1141 struct resword
1142 {
1143   const char *word;
1144   ENUM_BITFIELD(rid) rid : 16;
1145   unsigned int disable   : 16;
1146 };
1147
1148 static const struct resword reswords[] =
1149 {
1150   { "_Bool",            RID_BOOL,       0 },
1151   { "_Complex",         RID_COMPLEX,    0 },
1152   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
1153   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
1154   { "__alignof",        RID_ALIGNOF,    0 },
1155   { "__alignof__",      RID_ALIGNOF,    0 },
1156   { "__asm",            RID_ASM,        0 },
1157   { "__asm__",          RID_ASM,        0 },
1158   { "__attribute",      RID_ATTRIBUTE,  0 },
1159   { "__attribute__",    RID_ATTRIBUTE,  0 },
1160   { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
1161   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
1162   { "__builtin_va_arg", RID_VA_ARG,     0 },
1163   { "__complex",        RID_COMPLEX,    0 },
1164   { "__complex__",      RID_COMPLEX,    0 },
1165   { "__const",          RID_CONST,      0 },
1166   { "__const__",        RID_CONST,      0 },
1167   { "__extension__",    RID_EXTENSION,  0 },
1168   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
1169   { "__imag",           RID_IMAGPART,   0 },
1170   { "__imag__",         RID_IMAGPART,   0 },
1171   { "__inline",         RID_INLINE,     0 },
1172   { "__inline__",       RID_INLINE,     0 },
1173   { "__label__",        RID_LABEL,      0 },
1174   { "__ptrbase",        RID_PTRBASE,    0 },
1175   { "__ptrbase__",      RID_PTRBASE,    0 },
1176   { "__ptrextent",      RID_PTREXTENT,  0 },
1177   { "__ptrextent__",    RID_PTREXTENT,  0 },
1178   { "__ptrvalue",       RID_PTRVALUE,   0 },
1179   { "__ptrvalue__",     RID_PTRVALUE,   0 },
1180   { "__real",           RID_REALPART,   0 },
1181   { "__real__",         RID_REALPART,   0 },
1182   { "__restrict",       RID_RESTRICT,   0 },
1183   { "__restrict__",     RID_RESTRICT,   0 },
1184   { "__signed",         RID_SIGNED,     0 },
1185   { "__signed__",       RID_SIGNED,     0 },
1186   { "__typeof",         RID_TYPEOF,     0 },
1187   { "__typeof__",       RID_TYPEOF,     0 },
1188   { "__volatile",       RID_VOLATILE,   0 },
1189   { "__volatile__",     RID_VOLATILE,   0 },
1190   { "asm",              RID_ASM,        0 },
1191   { "auto",             RID_AUTO,       0 },
1192   { "break",            RID_BREAK,      0 },
1193   { "case",             RID_CASE,       0 },
1194   { "char",             RID_CHAR,       0 },
1195   { "const",            RID_CONST,      0 },
1196   { "continue",         RID_CONTINUE,   0 },
1197   { "default",          RID_DEFAULT,    0 },
1198   { "do",               RID_DO,         0 },
1199   { "double",           RID_DOUBLE,     0 },
1200   { "else",             RID_ELSE,       0 },
1201   { "enum",             RID_ENUM,       0 },
1202   { "extern",           RID_EXTERN,     0 },
1203   { "float",            RID_FLOAT,      0 },
1204   { "for",              RID_FOR,        0 },
1205   { "goto",             RID_GOTO,       0 },
1206   { "if",               RID_IF,         0 },
1207   { "inline",           RID_INLINE,     0 },
1208   { "int",              RID_INT,        0 },
1209   { "long",             RID_LONG,       0 },
1210   { "register",         RID_REGISTER,   0 },
1211   { "restrict",         RID_RESTRICT,   0 },
1212   { "return",           RID_RETURN,     0 },
1213   { "short",            RID_SHORT,      0 },
1214   { "signed",           RID_SIGNED,     0 },
1215   { "sizeof",           RID_SIZEOF,     0 },
1216   { "static",           RID_STATIC,     0 },
1217   { "struct",           RID_STRUCT,     0 },
1218   { "switch",           RID_SWITCH,     0 },
1219   { "typedef",          RID_TYPEDEF,    0 },
1220   { "typeof",           RID_TYPEOF,     0 },
1221   { "union",            RID_UNION,      0 },
1222   { "unsigned",         RID_UNSIGNED,   0 },
1223   { "void",             RID_VOID,       0 },
1224   { "volatile",         RID_VOLATILE,   0 },
1225   { "while",            RID_WHILE,      0 },
1226 };
1227 #define N_reswords (sizeof reswords / sizeof (struct resword))
1228
1229 /* Init enough to allow the C decl code to work, then clean up
1230    afterwards.  */
1231
1232 void
1233 treelang_init_decl_processing ()
1234 {
1235   unsigned int i;
1236   tree id;
1237
1238   ridpointers = (tree *) ggc_calloc ((int) RID_MAX, sizeof (tree));
1239
1240   for (i = 0; i < N_reswords; i++)
1241     {
1242       id = get_identifier (reswords[i].word);
1243       C_RID_CODE (id) = reswords[i].rid;
1244       C_IS_RESERVED_WORD (id) = 1;
1245       ridpointers [(int) reswords[i].rid] = id;
1246     }
1247
1248   c_init_decl_processing ();
1249
1250   /* ix86_return_pops_args takes the type of these so need to patch
1251      their own type as themselves.  */
1252
1253   for (i = 0; i < itk_none; i++)
1254     {
1255       if (integer_types[i])
1256         TREE_TYPE (integer_types [i]) = integer_types[i];
1257     }
1258
1259   /* Probably these ones too.  */
1260   TREE_TYPE (float_type_node) = float_type_node;
1261   TREE_TYPE (double_type_node) = double_type_node;
1262   TREE_TYPE (long_double_type_node) = long_double_type_node;
1263
1264 }
1265
1266 /* Save typing debug_tree all the time. Dump a tree T pretty and
1267    concise.  */
1268
1269 void dt (tree t);
1270
1271 void
1272 dt (tree t)
1273 {
1274   debug_tree (t);
1275 }
1276
1277 /* Get a stringpool entry for a string S of length L.  This is needed
1278    because the GTY routines don't mark strings, forcing you to put
1279    them into stringpool, which is never freed.  */
1280
1281 const char*
1282 get_string (const char *s, size_t l)
1283 {
1284   tree t;
1285   t = get_identifier_with_length (s, l);
1286   return IDENTIFIER_POINTER(t);
1287 }
1288