gcc/java/boehm.c

   1 /* Functions related to the Boehm garbage collector.
   2    Copyright (C) 2000-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.
  19
  20 Java and all Java-based marks are trademarks or registered trademarks
  21 of Sun Microsystems, Inc. in the United States and other countries.
  22 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  23
  24 /* Written by Tom Tromey <tromey@cygnus.com>.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "java-tree.h"
  32 #include "parse.h"
  33
  34 static void mark_reference_fields (tree, wide_int *, unsigned int,
  35                                    int *, int *, int *, HOST_WIDE_INT *);
  36
  37 /* A procedure-based object descriptor.  We know that our
  38    `kind' is 0, and `env' is likewise 0, so we have a simple
  39    computation.  From the GC sources:
  40    (((((env) << LOG_MAX_MARK_PROCS) | (proc_index)) << DS_TAG_BITS)     \
  41    | DS_PROC)
  42    Here DS_PROC == 2.  */
  43 #define PROCEDURE_OBJECT_DESCRIPTOR 2
  44
  45 /* Recursively mark reference fields.  */
  46 static void
  47 mark_reference_fields (tree field,
  48                        wide_int *mask,
  49                        unsigned int ubit,
  50                        int *pointer_after_end,
  51                        int *all_bits_set,
  52                        int *last_set_index,
  53                        HOST_WIDE_INT *last_view_index)
  54 {
  55   /* See if we have fields from our superclass.  */
  56   if (DECL_NAME (field) == NULL_TREE)
  57     {
  58       mark_reference_fields (TYPE_FIELDS (TREE_TYPE (field)),
  59                              mask, ubit,
  60                              pointer_after_end, all_bits_set,
  61                              last_set_index, last_view_index);
  62       field = DECL_CHAIN (field);
  63     }
  64
  65   for (; field != NULL_TREE; field = DECL_CHAIN (field))
  66     {
  67       HOST_WIDE_INT offset;
  68       HOST_WIDE_INT size_bytes;
  69
  70       if (FIELD_STATIC (field))
  71         continue;
  72
  73       offset = int_byte_position (field);
  74       size_bytes = int_size_in_bytes (TREE_TYPE (field));
  75
  76       if (JREFERENCE_TYPE_P (TREE_TYPE (field))
  77           /* An `object' of type gnu.gcj.RawData is actually non-Java
  78              data.  */
  79           && TREE_TYPE (field) != rawdata_ptr_type_node)
  80         {
  81           unsigned int count;
  82           unsigned int size_words;
  83           unsigned int i;
  84
  85           /* If this reference slot appears to overlay a slot we think
  86              we already covered, then we are doomed.  */
  87           gcc_assert (offset > *last_view_index);
  88
  89           if (offset % (HOST_WIDE_INT) (POINTER_SIZE / BITS_PER_UNIT))
  90             {
  91               *all_bits_set = -1;
  92               *pointer_after_end = 1;
  93               break;
  94             }
  95
  96           count = offset * BITS_PER_UNIT / POINTER_SIZE;
  97           size_words = size_bytes * BITS_PER_UNIT / POINTER_SIZE;
  98
  99           *last_set_index = count;
 100
 101           if (count >= ubit - 2)
 102             *pointer_after_end = 1;
 103           else
 104             /* First word in object corresponds to most significant byte of
 105                bitmap.
 106
 107                In the case of a multiple-word record, we set pointer
 108                bits for all words in the record. This is conservative, but the
 109                size_words != 1 case is impossible in regular java code. */
 110             for (i = 0; i < size_words; ++i)
 111               *mask = wi::set_bit (*mask, ubit - count - i - 1);
 112
 113           /* If we saw a non-reference field earlier, then we can't
 114              use the count representation.  We keep track of that in
 115              *ALL_BITS_SET.  */
 116           if (! *all_bits_set)
 117             *all_bits_set = -1;
 118         }
 119       else if (*all_bits_set > 0)
 120         *all_bits_set = 0;
 121
 122       *last_view_index = offset;
 123     }
 124 }
 125
 126 /* Return the marking bitmap for the class TYPE.  For now this is a
 127    single word describing the type.  */
 128 tree
 129 get_boehm_type_descriptor (tree type)
 130 {
 131   unsigned int count, log2_size, ubit;
 132   int bit;
 133   int all_bits_set = 1;
 134   int last_set_index = 0;
 135   HOST_WIDE_INT last_view_index = -1;
 136   int pointer_after_end = 0;
 137   tree field, value, value_type;
 138
 139   /* If the GC wasn't requested, just use a null pointer.  */
 140   if (! flag_use_boehm_gc)
 141     return null_pointer_node;
 142
 143   value_type = java_type_for_mode (ptr_mode, 1);
 144   wide_int mask = wi::zero (TYPE_PRECISION (value_type));
 145
 146   /* If we have a type of unknown size, use a proc.  */
 147   if (int_size_in_bytes (type) == -1)
 148     goto procedure_object_descriptor;
 149
 150   bit = POINTER_SIZE / BITS_PER_UNIT;
 151   /* The size of this node has to be known.  And, we only support 32
 152      and 64 bit targets, so we need to know that the log2 is one of
 153      our values.  */
 154   log2_size = exact_log2 (bit);
 155   if (bit == -1 || (log2_size != 2 && log2_size != 3))
 156     {
 157       /* This means the GC isn't supported.  We should probably
 158          abort or give an error.  Instead, for now, we just silently
 159          revert.  FIXME.  */
 160       return null_pointer_node;
 161     }
 162   bit *= BITS_PER_UNIT;
 163
 164   /* Warning avoidance.  */
 165   ubit = (unsigned int) bit;
 166
 167   if (type == class_type_node)
 168     goto procedure_object_descriptor;
 169
 170   field = TYPE_FIELDS (type);
 171   mark_reference_fields (field, &mask, ubit,
 172                          &pointer_after_end, &all_bits_set,
 173                          &last_set_index, &last_view_index);
 174
 175   /* If the object is all pointers, or if the part with pointers fits
 176      in our bitmap, then we are ok.  Otherwise we have to allocate it
 177      a different way.  */
 178   if (all_bits_set != -1 || (pointer_after_end && flag_reduced_reflection))
 179     {
 180       /* In this case the initial part of the object is all reference
 181          fields, and the end of the object is all non-reference
 182          fields.  We represent the mark as a count of the fields,
 183          shifted.  In the GC the computation looks something like
 184          this:
 185          value = DS_LENGTH | WORDS_TO_BYTES (last_set_index + 1);
 186          DS_LENGTH is 0.
 187          WORDS_TO_BYTES shifts by log2(bytes-per-pointer).
 188
 189          In the case of flag_reduced_reflection and the bitmap would
 190          overflow, we tell the gc that the object is all pointers so
 191          that we don't have to emit reflection data for run time
 192          marking. */
 193       count = 0;
 194       mask = wi::zero (TYPE_PRECISION (value_type));
 195       ++last_set_index;
 196       while (last_set_index)
 197         {
 198           if ((last_set_index & 1))
 199             mask = wi::set_bit (mask, log2_size + count);
 200           last_set_index >>= 1;
 201           ++count;
 202         }
 203       value = wide_int_to_tree (value_type, mask);
 204     }
 205   else if (! pointer_after_end)
 206     {
 207       /* Bottom two bits for bitmap mark type are 01.  */
 208       mask = wi::set_bit (mask, 0);
 209       value = wide_int_to_tree (value_type, mask);
 210     }
 211   else
 212     {
 213     procedure_object_descriptor:
 214       value = build_int_cst (value_type, PROCEDURE_OBJECT_DESCRIPTOR);
 215     }
 216
 217   return value;
 218 }
 219
 220 /* The fourth (index of 3) element in the vtable is the GC descriptor.
 221    A value of 2 indicates that the class uses _Jv_MarkObj. */
 222 bool
 223 uses_jv_markobj_p (tree dtable)
 224 {
 225   tree v;
 226   /* FIXME: what do we return if !flag_use_boehm_gc ? */
 227   gcc_assert (flag_use_boehm_gc);
 228   /* FIXME: this is wrong if TARGET_VTABLE_USES_DESCRIPTORS.  However,
 229      this function is only used with flag_reduced_reflection.  No
 230      point in asserting unless we hit the bad case.  */
 231   gcc_assert (!flag_reduced_reflection || TARGET_VTABLE_USES_DESCRIPTORS == 0);
 232   v = (*CONSTRUCTOR_ELTS (dtable))[3].value;
 233   return (PROCEDURE_OBJECT_DESCRIPTOR == TREE_INT_CST_LOW (v));
 234 }