OSDN Git Service

541e78d2cb56307d65aedd69ceae2f084111ab83
[pf3gnuchains/gcc-fork.git] / gcc / java / constants.c
1 /* Handle the constant pool of the Java(TM) Virtual Machine.
2    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
3    2007, 2008  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 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 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "jcf.h"
29 #include "tree.h"
30 #include "java-tree.h"
31 #include "toplev.h"
32 #include "ggc.h"
33
34 static void set_constant_entry (CPool *, int, int, jword);
35 static int find_tree_constant (CPool *, int, tree);
36 static int find_name_and_type_constant (CPool *, tree, tree);
37 static tree get_tag_node (int);
38
39 /* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */
40
41 static void
42 set_constant_entry (CPool *cpool, int index, int tag, jword value)
43 {
44   if (cpool->data == NULL)
45     {
46       cpool->capacity = 100;
47       cpool->tags = GGC_CNEWVEC (uint8, cpool->capacity);
48       cpool->data = GGC_CNEWVEC (union cpool_entry, cpool->capacity);
49       cpool->count = 1;
50     }
51   if (index >= cpool->capacity)
52     {
53       int old_cap = cpool->capacity;
54       cpool->capacity *= 2;
55       if (index >= cpool->capacity)
56         cpool->capacity = index + 10;
57       cpool->tags = GGC_RESIZEVEC (uint8, cpool->tags, cpool->capacity);
58       cpool->data = GGC_RESIZEVEC (union cpool_entry, cpool->data,
59                                    cpool->capacity);
60
61       /* Make sure GC never sees uninitialized tag values.  */
62       memset (cpool->tags + old_cap, 0, cpool->capacity - old_cap);
63       memset (cpool->data + old_cap, 0,
64               (cpool->capacity - old_cap) * sizeof (union cpool_entry));
65     }
66   if (index >= cpool->count)
67     cpool->count = index + 1;
68   cpool->tags[index] = tag;
69   cpool->data[index].w = value;
70 }
71
72 /* Find (or create) a constant pool entry matching TAG and VALUE. */
73
74 int
75 find_constant1 (CPool *cpool, int tag, jword value)
76 {
77   int i;
78   for (i = cpool->count;  --i > 0; )
79     {
80       if (cpool->tags[i] == tag && cpool->data[i].w == value)
81         return i;
82     }
83   i = cpool->count == 0 ? 1 : cpool->count;
84   set_constant_entry (cpool, i, tag, value);
85   return i;
86 }
87
88 /* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
89
90 int
91 find_constant2 (CPool *cpool, int tag, jword word1, jword word2)
92 {
93   int i;
94   for (i = cpool->count - 1;  --i > 0; )
95     {
96       if (cpool->tags[i] == tag
97           && cpool->data[i].w == word1
98           && cpool->data[i+1].w == word2)
99         return i;
100     }
101   i = cpool->count == 0 ? 1 : cpool->count;
102   set_constant_entry (cpool, i, tag, word1);
103   set_constant_entry (cpool, i+1, 0, word2);
104   return i;
105 }
106
107 static int
108 find_tree_constant (CPool *cpool, int tag, tree value)
109 {
110   int i;
111   for (i = cpool->count;  --i > 0; )
112     {
113       if (cpool->tags[i] == tag && cpool->data[i].t == value)
114         return i;
115     }
116   i = cpool->count == 0 ? 1 : cpool->count;
117   set_constant_entry (cpool, i, tag, 0);
118   cpool->data[i].t = value;
119   return i;
120 }
121
122
123 int
124 find_utf8_constant (CPool *cpool, tree name)
125 {
126   if (name == NULL_TREE)
127     return 0;
128   return find_tree_constant (cpool, CONSTANT_Utf8, name);
129 }
130
131 int
132 find_class_or_string_constant (CPool *cpool, int tag, tree name)
133 {
134   jword j = find_utf8_constant (cpool, name);
135   int i;
136   for (i = cpool->count;  --i > 0; )
137     {
138       if (cpool->tags[i] == tag && cpool->data[i].w == j)
139         return i;
140     }
141   i = cpool->count;
142   set_constant_entry (cpool, i, tag, j);
143   return i;
144 }
145
146 int
147 find_class_constant (CPool *cpool, tree type)
148 {
149   return find_class_or_string_constant (cpool, CONSTANT_Class,
150                                         build_internal_class_name (type));
151 }
152
153 /* Allocate a CONSTANT_string entry given a STRING_CST. */
154
155 int
156 find_string_constant (CPool *cpool, tree string)
157 {
158   string = get_identifier (TREE_STRING_POINTER (string));
159   return find_class_or_string_constant (cpool, CONSTANT_String, string);
160
161 }
162
163 /* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
164    Return its index in the constant pool CPOOL. */
165
166 static int
167 find_name_and_type_constant (CPool *cpool, tree name, tree type)
168 {
169   int name_index = find_utf8_constant (cpool, name);
170   int type_index = find_utf8_constant (cpool, build_java_signature (type));
171   return find_constant1 (cpool, CONSTANT_NameAndType,
172                          (name_index << 16) | type_index);
173 }
174
175 /* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL).
176    Return its index in the constant pool CPOOL. */
177
178 int
179 find_fieldref_index (CPool *cpool, tree decl)
180 {
181   int class_index = find_class_constant (cpool, DECL_CONTEXT (decl));
182   int name_type_index
183     = find_name_and_type_constant (cpool, DECL_NAME (decl), TREE_TYPE (decl));
184   return find_constant1 (cpool, CONSTANT_Fieldref,
185                          (class_index << 16) | name_type_index);
186 }
187
188 /* Find (or create) a CONSTANT_Methodref for DECL (a FUNCTION_DECL).
189    Return its index in the constant pool CPOOL. */
190
191 int
192 find_methodref_index (CPool *cpool, tree decl)
193 {
194   return find_methodref_with_class_index (cpool, decl, DECL_CONTEXT (decl));
195 }
196
197 int
198 find_methodref_with_class_index (CPool *cpool, tree decl, tree mclass)
199 {
200   int class_index = find_class_constant (cpool, mclass);
201   tree name = DECL_CONSTRUCTOR_P (decl) ? init_identifier_node
202     : DECL_NAME (decl);
203   int name_type_index;
204   name_type_index = 
205       find_name_and_type_constant (cpool, name, TREE_TYPE (decl));
206   return find_constant1 (cpool,
207                          CLASS_INTERFACE (TYPE_NAME (mclass))
208                          ? CONSTANT_InterfaceMethodref
209                          : CONSTANT_Methodref,
210                          (class_index << 16) | name_type_index);
211 }
212
213 #define PUT1(X)  (*ptr++ = (X))
214 #define PUT2(X)  (PUT1((X) >> 8), PUT1(X))
215 #define PUT4(X)  (PUT2((X) >> 16), PUT2(X))
216 #define PUTN(P, N)  (memcpy(ptr, (P), (N)), ptr += (N))
217
218 /* Give the number of bytes needed in a .class file for the CPOOL
219    constant pool.  Includes the 2-byte constant_pool_count. */
220
221 int
222 count_constant_pool_bytes (CPool *cpool)
223 {
224   int size = 2;
225   int i = 1;
226   for ( ;  i < cpool->count;  i++)
227     {
228       size++;
229       switch (cpool->tags[i])
230         {
231         case CONSTANT_NameAndType:
232         case CONSTANT_Fieldref:
233         case CONSTANT_Methodref:
234         case CONSTANT_InterfaceMethodref:
235         case CONSTANT_Float:
236         case CONSTANT_Integer:
237           size += 4;
238           break;
239         case CONSTANT_Class:
240         case CONSTANT_String:
241           size += 2;
242           break;
243         case CONSTANT_Long:
244         case CONSTANT_Double:
245           size += 8;
246           i++;
247           break;
248         case CONSTANT_Utf8:
249           {
250             tree t = cpool->data[i].t;
251             int len = IDENTIFIER_LENGTH (t);
252             size += len + 2;
253           }
254           break;
255         default:
256           /* Second word of CONSTANT_Long and  CONSTANT_Double. */
257           size--;
258         }
259     }
260   return size;
261 }
262
263 /* Write the constant pool CPOOL into BUFFER.
264    The length of BUFFER is LENGTH, which must match the needed length. */
265
266 void
267 write_constant_pool (CPool *cpool, unsigned char *buffer, int length)
268 {
269   unsigned char *ptr = buffer;
270   int i = 1;
271   union cpool_entry *datap = &cpool->data[1];
272   PUT2 (cpool->count);
273   for ( ;  i < cpool->count;  i++, datap++)
274     {
275       int tag = cpool->tags[i];
276       PUT1 (tag);
277       switch (tag)
278         {
279         case CONSTANT_NameAndType:
280         case CONSTANT_Fieldref:
281         case CONSTANT_Methodref:
282         case CONSTANT_InterfaceMethodref:
283         case CONSTANT_Float:
284         case CONSTANT_Integer:
285           PUT4 (datap->w);
286           break;
287         case CONSTANT_Class:
288         case CONSTANT_String:
289           PUT2 (datap->w);
290           break;
291           break;
292         case CONSTANT_Long:
293         case CONSTANT_Double:
294           PUT4(datap->w);
295           i++;
296           datap++;
297           PUT4 (datap->w);
298           break;
299         case CONSTANT_Utf8:
300           {
301             tree t = datap->t;
302             int len = IDENTIFIER_LENGTH (t);
303             PUT2 (len);
304             PUTN (IDENTIFIER_POINTER (t), len);
305           }
306           break;
307         }
308     }
309
310   gcc_assert (ptr == buffer + length);
311 }
312
313 static GTY(()) tree tag_nodes[13];
314 static tree
315 get_tag_node (int tag)
316 {
317   /* A Cache for build_int_cst (CONSTANT_XXX, 0). */
318
319   if (tag >= 13)
320     return build_int_cst (NULL_TREE, tag);
321
322   if (tag_nodes[tag] == NULL_TREE)
323     tag_nodes[tag] = build_int_cst (NULL_TREE, tag);
324   return tag_nodes[tag];
325 }
326
327 /* Given a class, return its constant pool, creating one if necessary.  */
328
329 CPool *
330 cpool_for_class (tree klass)
331 {
332   CPool *cpool = TYPE_CPOOL (klass);
333
334   if (cpool == NULL)
335     {
336       cpool = GGC_CNEW (struct CPool);
337       TYPE_CPOOL (klass) = cpool;
338     }
339   return cpool;
340 }
341
342 /* Look for a constant pool entry that matches TAG and NAME.
343    Creates a new entry if not found.
344    TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class.
345    NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class.
346    Returns the index of the entry. */
347
348 int
349 alloc_name_constant (int tag, tree name)
350 {
351   CPool *outgoing_cpool = cpool_for_class (output_class);
352   return find_tree_constant (outgoing_cpool, tag, name);
353 }
354
355 /* Create a constant pool entry for a name_and_type.  This one has '.'
356    rather than '/' because it isn't going into a class file, it's
357    going into a compiled object.  We don't use the '/' separator in
358    compiled objects.  */
359
360 static int
361 find_name_and_type_constant_tree (CPool *cpool, tree name, tree type)
362 {
363   int name_index = find_utf8_constant (cpool, name);
364   int type_index 
365     = find_utf8_constant (cpool, 
366                           identifier_subst (build_java_signature (type), 
367                                             "", '/', '.', ""));
368   return find_constant1 (cpool, CONSTANT_NameAndType,
369                          (name_index << 16) | type_index);
370 }
371
372 /* Look for a field ref that matches DECL in the constant pool of
373    KLASS.  
374    Return the index of the entry.  */
375
376 int
377 alloc_constant_fieldref (tree klass, tree decl)
378 {
379   CPool *outgoing_cpool = cpool_for_class (klass);
380   int class_index 
381     = find_tree_constant (outgoing_cpool, CONSTANT_Class, 
382                           DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
383   int name_type_index
384     = find_name_and_type_constant_tree (outgoing_cpool, DECL_NAME (decl), 
385                                         TREE_TYPE (decl));
386   return find_constant1 (outgoing_cpool, CONSTANT_Fieldref,
387                          (class_index << 16) | name_type_index);
388 }
389
390 /* Build an identifier for the internal name of reference type TYPE. */
391
392 tree
393 build_internal_class_name (tree type)
394 {
395   tree name;
396   if (TYPE_ARRAY_P (type))
397     name = build_java_signature (type);
398   else
399     {
400       name = TYPE_NAME (type);
401       if (TREE_CODE (name) != IDENTIFIER_NODE)
402         name = DECL_NAME (name);
403       name = identifier_subst (name, "", '.', '/', "");
404     }
405   return name;
406 }
407
408 /* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */
409
410 int
411 alloc_class_constant (tree clas)
412 {
413   tree class_name = build_internal_class_name (clas);
414   
415   return alloc_name_constant (CONSTANT_Class,
416                               (unmangle_classname 
417                                (IDENTIFIER_POINTER(class_name),
418                                 IDENTIFIER_LENGTH(class_name))));
419 }
420
421 /* Return the decl of the data array of the current constant pool. */
422
423 tree
424 build_constant_data_ref (bool indirect)
425 {
426   if (indirect)
427     {
428       tree d;
429       tree cpool_type = build_array_type (ptr_type_node, NULL_TREE);
430       tree decl = build_class_ref (output_class);
431       tree klass = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (decl)),
432                            decl);
433       tree constants = build3 (COMPONENT_REF, 
434                                TREE_TYPE (constants_field_decl_node), klass,
435                                constants_field_decl_node,
436                                NULL_TREE);
437       tree data = build3 (COMPONENT_REF, 
438                           TREE_TYPE (constants_data_field_decl_node), 
439                           constants,
440                           constants_data_field_decl_node,
441                           NULL_TREE);
442
443       TREE_THIS_NOTRAP (klass) = 1;
444       data = fold_convert (build_pointer_type (cpool_type), data);
445       d = build1 (INDIRECT_REF, cpool_type, data);
446
447       return d;
448     }
449   else
450     {
451       tree decl_name = mangled_classname ("_CD_", output_class);
452       tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
453
454       if (! decl)
455         {
456           /* Build a type with unspecified bounds.  The will make sure
457              that targets do the right thing with whatever size we end
458              up with at the end.  Using bounds that are too small risks
459              assuming the data is in the small data section.  */
460           tree type = build_array_type (ptr_type_node, NULL_TREE);
461
462           /* We need to lay out the type ourselves, since build_array_type
463              thinks the type is incomplete.  */
464           layout_type (type);
465
466           decl = build_decl (input_location, VAR_DECL, decl_name, type);
467           TREE_STATIC (decl) = 1;
468           IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
469         }
470
471       return decl;
472     }
473 }
474
475 /* Get the pointer value at the INDEX'th element of the constant pool. */
476
477 tree
478 build_ref_from_constant_pool (int index)
479 {
480   tree i;
481   tree d = TYPE_CPOOL_DATA_REF (output_class);
482
483   if (d == NULL_TREE)
484     d = build_constant_data_ref (flag_indirect_classes);
485
486   i = build_int_cst (NULL_TREE, index);
487   d = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (d)), d, i,
488                  NULL_TREE, NULL_TREE);
489   return d;
490 }
491
492 /* Build an initializer for the constants field of the current constant pool.
493    Should only be called at top-level, since it may emit declarations. */
494
495 tree
496 build_constants_constructor (void)
497 {
498   CPool *outgoing_cpool = cpool_for_class (current_class);
499   tree tags_value, data_value;
500   tree cons;
501   tree tags_list = NULL_TREE;
502   tree data_list = NULL_TREE;
503   int i;
504
505   for (i = outgoing_cpool->count;  --i > 0; )
506     switch (outgoing_cpool->tags[i] & ~CONSTANT_LazyFlag)
507       {
508       case CONSTANT_None:  /* The second half of a Double or Long on a
509                               32-bit target.  */
510       case CONSTANT_Fieldref:
511       case CONSTANT_NameAndType:
512       case CONSTANT_Float:
513       case CONSTANT_Integer:
514       case CONSTANT_Double:
515       case CONSTANT_Long:
516       case CONSTANT_Methodref:
517       case CONSTANT_InterfaceMethodref:
518         {
519           unsigned HOST_WIDE_INT temp = outgoing_cpool->data[i].w;
520
521           /* Make sure that on a big-endian machine with 64-bit
522              pointers this 32-bit jint appears in the first word.
523              FIXME: This is a kludge.  The field we're initializing is
524              not a scalar but a union, and that's how we should
525              represent it in the compiler.  We should fix this.  */
526           if (BYTES_BIG_ENDIAN && POINTER_SIZE > 32)
527             temp <<= POINTER_SIZE - 32;
528
529           tags_list
530             = tree_cons (NULL_TREE, get_tag_node (outgoing_cpool->tags[i]),
531                          tags_list);
532           data_list
533             = tree_cons (NULL_TREE, 
534                          fold_convert (ptr_type_node, 
535                                        (build_int_cst (NULL_TREE, temp))),
536                          data_list);
537         }
538         break;
539
540       case CONSTANT_Class:
541       case CONSTANT_String:
542       case CONSTANT_Unicode:
543       case CONSTANT_Utf8:
544         tags_list
545           = tree_cons (NULL_TREE, get_tag_node (outgoing_cpool->tags[i]),
546                        tags_list);
547         data_list
548           = tree_cons (NULL_TREE, build_utf8_ref (outgoing_cpool->data[i].t),
549                        data_list);
550         break;
551
552       default:
553         gcc_assert (false);
554       }
555   if (outgoing_cpool->count > 0)
556     {
557       tree data_decl, tags_decl, tags_type;
558       tree max_index = build_int_cst (sizetype, outgoing_cpool->count - 1);
559       tree index_type = build_index_type (max_index);
560       tree tem;
561
562       /* Add dummy 0'th element of constant pool. */
563       tags_list = tree_cons (NULL_TREE, get_tag_node (0), tags_list);
564       data_list = tree_cons (NULL_TREE, null_pointer_node, data_list);
565   
566       /* Change the type of the decl to have the proper array size.
567          ???  Make sure to transition the old type-pointer-to list to this
568          new type to not invalidate all build address expressions.  */
569       data_decl = build_constant_data_ref (false);
570       tem = TYPE_POINTER_TO (TREE_TYPE (data_decl));
571       if (!tem)
572         tem = build_pointer_type (TREE_TYPE (data_decl));
573       TYPE_POINTER_TO (TREE_TYPE (data_decl)) = NULL_TREE;
574       TREE_TYPE (data_decl) = build_array_type (ptr_type_node, index_type);
575       TYPE_POINTER_TO (TREE_TYPE (data_decl)) = tem;
576       DECL_INITIAL (data_decl) = build_constructor_from_list
577                                   (TREE_TYPE (data_decl), data_list);
578       DECL_SIZE (data_decl) = TYPE_SIZE (TREE_TYPE (data_decl));
579       DECL_SIZE_UNIT (data_decl) = TYPE_SIZE_UNIT (TREE_TYPE (data_decl));
580       rest_of_decl_compilation (data_decl, 1, 0);
581       data_value = build_address_of (data_decl);
582
583       tags_type = build_array_type (unsigned_byte_type_node, index_type);
584       tags_decl = build_decl (input_location, 
585                               VAR_DECL, mangled_classname ("_CT_", 
586                                                            current_class),
587                               tags_type);
588       TREE_STATIC (tags_decl) = 1;
589       DECL_INITIAL (tags_decl) = build_constructor_from_list
590                                  (tags_type, tags_list);
591       rest_of_decl_compilation (tags_decl, 1, 0);
592       tags_value = build_address_of (tags_decl);
593     }
594   else
595     {
596       data_value = null_pointer_node;
597       tags_value = null_pointer_node;
598     }
599   START_RECORD_CONSTRUCTOR (cons, constants_type_node);
600   PUSH_FIELD_VALUE (cons, "size",
601                     build_int_cst (NULL_TREE, outgoing_cpool->count));
602   PUSH_FIELD_VALUE (cons, "tags", tags_value);
603   PUSH_FIELD_VALUE (cons, "data", data_value);
604   FINISH_RECORD_CONSTRUCTOR (cons);
605   return cons;
606 }
607
608 #include "gt-java-constants.h"