2011-04-29 Richard Guenther <rguenther@suse.de>
[official-gcc.git] / gcc / java / constants.c
blob2cc911f33bd167eac657413ca0e646f6a0ffbdd0
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, 2010, 2011 Free Software Foundation, Inc.
5 This file is part of GCC.
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.
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/>.
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. */
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 "diagnostic-core.h"
32 #include "toplev.h"
33 #include "ggc.h"
35 static void set_constant_entry (CPool *, int, int, jword);
36 static int find_tree_constant (CPool *, int, tree);
37 static int find_name_and_type_constant (CPool *, tree, tree);
38 static tree get_tag_node (int);
40 /* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */
42 static void
43 set_constant_entry (CPool *cpool, int index, int tag, jword value)
45 if (cpool->data == NULL)
47 cpool->capacity = 100;
48 cpool->tags = (uint8 *) ggc_alloc_cleared_atomic (sizeof (uint8)
49 * cpool->capacity);
50 cpool->data = ggc_alloc_cleared_vec_cpool_entry (sizeof
51 (union cpool_entry),
52 cpool->capacity);
53 cpool->count = 1;
55 if (index >= cpool->capacity)
57 int old_cap = cpool->capacity;
58 cpool->capacity *= 2;
59 if (index >= cpool->capacity)
60 cpool->capacity = index + 10;
61 cpool->tags = GGC_RESIZEVEC (uint8, cpool->tags, cpool->capacity);
62 cpool->data = GGC_RESIZEVEC (union cpool_entry, cpool->data,
63 cpool->capacity);
65 /* Make sure GC never sees uninitialized tag values. */
66 memset (cpool->tags + old_cap, 0, cpool->capacity - old_cap);
67 memset (cpool->data + old_cap, 0,
68 (cpool->capacity - old_cap) * sizeof (union cpool_entry));
70 if (index >= cpool->count)
71 cpool->count = index + 1;
72 cpool->tags[index] = tag;
73 cpool->data[index].w = value;
76 /* Find (or create) a constant pool entry matching TAG and VALUE. */
78 int
79 find_constant1 (CPool *cpool, int tag, jword value)
81 int i;
82 for (i = cpool->count; --i > 0; )
84 if (cpool->tags[i] == tag && cpool->data[i].w == value)
85 return i;
87 i = cpool->count == 0 ? 1 : cpool->count;
88 set_constant_entry (cpool, i, tag, value);
89 return i;
92 /* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
94 int
95 find_constant2 (CPool *cpool, int tag, jword word1, jword word2)
97 int i;
98 for (i = cpool->count - 1; --i > 0; )
100 if (cpool->tags[i] == tag
101 && cpool->data[i].w == word1
102 && cpool->data[i+1].w == word2)
103 return i;
105 i = cpool->count == 0 ? 1 : cpool->count;
106 set_constant_entry (cpool, i, tag, word1);
107 set_constant_entry (cpool, i+1, 0, word2);
108 return i;
111 static int
112 find_tree_constant (CPool *cpool, int tag, tree value)
114 int i;
115 for (i = cpool->count; --i > 0; )
117 if (cpool->tags[i] == tag && cpool->data[i].t == value)
118 return i;
120 i = cpool->count == 0 ? 1 : cpool->count;
121 set_constant_entry (cpool, i, tag, 0);
122 cpool->data[i].t = value;
123 return i;
128 find_utf8_constant (CPool *cpool, tree name)
130 if (name == NULL_TREE)
131 return 0;
132 return find_tree_constant (cpool, CONSTANT_Utf8, name);
136 find_class_or_string_constant (CPool *cpool, int tag, tree name)
138 jword j = find_utf8_constant (cpool, name);
139 int i;
140 for (i = cpool->count; --i > 0; )
142 if (cpool->tags[i] == tag && cpool->data[i].w == j)
143 return i;
145 i = cpool->count;
146 set_constant_entry (cpool, i, tag, j);
147 return i;
151 find_class_constant (CPool *cpool, tree type)
153 return find_class_or_string_constant (cpool, CONSTANT_Class,
154 build_internal_class_name (type));
157 /* Allocate a CONSTANT_string entry given a STRING_CST. */
160 find_string_constant (CPool *cpool, tree string)
162 string = get_identifier (TREE_STRING_POINTER (string));
163 return find_class_or_string_constant (cpool, CONSTANT_String, string);
167 /* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
168 Return its index in the constant pool CPOOL. */
170 static int
171 find_name_and_type_constant (CPool *cpool, tree name, tree type)
173 int name_index = find_utf8_constant (cpool, name);
174 int type_index = find_utf8_constant (cpool, build_java_signature (type));
175 return find_constant1 (cpool, CONSTANT_NameAndType,
176 (name_index << 16) | type_index);
179 /* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL).
180 Return its index in the constant pool CPOOL. */
183 find_fieldref_index (CPool *cpool, tree decl)
185 int class_index = find_class_constant (cpool, DECL_CONTEXT (decl));
186 int name_type_index
187 = find_name_and_type_constant (cpool, DECL_NAME (decl), TREE_TYPE (decl));
188 return find_constant1 (cpool, CONSTANT_Fieldref,
189 (class_index << 16) | name_type_index);
192 /* Find (or create) a CONSTANT_Methodref for DECL (a FUNCTION_DECL).
193 Return its index in the constant pool CPOOL. */
196 find_methodref_index (CPool *cpool, tree decl)
198 return find_methodref_with_class_index (cpool, decl, DECL_CONTEXT (decl));
202 find_methodref_with_class_index (CPool *cpool, tree decl, tree mclass)
204 int class_index = find_class_constant (cpool, mclass);
205 tree name = DECL_CONSTRUCTOR_P (decl) ? init_identifier_node
206 : DECL_NAME (decl);
207 int name_type_index;
208 name_type_index =
209 find_name_and_type_constant (cpool, name, TREE_TYPE (decl));
210 return find_constant1 (cpool,
211 CLASS_INTERFACE (TYPE_NAME (mclass))
212 ? CONSTANT_InterfaceMethodref
213 : CONSTANT_Methodref,
214 (class_index << 16) | name_type_index);
217 #define PUT1(X) (*ptr++ = (X))
218 #define PUT2(X) (PUT1((X) >> 8), PUT1(X))
219 #define PUT4(X) (PUT2((X) >> 16), PUT2(X))
220 #define PUTN(P, N) (memcpy(ptr, (P), (N)), ptr += (N))
222 /* Give the number of bytes needed in a .class file for the CPOOL
223 constant pool. Includes the 2-byte constant_pool_count. */
226 count_constant_pool_bytes (CPool *cpool)
228 int size = 2;
229 int i = 1;
230 for ( ; i < cpool->count; i++)
232 size++;
233 switch (cpool->tags[i])
235 case CONSTANT_NameAndType:
236 case CONSTANT_Fieldref:
237 case CONSTANT_Methodref:
238 case CONSTANT_InterfaceMethodref:
239 case CONSTANT_Float:
240 case CONSTANT_Integer:
241 size += 4;
242 break;
243 case CONSTANT_Class:
244 case CONSTANT_String:
245 size += 2;
246 break;
247 case CONSTANT_Long:
248 case CONSTANT_Double:
249 size += 8;
250 i++;
251 break;
252 case CONSTANT_Utf8:
254 tree t = cpool->data[i].t;
255 int len = IDENTIFIER_LENGTH (t);
256 size += len + 2;
258 break;
259 default:
260 /* Second word of CONSTANT_Long and CONSTANT_Double. */
261 size--;
264 return size;
267 /* Write the constant pool CPOOL into BUFFER.
268 The length of BUFFER is LENGTH, which must match the needed length. */
270 void
271 write_constant_pool (CPool *cpool, unsigned char *buffer, int length)
273 unsigned char *ptr = buffer;
274 int i = 1;
275 union cpool_entry *datap = &cpool->data[1];
276 PUT2 (cpool->count);
277 for ( ; i < cpool->count; i++, datap++)
279 int tag = cpool->tags[i];
280 PUT1 (tag);
281 switch (tag)
283 case CONSTANT_NameAndType:
284 case CONSTANT_Fieldref:
285 case CONSTANT_Methodref:
286 case CONSTANT_InterfaceMethodref:
287 case CONSTANT_Float:
288 case CONSTANT_Integer:
289 PUT4 (datap->w);
290 break;
291 case CONSTANT_Class:
292 case CONSTANT_String:
293 PUT2 (datap->w);
294 break;
295 break;
296 case CONSTANT_Long:
297 case CONSTANT_Double:
298 PUT4(datap->w);
299 i++;
300 datap++;
301 PUT4 (datap->w);
302 break;
303 case CONSTANT_Utf8:
305 tree t = datap->t;
306 int len = IDENTIFIER_LENGTH (t);
307 PUT2 (len);
308 PUTN (IDENTIFIER_POINTER (t), len);
310 break;
314 gcc_assert (ptr == buffer + length);
317 static GTY(()) tree tag_nodes[13];
318 static tree
319 get_tag_node (int tag)
321 /* A Cache for build_int_cst (CONSTANT_XXX, 0). */
323 if (tag >= 13)
324 return build_int_cst (NULL_TREE, tag);
326 if (tag_nodes[tag] == NULL_TREE)
327 tag_nodes[tag] = build_int_cst (NULL_TREE, tag);
328 return tag_nodes[tag];
331 /* Given a class, return its constant pool, creating one if necessary. */
333 CPool *
334 cpool_for_class (tree klass)
336 CPool *cpool = TYPE_CPOOL (klass);
338 if (cpool == NULL)
340 cpool = ggc_alloc_cleared_CPool ();
341 TYPE_CPOOL (klass) = cpool;
343 return cpool;
346 /* Look for a constant pool entry that matches TAG and NAME.
347 Creates a new entry if not found.
348 TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class.
349 NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class.
350 Returns the index of the entry. */
353 alloc_name_constant (int tag, tree name)
355 CPool *outgoing_cpool = cpool_for_class (output_class);
356 return find_tree_constant (outgoing_cpool, tag, name);
359 /* Create a constant pool entry for a name_and_type. This one has '.'
360 rather than '/' because it isn't going into a class file, it's
361 going into a compiled object. We don't use the '/' separator in
362 compiled objects. */
364 static int
365 find_name_and_type_constant_tree (CPool *cpool, tree name, tree type)
367 int name_index = find_utf8_constant (cpool, name);
368 int type_index
369 = find_utf8_constant (cpool,
370 identifier_subst (build_java_signature (type),
371 "", '/', '.', ""));
372 return find_constant1 (cpool, CONSTANT_NameAndType,
373 (name_index << 16) | type_index);
376 /* Look for a field ref that matches DECL in the constant pool of
377 KLASS.
378 Return the index of the entry. */
381 alloc_constant_fieldref (tree klass, tree decl)
383 CPool *outgoing_cpool = cpool_for_class (klass);
384 int class_index
385 = find_tree_constant (outgoing_cpool, CONSTANT_Class,
386 DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
387 int name_type_index
388 = find_name_and_type_constant_tree (outgoing_cpool, DECL_NAME (decl),
389 TREE_TYPE (decl));
390 return find_constant1 (outgoing_cpool, CONSTANT_Fieldref,
391 (class_index << 16) | name_type_index);
394 /* Build an identifier for the internal name of reference type TYPE. */
396 tree
397 build_internal_class_name (tree type)
399 tree name;
400 if (TYPE_ARRAY_P (type))
401 name = build_java_signature (type);
402 else
404 name = TYPE_NAME (type);
405 if (TREE_CODE (name) != IDENTIFIER_NODE)
406 name = DECL_NAME (name);
407 name = identifier_subst (name, "", '.', '/', "");
409 return name;
412 /* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */
415 alloc_class_constant (tree clas)
417 tree class_name = build_internal_class_name (clas);
419 return alloc_name_constant (CONSTANT_Class,
420 (unmangle_classname
421 (IDENTIFIER_POINTER(class_name),
422 IDENTIFIER_LENGTH(class_name))));
425 /* Return the decl of the data array of the current constant pool. */
427 tree
428 build_constant_data_ref (bool indirect)
430 if (indirect)
432 tree d;
433 tree cpool_type = build_array_type (ptr_type_node, NULL_TREE);
434 tree decl = build_class_ref (output_class);
435 tree klass = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (decl)),
436 decl);
437 tree constants = build3 (COMPONENT_REF,
438 TREE_TYPE (constants_field_decl_node), klass,
439 constants_field_decl_node,
440 NULL_TREE);
441 tree data = build3 (COMPONENT_REF,
442 TREE_TYPE (constants_data_field_decl_node),
443 constants,
444 constants_data_field_decl_node,
445 NULL_TREE);
447 TREE_THIS_NOTRAP (klass) = 1;
448 data = fold_convert (build_pointer_type (cpool_type), data);
449 d = build1 (INDIRECT_REF, cpool_type, data);
451 return d;
453 else
455 tree decl_name = mangled_classname ("_CD_", output_class);
456 tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
458 if (! decl)
460 /* Build a type with unspecified bounds. The will make sure
461 that targets do the right thing with whatever size we end
462 up with at the end. Using bounds that are too small risks
463 assuming the data is in the small data section. */
464 tree type = build_array_type (ptr_type_node, NULL_TREE);
466 /* We need to lay out the type ourselves, since build_array_type
467 thinks the type is incomplete. */
468 layout_type (type);
470 decl = build_decl (input_location, VAR_DECL, decl_name, type);
471 TREE_STATIC (decl) = 1;
472 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
475 return decl;
479 /* Get the pointer value at the INDEX'th element of the constant pool. */
481 tree
482 build_ref_from_constant_pool (int index)
484 tree i;
485 tree d = TYPE_CPOOL_DATA_REF (output_class);
487 if (d == NULL_TREE)
488 d = build_constant_data_ref (flag_indirect_classes);
490 i = build_int_cst (NULL_TREE, index);
491 d = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (d)), d, i,
492 NULL_TREE, NULL_TREE);
493 return d;
496 /* Build an initializer for the constants field of the current constant pool.
497 Should only be called at top-level, since it may emit declarations. */
499 tree
500 build_constants_constructor (void)
502 CPool *outgoing_cpool = cpool_for_class (current_class);
503 tree tags_value, data_value;
504 tree cons;
505 VEC(constructor_elt,gc) *v = NULL;
506 int i;
507 VEC(constructor_elt,gc) *tags = NULL;
508 VEC(constructor_elt,gc) *data = NULL;
509 constructor_elt *t = NULL;
510 constructor_elt *d = NULL;
512 if (outgoing_cpool->count > 0)
514 int c = outgoing_cpool->count;
515 VEC_safe_grow_cleared (constructor_elt, gc, tags, c);
516 VEC_safe_grow_cleared (constructor_elt, gc, data, c);
517 t = VEC_index (constructor_elt, tags, c-1);
518 d = VEC_index (constructor_elt, data, c-1);
521 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
522 for (i = outgoing_cpool->count; --i > 0; )
523 switch (outgoing_cpool->tags[i] & ~CONSTANT_LazyFlag)
525 case CONSTANT_None: /* The second half of a Double or Long on a
526 32-bit target. */
527 case CONSTANT_Fieldref:
528 case CONSTANT_NameAndType:
529 case CONSTANT_Float:
530 case CONSTANT_Integer:
531 case CONSTANT_Double:
532 case CONSTANT_Long:
533 case CONSTANT_Methodref:
534 case CONSTANT_InterfaceMethodref:
536 unsigned HOST_WIDE_INT temp = outgoing_cpool->data[i].w;
538 /* Make sure that on a big-endian machine with 64-bit
539 pointers this 32-bit jint appears in the first word.
540 FIXME: This is a kludge. The field we're initializing is
541 not a scalar but a union, and that's how we should
542 represent it in the compiler. We should fix this. */
543 if (BYTES_BIG_ENDIAN)
544 temp <<= ((POINTER_SIZE > 32) ? POINTER_SIZE - 32 : 0);
546 CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i]));
547 CONSTRUCTOR_PREPEND_VALUE (d, build_int_cst (ptr_type_node, temp));
549 break;
551 case CONSTANT_Class:
552 case CONSTANT_String:
553 case CONSTANT_Unicode:
554 case CONSTANT_Utf8:
555 CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i]));
556 CONSTRUCTOR_PREPEND_VALUE (d, build_utf8_ref (outgoing_cpool->data[i].t));
557 break;
559 default:
560 gcc_assert (false);
562 #undef CONSTRUCTOR_PREPEND_VALUE
564 if (outgoing_cpool->count > 0)
566 tree data_decl, tags_decl, tags_type;
567 tree max_index = build_int_cst (sizetype, outgoing_cpool->count - 1);
568 tree index_type = build_index_type (max_index);
569 tree tem;
571 /* Add dummy 0'th element of constant pool. */
572 gcc_assert (t == VEC_address (constructor_elt, tags));
573 gcc_assert (d == VEC_address (constructor_elt, data));
574 t->value = get_tag_node (0);
575 d->value = null_pointer_node;
577 /* Change the type of the decl to have the proper array size.
578 ??? Make sure to transition the old type-pointer-to list to this
579 new type to not invalidate all build address expressions. */
580 data_decl = build_constant_data_ref (false);
581 tem = TYPE_POINTER_TO (TREE_TYPE (data_decl));
582 if (!tem)
583 tem = build_pointer_type (TREE_TYPE (data_decl));
584 TYPE_POINTER_TO (TREE_TYPE (data_decl)) = NULL_TREE;
585 TREE_TYPE (data_decl) = build_array_type (ptr_type_node, index_type);
586 TYPE_POINTER_TO (TREE_TYPE (data_decl)) = tem;
587 DECL_INITIAL (data_decl) = build_constructor (TREE_TYPE (data_decl), data);
588 DECL_SIZE (data_decl) = TYPE_SIZE (TREE_TYPE (data_decl));
589 DECL_SIZE_UNIT (data_decl) = TYPE_SIZE_UNIT (TREE_TYPE (data_decl));
590 rest_of_decl_compilation (data_decl, 1, 0);
591 data_value = build_address_of (data_decl);
593 tags_type = build_array_type (unsigned_byte_type_node, index_type);
594 tags_decl = build_decl (input_location,
595 VAR_DECL, mangled_classname ("_CT_",
596 current_class),
597 tags_type);
598 TREE_STATIC (tags_decl) = 1;
599 DECL_INITIAL (tags_decl) = build_constructor (tags_type, tags);
600 rest_of_decl_compilation (tags_decl, 1, 0);
601 tags_value = build_address_of (tags_decl);
603 else
605 data_value = null_pointer_node;
606 tags_value = null_pointer_node;
608 START_RECORD_CONSTRUCTOR (v, constants_type_node);
609 PUSH_FIELD_VALUE (v, "size",
610 build_int_cst (NULL_TREE, outgoing_cpool->count));
611 PUSH_FIELD_VALUE (v, "tags", tags_value);
612 PUSH_FIELD_VALUE (v, "data", data_value);
613 FINISH_RECORD_CONSTRUCTOR (cons, v, constants_type_node);
614 return cons;
617 #include "gt-java-constants.h"