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)
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. */
26 #include "coretypes.h"
30 #include "java-tree.h"
31 #include "diagnostic-core.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. */
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
)
50 cpool
->data
= ggc_alloc_cleared_vec_cpool_entry (sizeof
55 if (index
>= cpool
->capacity
)
57 int old_cap
= cpool
->capacity
;
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
,
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. */
79 find_constant1 (CPool
*cpool
, int tag
, jword value
)
82 for (i
= cpool
->count
; --i
> 0; )
84 if (cpool
->tags
[i
] == tag
&& cpool
->data
[i
].w
== value
)
87 i
= cpool
->count
== 0 ? 1 : cpool
->count
;
88 set_constant_entry (cpool
, i
, tag
, value
);
92 /* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
95 find_constant2 (CPool
*cpool
, int tag
, jword word1
, jword word2
)
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
)
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
);
112 find_tree_constant (CPool
*cpool
, int tag
, tree value
)
115 for (i
= cpool
->count
; --i
> 0; )
117 if (cpool
->tags
[i
] == tag
&& cpool
->data
[i
].t
== value
)
120 i
= cpool
->count
== 0 ? 1 : cpool
->count
;
121 set_constant_entry (cpool
, i
, tag
, 0);
122 cpool
->data
[i
].t
= value
;
128 find_utf8_constant (CPool
*cpool
, tree name
)
130 if (name
== NULL_TREE
)
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
);
140 for (i
= cpool
->count
; --i
> 0; )
142 if (cpool
->tags
[i
] == tag
&& cpool
->data
[i
].w
== j
)
146 set_constant_entry (cpool
, i
, tag
, j
);
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. */
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
));
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
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
)
230 for ( ; i
< cpool
->count
; i
++)
233 switch (cpool
->tags
[i
])
235 case CONSTANT_NameAndType
:
236 case CONSTANT_Fieldref
:
237 case CONSTANT_Methodref
:
238 case CONSTANT_InterfaceMethodref
:
240 case CONSTANT_Integer
:
244 case CONSTANT_String
:
248 case CONSTANT_Double
:
254 tree t
= cpool
->data
[i
].t
;
255 int len
= IDENTIFIER_LENGTH (t
);
260 /* Second word of CONSTANT_Long and CONSTANT_Double. */
267 /* Write the constant pool CPOOL into BUFFER.
268 The length of BUFFER is LENGTH, which must match the needed length. */
271 write_constant_pool (CPool
*cpool
, unsigned char *buffer
, int length
)
273 unsigned char *ptr
= buffer
;
275 union cpool_entry
*datap
= &cpool
->data
[1];
277 for ( ; i
< cpool
->count
; i
++, datap
++)
279 int tag
= cpool
->tags
[i
];
283 case CONSTANT_NameAndType
:
284 case CONSTANT_Fieldref
:
285 case CONSTANT_Methodref
:
286 case CONSTANT_InterfaceMethodref
:
288 case CONSTANT_Integer
:
292 case CONSTANT_String
:
297 case CONSTANT_Double
:
306 int len
= IDENTIFIER_LENGTH (t
);
308 PUTN (IDENTIFIER_POINTER (t
), len
);
314 gcc_assert (ptr
== buffer
+ length
);
317 static GTY(()) tree tag_nodes
[13];
319 get_tag_node (int tag
)
321 /* A Cache for build_int_cst (CONSTANT_XXX, 0). */
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. */
334 cpool_for_class (tree klass
)
336 CPool
*cpool
= TYPE_CPOOL (klass
);
340 cpool
= ggc_alloc_cleared_CPool ();
341 TYPE_CPOOL (klass
) = 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
365 find_name_and_type_constant_tree (CPool
*cpool
, tree name
, tree type
)
367 int name_index
= find_utf8_constant (cpool
, name
);
369 = find_utf8_constant (cpool
,
370 identifier_subst (build_java_signature (type
),
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
378 Return the index of the entry. */
381 alloc_constant_fieldref (tree klass
, tree decl
)
383 CPool
*outgoing_cpool
= cpool_for_class (klass
);
385 = find_tree_constant (outgoing_cpool
, CONSTANT_Class
,
386 DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
388 = find_name_and_type_constant_tree (outgoing_cpool
, DECL_NAME (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. */
397 build_internal_class_name (tree type
)
400 if (TYPE_ARRAY_P (type
))
401 name
= build_java_signature (type
);
404 name
= TYPE_NAME (type
);
405 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
406 name
= DECL_NAME (name
);
407 name
= identifier_subst (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
,
421 (IDENTIFIER_POINTER(class_name
),
422 IDENTIFIER_LENGTH(class_name
))));
425 /* Return the decl of the data array of the current constant pool. */
428 build_constant_data_ref (bool indirect
)
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
)),
437 tree constants
= build3 (COMPONENT_REF
,
438 TREE_TYPE (constants_field_decl_node
), klass
,
439 constants_field_decl_node
,
441 tree data
= build3 (COMPONENT_REF
,
442 TREE_TYPE (constants_data_field_decl_node
),
444 constants_data_field_decl_node
,
447 TREE_THIS_NOTRAP (klass
) = 1;
448 data
= fold_convert (build_pointer_type (cpool_type
), data
);
449 d
= build1 (INDIRECT_REF
, cpool_type
, data
);
455 tree decl_name
= mangled_classname ("_CD_", output_class
);
456 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
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. */
470 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, type
);
471 TREE_STATIC (decl
) = 1;
472 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
479 /* Get the pointer value at the INDEX'th element of the constant pool. */
482 build_ref_from_constant_pool (int index
)
485 tree d
= TYPE_CPOOL_DATA_REF (output_class
);
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
);
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. */
500 build_constants_constructor (void)
502 CPool
*outgoing_cpool
= cpool_for_class (current_class
);
503 tree tags_value
, data_value
;
505 VEC(constructor_elt
,gc
) *v
= NULL
;
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
527 case CONSTANT_Fieldref
:
528 case CONSTANT_NameAndType
:
530 case CONSTANT_Integer
:
531 case CONSTANT_Double
:
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
));
552 case CONSTANT_String
:
553 case CONSTANT_Unicode
:
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
));
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
);
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
));
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_",
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
);
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
);
617 #include "gt-java-constants.h"