home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gnat-2.06-src.tgz / tar.out / fsf / gnat / ada / a-misc.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  16KB  |  567 lines
  1. /****************************************************************************/
  2. /*                                                                          */
  3. /*                         GNAT COMPILER COMPONENTS                         */
  4. /*                                                                          */
  5. /*                               A - M I S C                                */
  6. /*                                                                          */
  7. /*                          C Implementation File                           */
  8. /*                                                                          */
  9. /*                             $Revision: 1.75 $                            */
  10. /*                                                                          */
  11. /*           Copyright (c) 1992,1993,1994 NYU, All Rights Reserved          */
  12. /*                                                                          */
  13. /* GNAT is free software;  you can  redistribute it  and/or modify it under */
  14. /* terms of the  GNU General Public License as published  by the Free Soft- */
  15. /* ware  Foundation;  either version 2,  or (at your option) any later ver- */
  16. /* sion.  GNAT is distributed in the hope that it will be useful, but WITH- */
  17. /* OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY */
  18. /* or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License */
  19. /* for  more details.  You should have  received  a copy of the GNU General */
  20. /* Public License  distributed with GNAT;  see file COPYING.  If not, write */
  21. /* to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  22. /*                                                                          */
  23. /****************************************************************************/
  24.  
  25. #include "config.h"
  26. #include <stdio.h>
  27. #include <string.h>
  28. #include "tree.h"
  29. #include "rtl.h"
  30. #include "expr.h"
  31. #include "a-ada.h"
  32. #include "a-types.h"
  33. #include "a-atree.h"
  34. #include "a-nlists.h"
  35. #include "a-elists.h"
  36. #include "a-sinfo.h"
  37. #include "a-einfo.h"
  38. #include "a-namet.h"
  39. #include "a-string.h"
  40. #include "a-uintp.h"
  41. #include "a-gtran3.h"
  42. #include "a-trans.h"
  43. #include "a-trans3.h"
  44. #include "a-trans4.h"
  45. #include "a-misc.h"
  46. #include "a-rtree.h"
  47. #include "flags.h"
  48.  
  49. extern char *xmalloc ();
  50. extern char *main_input_filename;
  51.  
  52. /* Tables describing GCC tree codes used only by GNAT.  
  53.  
  54.    Table indexed by tree code giving a string containing a character
  55.    classifying the tree code.  Possibilities are
  56.    t, d, s, c, r, <, 1 and 2.  See cp-tree.def for details.  */
  57.  
  58. #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  59.  
  60. char *gnat_tree_code_type[] = {
  61.   "x",
  62. #include "a-tree.def"
  63. };
  64. #undef DEFTREECODE
  65.  
  66. /* Table indexed by tree code giving number of expression
  67.    operands beyond the fixed part of the node structure.
  68.    Not used for types or decls.  */
  69.  
  70. #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  71.  
  72. int gnat_tree_code_length[] = {
  73.   0,
  74. #include "a-tree.def"
  75. };
  76. #undef DEFTREECODE
  77.  
  78. /* Names of tree components.
  79.    Used for printing out the tree and error messages.  */
  80. #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
  81.  
  82. char *gnat_tree_code_name[] = {
  83.   "@@dummy",
  84. #include "a-tree.def"
  85. };
  86. #undef DEFTREECODE
  87.  
  88. /* gnat standard argc argv */
  89.  
  90. extern int gnat_argc;
  91. extern char **gnat_argv;
  92.  
  93. /* Root node of the tree read in.  Used only by yyparse.  */
  94. Node_Id gnat_root;
  95.  
  96. /* Global Variables Expected by gcc: */
  97.  
  98. char *language_string = "GNU Ada";
  99. int current_function_returns_null;
  100. int flag_traditional;        /* Used by dwarfout.c.  */
  101.  
  102. /* Routines Expected by gcc:  */
  103.  
  104. /* For most front-ends, this is the parser for the language.  For us, we
  105.    process the GNAT tree.  */
  106.  
  107. int
  108. yyparse ()
  109. {
  110.   /* Make up what Gigi uses as a jmpbuf.  */
  111.   size_t jmpbuf[100];
  112.  
  113.   /* Call the front-end elaboration procedures */
  114.   ada__bind ();
  115.  
  116.   /* Set up to catch unhandled exceptions.  */
  117.   if (setjmp (jmpbuf))
  118.     abort ();
  119.  
  120.   system__task_specific_data__set_jmpbuf_address (jmpbuf);
  121.  
  122.   immediate_size_expand = 1;
  123.  
  124.   /* Call the front end */
  125.   _ada_gnat1drv ();
  126.  
  127.   return 0;
  128. }
  129.  
  130. /* init gnat_argc and gnat_argv */
  131.  
  132. void 
  133. init_gnat_args ()
  134. {
  135.   extern int save_argc;
  136.  
  137.   /* initialize gnat_argv with save_argv size */
  138.   gnat_argv = (char **) malloc ((save_argc + 1) * sizeof (gnat_argv[0])); 
  139.  
  140.   /* leave the 2 first slots in gnat_argv for the program name and 
  141.      the main source name */
  142.  
  143.   gnat_argc = 2;
  144. }
  145.  
  146. /* Decode all the language specific options that cannot be decoded by GCC. The
  147.    option decoding phase of GCC calls this routine on the flags that it cannot
  148.    decode. This routine returns 1 if it is successful, otherwise it
  149.    returns 0. */
  150.  
  151. int
  152. lang_decode_option (p)
  153.      char *p;
  154. {
  155.   if (!gnat_argc) init_gnat_args ();
  156. #if defined (WINNT) || defined (__EMX__)
  157.   if (strnicmp (p, "-gnat", 5))
  158. #else
  159.   if (strncasecmp (p, "-gnat", 5))
  160. #endif
  161.     if (!strncmp (p, "-I", 2))
  162.        {
  163.        /* pass the -I switches as-is */
  164.        gnat_argv[gnat_argc] = p;
  165.        gnat_argc ++;
  166.        return 1;
  167.        }
  168.   else
  169.     {
  170.        /* we assume for the moment that all other front end options
  171.           are passed with "gnat" prefix */
  172.        return 0;
  173.        }
  174.  
  175.   else
  176.     {
  177.       /* recopy the switches without the 'gnat' prefix */
  178.  
  179.       gnat_argv[gnat_argc] =  (char *) malloc (strlen (p) - 3);
  180.       gnat_argv[gnat_argc][0] = '-';
  181.       strcpy (gnat_argv[gnat_argc] + 1, p + 5);
  182.       gnat_argc ++;
  183.       return 1;
  184.     }
  185. }
  186.  
  187. /* Perform all the initialization steps that are language-specific.  */
  188.  
  189. void
  190. lang_init ()
  191. {
  192.   extern char **save_argv;
  193.  
  194.   if (!gnat_argc) init_gnat_args ();
  195.  
  196.   gnat_argv [0] = save_argv[0];     /* name of the command */ 
  197.   gnat_argv [1] = input_filename;   /* name of the main source */
  198.   gnat_argv [gnat_argc] = 0;      /* end of argv */
  199.  
  200.   main_input_filename = input_filename;
  201.  
  202. }
  203.  
  204. /* Perform all the finalization steps that are language-specific.  */
  205.  
  206. void
  207. lang_finish ()
  208. {}
  209.  
  210. /* Return a short string identifying this language to the debugger.  */
  211.  
  212. char *
  213. lang_identify ()
  214. {
  215.   return "ada";
  216. }
  217.  
  218. /* If DECL has a cleanup, build and return that cleanup here.
  219.    This is a callback called by expand_expr.  */
  220.  
  221. tree
  222. maybe_build_cleanup (decl)
  223.      tree decl;
  224. {
  225.   /* There are no cleanups in C.  */
  226.   return NULL_TREE;
  227. }
  228.  
  229. /* Print any language-specific compilation statistics.  */
  230.  
  231. void
  232. print_lang_statistics ()
  233. {}
  234.  
  235. /* integrate_decl_tree calls this function, but since we don't use the
  236.    DECL_LANG_SPECIFIC field, this is a no-op.  */
  237.  
  238. void
  239. copy_lang_decl (node)
  240.      tree node;
  241. {
  242. }
  243.  
  244. /* Hooks for print-tree.c:  */
  245.  
  246. void
  247. print_lang_decl (file, node, indent)
  248.      FILE *file;
  249.      tree node;
  250.      int indent;
  251. {}
  252.  
  253. void
  254. print_lang_type (file, node, indent)
  255.      FILE *file;
  256.      tree node;
  257.      int indent;
  258. {
  259.   if (TREE_CODE (node) == FUNCTION_TYPE && TYPE_CI_CO_LIST (node))
  260.     print_node (file, "ci_co_list", TYPE_CI_CO_LIST (node), indent + 4);
  261.   else if (TREE_CODE (node) == INTEGER_TYPE && TYPE_MODULAR_P (node)
  262.        && TYPE_MODULUS (node))
  263.     print_node (file, "modulus", TYPE_MODULUS (node), indent + 4);
  264.   else if (TREE_CODE (node) == INTEGER_TYPE && TYPE_INDEX_TYPE (node))
  265.     print_node (file, "index type", TYPE_INDEX_TYPE (node), indent + 4);
  266.   else if (TREE_CODE (node) == RECORD_TYPE && TYPE_FAT_POINTER_P (node)
  267.        && TYPE_UNCONSTRAINED_ARRAY (node))
  268.     print_node (file, "unconstrained array",
  269.         TYPE_UNCONSTRAINED_ARRAY (node), indent + 4);
  270.   else if (TREE_CODE (node) == RECORD_TYPE && TYPE_PARENT_SUBTYPE (node))
  271.     print_node (file, "parent subtype",
  272.         TYPE_PARENT_SUBTYPE (node), indent + 4);
  273. }
  274.  
  275. void
  276. print_lang_identifier (file, node, indent)
  277.      FILE *file;
  278.      tree node;
  279.      int indent;
  280. {}
  281.  
  282. /* Expands GNAT-specific GCC tree nodes.  The only ones we support here are
  283.    TRANSFORM_EXPR, UNCHECKED_CONVERT_EXPR, and NULL_EXPR.  */
  284.  
  285. static rtx
  286. gnat_expand_expr (exp, target, tmode, modifier)
  287.      tree exp;
  288.      rtx target;
  289.      enum machine_mode tmode;
  290.      enum expand_modifier modifier;
  291. {
  292.   tree type = TREE_TYPE (exp);
  293.   tree new;
  294.   rtx result;
  295.  
  296.   /* Update EXP to be the new expression to expand.  */
  297.  
  298.   switch (TREE_CODE (exp))
  299.     {
  300.     case TRANSFORM_EXPR:
  301.       /* If we will ignore our result, just generate code.  Otherwise,
  302.      expand it.  */
  303.       if (target == const0_rtx || TREE_CODE (type) == VOID_TYPE)
  304.     {
  305.       gnat_to_code (TREE_COMPLEXITY (exp));
  306.       return target;
  307.     }
  308.  
  309.       new = gnat_to_gnu (TREE_COMPLEXITY (exp));
  310.  
  311.       /* If we were to take the address of this node, do it now.  */
  312.       if (TREE_TRANSFORM_ADDR (exp))
  313.     new = build_unary_op (ADDR_EXPR, NULL_TREE, new);
  314.  
  315.       /* If convert was called on this TRANSFORM_EXPR, it will now have a type,
  316.      so we must do the conversion now.  */
  317.       if (type != error_mark_node)
  318.     new = convert (type, new);
  319.       break;
  320.  
  321.     case UNCHECKED_CONVERT_EXPR:
  322.       /* If the input and output are both the same mode (usually BLKmode),
  323.      just return the expanded input since we want just the bits.  But
  324.      we can't do this if the output is more strictly aligned than
  325.      the input.  */
  326.       if (TYPE_MODE (type) == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))
  327.       && (TYPE_ALIGN (type)
  328.           <= TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))))
  329.     new = TREE_OPERAND (exp, 0);
  330.  
  331.       /* If either mode is BLKmode, memory will be involved, so do this
  332.      via pointer punning.  Likewise, this doesn't work if there
  333.      is an alignment issue.  But we must do it for types that are known
  334.      to be aligned properly.  */
  335.       else if ((TYPE_MODE (type) == BLKmode
  336.         || TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == BLKmode)
  337.            && ((TYPE_ALIGN (type)
  338.             <= TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0))))
  339.            || TYPE_ALIGN_OK_P (type)
  340.            || TYPE_ALIGN_OK_P (TREE_TYPE (TREE_OPERAND (exp, 0)))))
  341.     new
  342.       = build_unary_op (INDIRECT_REF, NULL_TREE,
  343.                 convert (build_pointer_type (type),
  344.                      build_unary_op (ADDR_EXPR, NULL_TREE,
  345.                              TREE_OPERAND (exp, 0))));
  346.  
  347.       /* Otherwise make a union of the two types, convert to the union, and
  348.      extract the other value.  */
  349.       else
  350.     {
  351.       /* Note that copy_node puts objects in current_obstack and we
  352.          take advantage of that here since we want these objects to
  353.          all be in the momentary obstack.  */
  354.       tree in_type = TREE_TYPE (TREE_OPERAND (exp, 0));
  355.       tree union_type = copy_node (unchecked_union_node);
  356.       tree in_field
  357.         = create_field_decl ("in", in_type, union_type, 0, -1, 0);
  358.       tree out_field
  359.         = create_field_decl ("out", type, union_type, 0, -1, 0);
  360.  
  361.       TYPE_MAIN_VARIANT (union_type) = union_type;
  362.       finish_record_type (union_type,
  363.                   chainon (chainon (NULL_TREE, in_field),
  364.                        out_field),
  365.                   0, 0);
  366.  
  367.       new = build (COMPONENT_REF, type,
  368.                build1 (CONVERT_EXPR, union_type,
  369.                    TREE_OPERAND (exp, 0)),
  370.                out_field);
  371.     }
  372.       break;
  373.  
  374.     case NULL_EXPR:
  375.       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
  376.  
  377.       /* Now make a temporary RTL the same as expr.c does.  For
  378.      now, don't support variable-sized objects.  */
  379.       if (TYPE_MODE (type) == BLKmode || TREE_ADDRESSABLE (type))
  380.     {
  381.       int size = int_size_in_bytes (type);
  382.       rtx tem;
  383.  
  384.       /* We really can't handle variable-sized objects here, but we're
  385.          not going to do anything with it, so just allocate 1 byte.  */
  386.       if (size == -1)
  387.         size = 1;
  388.  
  389.       tem = assign_stack_temp (TYPE_MODE (type), size, 0);
  390.       MEM_IN_STRUCT_P (tem) = AGGREGATE_TYPE_P (type);
  391.       return tem;
  392.     }
  393.       else
  394.     {
  395.       int unsignedp = TREE_UNSIGNED (type);
  396.  
  397.       return gen_reg_rtx (promote_mode (type, TYPE_MODE  (type),
  398.                         &unsignedp, 0));
  399.     }
  400.  
  401.     case USE_EXPR:
  402.       if (target != const0_rtx)
  403.     gigi_abort (203);
  404.  
  405.       /* First write a volatile ASM_INPUT to prevent anything from being
  406.      moved.  */
  407.       result = gen_rtx (ASM_INPUT, VOIDmode, "");
  408.       MEM_VOLATILE_P (result) = 1;
  409.       emit_insn (result);
  410.  
  411.       result = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode,
  412.                 modifier);
  413.       emit_insn (gen_rtx (USE, VOIDmode, result));
  414.       return target;
  415.  
  416.     case UNCONSTRAINED_ARRAY_REF:
  417.       /* If we are evaluating just for side-effects, just evaluate our
  418.      operand.  Otherwise, abort since this code should never appear
  419.      in a tree to be evaluated (objects aren't unconstrained).  */
  420.       if (target == const0_rtx || TREE_CODE (type) == VOID_TYPE)
  421.     return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
  422.                 VOIDmode, modifier);
  423.  
  424.       /* ... fall through ... */
  425.  
  426.     default:
  427.       gigi_abort (201);
  428.     }
  429.  
  430.   return expand_expr (new, target, tmode, modifier);
  431. }
  432.  
  433. /* Make a TRANSFORM_EXPR to later expand GNAT_NODE into an object
  434.    of GNU_TYPE.  */
  435.  
  436. tree
  437. make_transform_expr (gnat_node, gnu_type)
  438.      Node_Id gnat_node;
  439.      tree gnu_type;
  440. {
  441.   tree gnu_result = build (TRANSFORM_EXPR, gnu_type);
  442.  
  443.   TREE_SIDE_EFFECTS (gnu_result) = 1;
  444.   TREE_COMPLEXITY (gnu_result) = gnat_node;
  445.   return gnu_result;
  446. }
  447.  
  448. /* Record the current code position in GNAT_NODE.  */
  449.  
  450. void
  451. record_code_position (gnat_node)
  452.      Node_Id gnat_node;
  453. {
  454.   if (global_bindings_p ())
  455.     save_gnu_tree (gnat_node, get_elaboration_location (), 1);
  456.   else
  457.     /* Always emit another insn in case marking the last insn
  458.        addressable needs some fixups.  */
  459.     save_gnu_tree (gnat_node,
  460.            (tree) emit_note (NULL_PTR, NOTE_INSN_DELETED), 1);
  461. }
  462.  
  463. /* Insert the code for GNAT_NODE at the position saved for that node.  */
  464.  
  465. void
  466. insert_code_for (gnat_node)
  467.      Node_Id gnat_node;
  468. {
  469.   if (global_bindings_p ())
  470.     {
  471.       push_pending_elaborations ();
  472.       gnat_to_code (gnat_node);
  473.       insert_elaboration_list (get_gnu_tree (gnat_node));
  474.       pop_pending_elaborations ();
  475.     }
  476.   else
  477.     {
  478.       rtx insns;
  479.  
  480.       start_sequence ();
  481.       gnat_to_code (gnat_node);
  482.       insns = get_insns ();
  483.       end_sequence ();
  484.       emit_insns_after (insns, (rtx) get_gnu_tree (gnat_node));
  485.     }
  486. }
  487.  
  488. /* Performs whatever initialization steps needed by the language-dependent
  489.    lexical analyzer.
  490.  
  491.    Define the additional tree codes here.  This isn't the best place to put
  492.    it, but it's where g++ does it.  */
  493.  
  494. void
  495. init_lex ()
  496. {
  497.   lang_expand_expr = gnat_expand_expr;
  498.  
  499.   tree_code_type
  500.     = (char **) realloc (tree_code_type,
  501.              sizeof (char *) * LAST_GNAT_TREE_CODE);
  502.   tree_code_length
  503.     = (int *) realloc (tree_code_length,
  504.                sizeof (int) * LAST_GNAT_TREE_CODE);
  505.   tree_code_name
  506.     = (char **) realloc (tree_code_name,
  507.              sizeof (char *) * LAST_GNAT_TREE_CODE);
  508.  
  509.   bcopy ((char *) gnat_tree_code_type,
  510.      (char *) (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE),
  511.      ((LAST_GNAT_TREE_CODE - (int) LAST_AND_UNUSED_TREE_CODE)
  512.       * sizeof (char *)));
  513.  
  514.   bcopy ((char *)gnat_tree_code_length,
  515.      (char *) (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
  516.      ((LAST_GNAT_TREE_CODE - (int) LAST_AND_UNUSED_TREE_CODE)
  517.       * sizeof (int)));
  518.  
  519.   bcopy ((char *) gnat_tree_code_name,
  520.      (char *) (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
  521.      ((LAST_GNAT_TREE_CODE - (int) LAST_AND_UNUSED_TREE_CODE)
  522.       * sizeof (char *)));
  523. }
  524.  
  525. /* Sets some debug flags for the parsed. It does nothing here.  */
  526.  
  527. void
  528. set_yydebug (value)
  529.      int value;
  530. {}
  531.  
  532.  
  533. /* Override the regular abort to call gigi_abort since it gives more useful
  534.    crash error messages.  If abort is a macro, we can't do this.  */
  535.  
  536. #ifndef abort
  537.  
  538. void
  539. abort ()
  540. {
  541.   gigi_abort (999);
  542. }
  543. #endif
  544.  
  545. /* Return the alignment for GNAT_TYPE.  */
  546.  
  547. int
  548. get_type_alignment (gnat_type)
  549.      Entity_Id gnat_type;
  550. {
  551.   return TYPE_ALIGN (gnat_to_gnu_type (gnat_type)) / BITS_PER_UNIT;
  552. }
  553.  
  554. /* Utility Routines needed by the Tree Translator: */
  555.  
  556. /* GNU_TYPE is the type of a subprogram parameter.  Determine from the type if
  557.    it should be passed by reference.  */
  558.  
  559. int
  560. pass_by_ref (gnu_type)
  561.      tree gnu_type;
  562. {
  563.   /* We pass only BLKmode and unconstrained objects by reference.  */
  564.   return (TREE_CODE (gnu_type) == UNCONSTRAINED_ARRAY_TYPE
  565.       || TYPE_MODE (gnu_type) == BLKmode);
  566. }
  567.