gcc/java/java-gimplify.c

   1 /* Java(TM) language-specific gimplification routines.
   2    Copyright (C) 2003, 2004, 2006, 2007, 2007, 2008, 2010
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.
  20
  21 Java and all Java-based marks are trademarks or registered trademarks
  22 of Sun Microsystems, Inc. in the United States and other countries.
  23 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "tree.h"
  29 #include "java-tree.h"
  30 #include "tree-dump.h"
  31 #include "gimple.h"
  32
  33 static tree java_gimplify_block (tree);
  34 static enum gimplify_status java_gimplify_modify_expr (tree *);
  35 static enum gimplify_status java_gimplify_self_mod_expr (tree *, gimple_seq *,
  36                                                          gimple_seq *);
  37
  38 static void dump_java_tree (enum tree_dump_index, tree);
  39
  40 /* Convert a Java tree to GENERIC.  */
  41
  42 void
  43 java_genericize (tree fndecl)
  44 {
  45   walk_tree (&DECL_SAVED_TREE (fndecl), java_replace_references, NULL, NULL);
  46   dump_java_tree (TDI_original, fndecl);
  47 }
  48
  49 /* Gimplify a Java tree.  */
  50
  51 int
  52 java_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
  53 {
  54   enum tree_code code = TREE_CODE (*expr_p);
  55
  56   switch (code)
  57     {
  58     case BLOCK:
  59       *expr_p = java_gimplify_block (*expr_p);
  60       break;
  61
  62     case MODIFY_EXPR:
  63       return java_gimplify_modify_expr (expr_p);
  64
  65     case POSTINCREMENT_EXPR:
  66     case POSTDECREMENT_EXPR:
  67     case PREINCREMENT_EXPR:
  68     case PREDECREMENT_EXPR:
  69       return java_gimplify_self_mod_expr (expr_p, pre_p, post_p);
  70
  71     /* These should already be lowered before we get here.  */
  72     case URSHIFT_EXPR:
  73     case COMPARE_EXPR:
  74     case COMPARE_L_EXPR:
  75     case COMPARE_G_EXPR:
  76       gcc_unreachable ();
  77
  78     default:
  79       return GS_UNHANDLED;
  80     }
  81
  82   return GS_OK;
  83 }
  84
  85 static enum gimplify_status
  86 java_gimplify_modify_expr (tree *modify_expr_p)
  87 {
  88   tree modify_expr = *modify_expr_p;
  89   tree lhs = TREE_OPERAND (modify_expr, 0);
  90   tree rhs = TREE_OPERAND (modify_expr, 1);
  91   tree lhs_type = TREE_TYPE (lhs);
  92
  93   if (lhs_type != TREE_TYPE (rhs))
  94     /* Fix up type mismatches to make legal GIMPLE.  These are
  95        generated in several places, in particular null pointer
  96        assignment and subclass assignment.  */
  97     TREE_OPERAND (modify_expr, 1) = convert (lhs_type, rhs);
  98
  99   return GS_UNHANDLED;
 100 }
 101
 102 /*  Special case handling for volatiles: we need to generate a barrier
 103     between the reading and the writing.  */
 104
 105 static enum gimplify_status
 106 java_gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 107                              gimple_seq *post_p ATTRIBUTE_UNUSED)
 108 {
 109   tree lhs = TREE_OPERAND (*expr_p, 0);
 110
 111   if (TREE_CODE (lhs) == COMPONENT_REF
 112       && TREE_THIS_VOLATILE (TREE_OPERAND (lhs, 1)))
 113     TREE_THIS_VOLATILE (lhs) = 1;
 114
 115   return GS_UNHANDLED;
 116 }
 117
 118
 119 /* Gimplify BLOCK into a BIND_EXPR.  */
 120
 121 static tree
 122 java_gimplify_block (tree java_block)
 123 {
 124   tree decls = BLOCK_VARS (java_block);
 125   tree body = BLOCK_EXPR_BODY (java_block);
 126   gimple outer = gimple_current_bind_expr ();
 127   tree block;
 128
 129   /* Don't bother with empty blocks.  */
 130   if (! body)
 131     return build_empty_stmt (input_location);
 132
 133   if (IS_EMPTY_STMT (body))
 134     return body;
 135
 136   /* Make a proper block.  Java blocks are unsuitable for BIND_EXPR
 137      because they use BLOCK_SUBBLOCKS for another purpose.  */
 138   block = make_node (BLOCK);
 139   BLOCK_VARS (block) = decls;
 140
 141   /* The TREE_USED flag on a block determines whether the debug output
 142      routines generate info for the variables in that block.  */
 143   TREE_USED (block) = 1;
 144
 145   if (outer != NULL)
 146     {
 147       tree b = gimple_bind_block (outer);
 148       BLOCK_SUBBLOCKS (b) = chainon (BLOCK_SUBBLOCKS (b), block);
 149     }
 150   BLOCK_EXPR_BODY (java_block) = NULL_TREE;
 151
 152   return build3 (BIND_EXPR, TREE_TYPE (java_block), decls, body, block);
 153 }
 154
 155 /* Dump a tree of some kind.  This is a convenience wrapper for the
 156    dump_* functions in tree-dump.c.  */
 157 static void
 158 dump_java_tree (enum tree_dump_index phase, tree t)
 159 {
 160   FILE *stream;
 161   int flags;
 162
 163   stream = dump_begin (phase, &flags);
 164   flags |= TDF_SLIM;
 165   if (stream)
 166     {
 167       dump_node (t, flags, stream);
 168       dump_end (phase, stream);
 169     }
 170 }