Fix type in the changelog entry,
[official-gcc.git] / gcc / java / constants.c
blob942c867fb7009e243ff50c75563ab93d97e29b42
1 /* Handle the constant pool of the Java(TM) Virtual Machine.
2 Copyright (C) 1997-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
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.
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 You should have received a copy of the GNU General Public License
16 along with GCC; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>.
19 Java and all Java-based marks are trademarks or registered trademarks
20 of Sun Microsystems, Inc. in the United States and other countries.
21 The Free Software Foundation is independent of Sun Microsystems, Inc. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "jcf.h"
28 #include "alias.h"
29 #include "tree.h"
30 #include "fold-const.h"
31 #include "stringpool.h"
32 #include "stor-layout.h"
33 #include "java-tree.h"
34 #include "diagnostic-core.h"
35 #include "toplev.h"
37 static void set_constant_entry (CPool *, int, int, jword);
38 static int find_tree_constant (CPool *, int, tree);
39 static int find_name_and_type_constant (CPool *, tree, tree);
40 static tree get_tag_node (int);
42 /* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */
44 static void
45 set_constant_entry (CPool *cpool, int index, int tag, jword value)
47 if (cpool->data == NULL)
49 cpool->capacity = 100;
50 cpool->tags = ggc_cleared_vec_alloc<uint8> (cpool->capacity);
51 cpool->data = ggc_cleared_vec_alloc<cpool_entry> (cpool->capacity);
52 cpool->count = 1;
54 if (index >= cpool->capacity)
56 int old_cap = cpool->capacity;
57 cpool->capacity *= 2;
58 if (index >= cpool->capacity)
59 cpool->capacity = index + 10;
60 cpool->tags = GGC_RESIZEVEC (uint8, cpool->tags, cpool->capacity);
61 cpool->data = GGC_RESIZEVEC (union cpool_entry, cpool->data,
62 cpool->capacity);
64 /* Make sure GC never sees uninitialized tag values. */
65 memset (cpool->tags + old_cap, 0, cpool->capacity - old_cap);
66 memset (cpool->data + old_cap, 0,
67 (cpool->capacity - old_cap) * sizeof (union cpool_entry));
69 if (index >= cpool->count)
70 cpool->count = index + 1;
71 cpool->tags[index] = tag;
72 cpool->data[index].w = value;
75 /* Find (or create) a constant pool entry matching TAG and VALUE. */
77 int
78 find_constant1 (CPool *cpool, int tag, jword value)
80 int i;
81 for (i = cpool->count; --i > 0; )
83 if (cpool->tags[i] == tag && cpool->data[i].w == value)
84 return i;
86 i = cpool->count == 0 ? 1 : cpool->count;
87 set_constant_entry (cpool, i, tag, value);
88 return i;
91 /* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
93 int
94 find_constant2 (CPool *cpool, int tag, jword word1, jword word2)
96 int i;
97 for (i = cpool->count - 1; --i > 0; )
99 if (cpool->tags[i] == tag
100 && cpool->data[i].w == word1
101 && cpool->data[i+1].w == word2)
102 return i;
104 i = cpool->count == 0 ? 1 : cpool->count;
105 set_constant_entry (cpool, i, tag, word1);
106 set_constant_entry (cpool, i+1, 0, word2);
107 return i;
110 static int
111 find_tree_constant (CPool *cpool, int tag, tree value)
113 int i;
114 for (i = cpool->count; --i > 0; )
116 if (cpool->tags[i] == tag && cpool->data[i].t == value)
117 return i;
119 i = cpool->count == 0 ? 1 : cpool->count;
120 set_constant_entry (cpool, i, tag, 0);
121 cpool->data[i].t = value;
122 return i;
127 find_utf8_constant (CPool *cpool, tree name)
129 if (name == NULL_TREE)
130 return 0;
131 return find_tree_constant (cpool, CONSTANT_Utf8, name);
135 find_class_or_string_constant (CPool *cpool, int tag, tree name)
137 jword j = find_utf8_constant (cpool, name);
138 int i;
139 for (i = cpool->count; --i > 0; )
141 if (cpool->tags[i] == tag && cpool->data[i].w == j)
142 return i;
144 i = cpool->count;
145 set_constant_entry (cpool, i, tag, j);
146 return i;
150 find_class_constant (CPool *cpool, tree type)
152 return find_class_or_string_constant (cpool, CONSTANT_Class,
153 build_internal_class_name (type));
156 /* Allocate a CONSTANT_string entry given a STRING_CST. */
159 find_string_constant (CPool *cpool, tree string)
161 string = get_identifier (TREE_STRING_POINTER (string));
162 return find_class_or_string_constant (cpool, CONSTANT_String, string);
166 /* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
167 Return its index in the constant pool CPOOL. */
169 static int
170 find_name_and_type_constant (CPool *cpool, tree name, tree type)
172 int name_index = find_utf8_constant (cpool, name);
173 int type_index = find_utf8_constant (cpool, build_java_signature (type));
174 return find_constant1 (cpool, CONSTANT_NameAndType,
175 (name_index << 16) | type_index);
178 /* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL).
179 Return its index in the constant pool CPOOL. */
182 find_fieldref_index (CPool *cpool, tree decl)
184 int class_index = find_class_constant (cpool, DECL_CONTEXT (decl));
185 int name_type_index
186 = find_name_and_type_constant (cpool, DECL_NAME (decl), TREE_TYPE (decl));
187 return find_constant1 (cpool, CONSTANT_Fieldref,
188 (class_index << 16) | name_type_index);
191 /* Find (or create) a CONSTANT_Methodref for DECL (a FUNCTION_DECL).
192 Return its index in the constant pool CPOOL. */
195 find_methodref_index (CPool *cpool, tree decl)
197 return find_methodref_with_class_index (cpool, decl, DECL_CONTEXT (decl));
201 find_methodref_with_class_index (CPool *cpool, tree decl, tree mclass)
203 int class_index = find_class_constant (cpool, mclass);
204 tree name = DECL_CONSTRUCTOR_P (decl) ? init_identifier_node
205 : DECL_NAME (decl);
206 int name_type_index;
207 name_type_index =
208 find_name_and_type_constant (cpool, name, TREE_TYPE (decl));
209 return find_constant1 (cpool,
210 CLASS_INTERFACE (TYPE_NAME (mclass))
211 ? CONSTANT_InterfaceMethodref
212 : CONSTANT_Methodref,
213 (class_index << 16) | name_type_index);
216 #define PUT1(X) (*ptr++ = (X))
217 #define PUT2(X) (PUT1((X) >> 8), PUT1(X))
218 #define PUT4(X) (PUT2((X) >> 16), PUT2(X))
219 #define PUTN(P, N) (memcpy(ptr, (P), (N)), ptr += (N))
221 /* Give the number of bytes needed in a .class file for the CPOOL
222 constant pool. Includes the 2-byte constant_pool_count. */
225 count_constant_pool_bytes (CPool *cpool)
227 int size = 2;
228 int i = 1;
229 for ( ; i < cpool->count; i++)
231 size++;
232 switch (cpool->tags[i])
234 case CONSTANT_NameAndType:
235 case CONSTANT_Fieldref:
236 case CONSTANT_Methodref:
237 case CONSTANT_InterfaceMethodref:
238 case CONSTANT_Float:
239 case CONSTANT_Integer:
240 size += 4;
241 break;
242 case CONSTANT_Class:
243 case CONSTANT_String:
244 size += 2;
245 break;
246 case CONSTANT_Long:
247 case CONSTANT_Double:
248 size += 8;
249 i++;
250 break;
251 case CONSTANT_Utf8:
253 tree t = cpool->data[i].t;
254 int len = IDENTIFIER_LENGTH (t);
255 size += len + 2;
257 break;
258 default:
259 /* Second word of CONSTANT_Long and CONSTANT_Double. */
260 size--;
263 return size;
266 /* Write the constant pool CPOOL into BUFFER.
267 The length of BUFFER is LENGTH, which must match the needed length. */
269 void
270 write_constant_pool (CPool *cpool, unsigned char *buffer, int length)
272 unsigned char *ptr = buffer;
273 int i = 1;
274 union cpool_entry *datap = &cpool->data[1];
275 PUT2 (cpool->count);
276 for ( ; i < cpool->count; i++, datap++)
278 int tag = cpool->tags[i];
279 PUT1 (tag);
280 switch (tag)
282 case CONSTANT_NameAndType:
283 case CONSTANT_Fieldref:
284 case CONSTANT_Methodref:
285 case CONSTANT_InterfaceMethodref:
286 case CONSTANT_Float:
287 case CONSTANT_Integer:
288 PUT4 (datap->w);
289 break;
290 case CONSTANT_Class:
291 case CONSTANT_String:
292 PUT2 (datap->w);
293 break;
294 break;
295 case CONSTANT_Long:
296 case CONSTANT_Double:
297 PUT4(datap->w);
298 i++;
299 datap++;
300 PUT4 (datap->w);
301 break;
302 case CONSTANT_Utf8:
304 tree t = datap->t;
305 int len = IDENTIFIER_LENGTH (t);
306 PUT2 (len);
307 PUTN (IDENTIFIER_POINTER (t), len);
309 break;
313 gcc_assert (ptr == buffer + length);
316 static GTY(()) tree tag_nodes[13];
317 static tree
318 get_tag_node (int tag)
320 /* A Cache for build_int_cst (CONSTANT_XXX, 0). */
322 if (tag >= 13)
323 return build_int_cst (NULL_TREE, tag);
325 if (tag_nodes[tag] == NULL_TREE)
326 tag_nodes[tag] = build_int_cst (NULL_TREE, tag);
327 return tag_nodes[tag];
330 /* Given a class, return its constant pool, creating one if necessary. */
332 CPool *
333 cpool_for_class (tree klass)
335 CPool *cpool = TYPE_CPOOL (klass);
337 if (cpool == NULL)
339 cpool = ggc_cleared_alloc<CPool> ();
340 TYPE_CPOOL (klass) = cpool;
342 return cpool;
345 /* Look for a constant pool entry that matches TAG and NAME.
346 Creates a new entry if not found.
347 TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class.
348 NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class.
349 Returns the index of the entry. */
352 alloc_name_constant (int tag, tree name)
354 CPool *outgoing_cpool = cpool_for_class (output_class);
355 return find_tree_constant (outgoing_cpool, tag, name);
358 /* Create a constant pool entry for a name_and_type. This one has '.'
359 rather than '/' because it isn't going into a class file, it's
360 going into a compiled object. We don't use the '/' separator in
361 compiled objects. */
363 static int
364 find_name_and_type_constant_tree (CPool *cpool, tree name, tree type)
366 int name_index = find_utf8_constant (cpool, name);
367 int type_index
368 = find_utf8_constant (cpool,
369 identifier_subst (build_java_signature (type),
370 "", '/', '.', ""));
371 return find_constant1 (cpool, CONSTANT_NameAndType,
372 (name_index << 16) | type_index);
375 /* Look for a field ref that matches DECL in the constant pool of
376 KLASS.
377 Return the index of the entry. */
380 alloc_constant_fieldref (tree klass, tree decl)
382 CPool *outgoing_cpool = cpool_for_class (klass);
383 int class_index
384 = find_tree_constant (outgoing_cpool, CONSTANT_Class,
385 DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
386 int name_type_index
387 = find_name_and_type_constant_tree (outgoing_cpool, DECL_NAME (decl),
388 TREE_TYPE (decl));
389 return find_constant1 (outgoing_cpool, CONSTANT_Fieldref,
390 (class_index << 16) | name_type_index);
393 /* Build an identifier for the internal name of reference type TYPE. */
395 tree
396 build_internal_class_name (tree type)
398 tree name;
399 if (TYPE_ARRAY_P (type))
400 name = build_java_signature (type);
401 else
403 name = TYPE_NAME (type);
404 if (TREE_CODE (name) != IDENTIFIER_NODE)
405 name = DECL_NAME (name);
406 name = identifier_subst (name, "", '.', '/', "");
408 return name;
411 /* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */
414 alloc_class_constant (tree clas)
416 tree class_name = build_internal_class_name (clas);
418 return alloc_name_constant (CONSTANT_Class,
419 (unmangle_classname
420 (IDENTIFIER_POINTER(class_name),
421 IDENTIFIER_LENGTH(class_name))));
424 /* Return the decl of the data array of the current constant pool. */
426 tree
427 build_constant_data_ref (bool indirect)
429 if (indirect)
431 tree d;
432 tree cpool_type = build_array_type (ptr_type_node, NULL_TREE);
433 tree decl = build_class_ref (output_class);
434 tree klass = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (decl)),
435 decl);
436 tree constants = build3 (COMPONENT_REF,
437 TREE_TYPE (constants_field_decl_node), klass,
438 constants_field_decl_node,
439 NULL_TREE);
440 tree data = build3 (COMPONENT_REF,
441 TREE_TYPE (constants_data_field_decl_node),
442 constants,
443 constants_data_field_decl_node,
444 NULL_TREE);
446 TREE_THIS_NOTRAP (klass) = 1;
447 data = fold_convert (build_pointer_type (cpool_type), data);
448 d = build1 (INDIRECT_REF, cpool_type, data);
450 return d;
452 else
454 tree decl_name = mangled_classname ("_CD_", output_class);
455 tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
457 if (! decl)
459 /* Build a type with unspecified bounds. The will make sure
460 that targets do the right thing with whatever size we end
461 up with at the end. Using bounds that are too small risks
462 assuming the data is in the small data section. */
463 tree type = build_array_type (ptr_type_node, NULL_TREE);
465 /* We need to lay out the type ourselves, since build_array_type
466 thinks the type is incomplete. */
467 layout_type (type);
469 decl = build_decl (input_location, VAR_DECL, decl_name, type);
470 TREE_STATIC (decl) = 1;
471 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
474 return decl;
478 /* Get the pointer value at the INDEX'th element of the constant pool. */
480 tree
481 build_ref_from_constant_pool (int index)
483 tree i;
484 tree d = TYPE_CPOOL_DATA_REF (output_class);
486 if (d == NULL_TREE)
487 d = build_constant_data_ref (flag_indirect_classes);
489 i = build_int_cst (NULL_TREE, index);
490 d = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (d)), d, i,
491 NULL_TREE, NULL_TREE);
492 return d;
495 /* Build an initializer for the constants field of the current constant pool.
496 Should only be called at top-level, since it may emit declarations. */
498 tree
499 build_constants_constructor (void)
501 CPool *outgoing_cpool = cpool_for_class (current_class);
502 tree tags_value, data_value;
503 tree cons;
504 vec<constructor_elt, va_gc> *v = NULL;
505 int i;
506 vec<constructor_elt, va_gc> *tags = NULL;
507 vec<constructor_elt, va_gc> *data = NULL;
508 constructor_elt *t = NULL;
509 constructor_elt *d = NULL;
511 if (outgoing_cpool->count > 0)
513 int c = outgoing_cpool->count;
514 vec_safe_grow_cleared (tags, c);
515 vec_safe_grow_cleared (data, c);
516 t = &(*tags)[c-1];
517 d = &(*data)[c-1];
520 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
521 for (i = outgoing_cpool->count; --i > 0; )
522 switch (outgoing_cpool->tags[i] & ~CONSTANT_LazyFlag)
524 case CONSTANT_None: /* The second half of a Double or Long on a
525 32-bit target. */
526 case CONSTANT_Fieldref:
527 case CONSTANT_NameAndType:
528 case CONSTANT_Float:
529 case CONSTANT_Integer:
530 case CONSTANT_Double:
531 case CONSTANT_Long:
532 case CONSTANT_Methodref:
533 case CONSTANT_InterfaceMethodref:
535 unsigned HOST_WIDE_INT temp = outgoing_cpool->data[i].w;
537 /* Make sure that on a big-endian machine with 64-bit
538 pointers this 32-bit jint appears in the first word.
539 FIXME: This is a kludge. The field we're initializing is
540 not a scalar but a union, and that's how we should
541 represent it in the compiler. We should fix this. */
542 if (BYTES_BIG_ENDIAN)
543 temp <<= ((POINTER_SIZE > 32) ? POINTER_SIZE - 32 : 0);
545 CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i]));
546 CONSTRUCTOR_PREPEND_VALUE (d, build_int_cst (ptr_type_node, temp));
548 break;
550 case CONSTANT_Class:
551 case CONSTANT_String:
552 case CONSTANT_Unicode:
553 case CONSTANT_Utf8:
554 CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i]));
555 CONSTRUCTOR_PREPEND_VALUE (d, build_utf8_ref (outgoing_cpool->data[i].t));
556 break;
558 default:
559 gcc_assert (false);
561 #undef CONSTRUCTOR_PREPEND_VALUE
563 if (outgoing_cpool->count > 0)
565 tree data_decl, tags_decl, tags_type;
566 tree max_index = build_int_cst (sizetype, outgoing_cpool->count - 1);
567 tree index_type = build_index_type (max_index);
568 tree tem;
570 /* Add dummy 0'th element of constant pool. */
571 gcc_assert (t == tags->address ());
572 gcc_assert (d == data->address ());
573 t->value = get_tag_node (0);
574 d->value = null_pointer_node;
576 /* Change the type of the decl to have the proper array size.
577 ??? Make sure to transition the old type-pointer-to list to this
578 new type to not invalidate all build address expressions. */
579 data_decl = build_constant_data_ref (false);
580 tem = TYPE_POINTER_TO (TREE_TYPE (data_decl));
581 if (!tem)
582 tem = build_pointer_type (TREE_TYPE (data_decl));
583 TYPE_POINTER_TO (TREE_TYPE (data_decl)) = NULL_TREE;
584 TREE_TYPE (data_decl) = build_array_type (ptr_type_node, index_type);
585 TYPE_POINTER_TO (TREE_TYPE (data_decl)) = tem;
586 DECL_INITIAL (data_decl) = build_constructor (TREE_TYPE (data_decl), data);
587 DECL_SIZE (data_decl) = TYPE_SIZE (TREE_TYPE (data_decl));
588 DECL_SIZE_UNIT (data_decl) = TYPE_SIZE_UNIT (TREE_TYPE (data_decl));
589 rest_of_decl_compilation (data_decl, 1, 0);
590 data_value = build_address_of (data_decl);
592 tags_type = build_array_type (unsigned_byte_type_node, index_type);
593 tags_decl = build_decl (input_location,
594 VAR_DECL, mangled_classname ("_CT_",
595 current_class),
596 tags_type);
597 TREE_STATIC (tags_decl) = 1;
598 DECL_INITIAL (tags_decl) = build_constructor (tags_type, tags);
599 rest_of_decl_compilation (tags_decl, 1, 0);
600 tags_value = build_address_of (tags_decl);
602 else
604 data_value = null_pointer_node;
605 tags_value = null_pointer_node;
607 START_RECORD_CONSTRUCTOR (v, constants_type_node);
608 PUSH_FIELD_VALUE (v, "size",
609 build_int_cst (NULL_TREE, outgoing_cpool->count));
610 PUSH_FIELD_VALUE (v, "tags", tags_value);
611 PUSH_FIELD_VALUE (v, "data", data_value);
612 FINISH_RECORD_CONSTRUCTOR (cons, v, constants_type_node);
613 return cons;
616 #include "gt-java-constants.h"