1 /* Handle the constant pool of the Java(TM) Virtual Machine.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC 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 2, or (at your option)
11 GNU CC 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 GNU CC; see the file COPYING. If not, write to
17 the Free Software Foundation, 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
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. */
28 #include "java-tree.h"
32 extern struct obstack permanent_obstack;
34 static void set_constant_entry PARAMS ((CPool *, int, int, jword));
35 static int find_class_or_string_constant PARAMS ((CPool *, int, tree));
36 static int find_name_and_type_constant PARAMS ((CPool *, tree, tree));
37 static tree get_tag_node PARAMS ((int));
38 static tree build_constant_data_ref PARAMS ((void));
40 /* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */
43 set_constant_entry (cpool, index, tag, value)
49 if (cpool->data == NULL)
51 cpool->capacity = 100;
52 cpool->tags = (uint8*) xmalloc (sizeof(uint8) * cpool->capacity);
53 cpool->data = (jword*) xmalloc (sizeof(jword) * cpool->capacity);
56 if (index >= cpool->capacity)
59 if (index >= cpool->capacity)
60 cpool->capacity = index + 10;
61 cpool->tags = (uint8*) xrealloc (cpool->tags,
62 sizeof(uint8) * cpool->capacity);
63 cpool->data = (jword*) xrealloc (cpool->data,
64 sizeof(jword) * cpool->capacity);
66 if (index >= cpool->count)
67 cpool->count = index + 1;
68 cpool->tags[index] = tag;
69 cpool->data[index] = value;
72 /* Find (or create) a constant pool entry matching TAG and VALUE. */
75 find_constant1 (cpool, tag, value)
81 for (i = cpool->count; --i > 0; )
83 if (cpool->tags[i] == tag && cpool->data[i] == value)
86 i = cpool->count == 0 ? 1 : cpool->count;
87 set_constant_entry (cpool, i, tag, value);
91 /* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
94 find_constant2 (cpool, tag, word1, word2)
100 for (i = cpool->count - 1; --i > 0; )
102 if (cpool->tags[i] == tag
103 && cpool->data[i] == word1
104 && cpool->data[i+1] == word2)
107 i = cpool->count == 0 ? 1 : cpool->count;
108 set_constant_entry (cpool, i, tag, word1);
109 set_constant_entry (cpool, i+1, 0, word2);
114 find_utf8_constant (cpool, name)
118 if (name == NULL_TREE)
120 return find_constant1 (cpool, CONSTANT_Utf8, (jword) name);
124 find_class_or_string_constant (cpool, tag, name)
129 int j = find_utf8_constant (cpool, name);
131 for (i = cpool->count; --i > 0; )
133 if (cpool->tags[i] == tag && cpool->data[i] == (jword) j)
137 set_constant_entry (cpool, i, tag, (jword) j);
142 find_class_constant (cpool, type)
146 return find_class_or_string_constant (cpool, CONSTANT_Class,
147 build_internal_class_name (type));
150 /* Allocate a CONSTANT_string entry given a STRING_CST. */
153 find_string_constant (cpool, string)
157 string = get_identifier (TREE_STRING_POINTER (string));
158 return find_class_or_string_constant (cpool, CONSTANT_String, string);
162 /* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
163 Return its index in the constant pool CPOOL. */
166 find_name_and_type_constant (cpool, name, type)
171 int name_index = find_utf8_constant (cpool, name);
172 int type_index = find_utf8_constant (cpool, build_java_signature (type));
173 return find_constant1 (cpool, CONSTANT_NameAndType,
174 (name_index << 16) | type_index);
177 /* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL).
178 Return its index in the constant pool CPOOL. */
181 find_fieldref_index (cpool, 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, decl)
200 return find_methodref_with_class_index (cpool, decl, DECL_CONTEXT (decl));
204 find_methodref_with_class_index (cpool, decl, mclass)
209 int class_index = find_class_constant (cpool, mclass);
210 tree name = DECL_CONSTRUCTOR_P (decl) ? init_identifier_node
214 find_name_and_type_constant (cpool, name, TREE_TYPE (decl));
215 return find_constant1 (cpool,
216 CLASS_INTERFACE (TYPE_NAME (mclass))
217 ? CONSTANT_InterfaceMethodref
218 : CONSTANT_Methodref,
219 (class_index << 16) | name_type_index);
222 #define PUT1(X) (*ptr++ = (X))
223 #define PUT2(X) (PUT1((X) >> 8), PUT1(X))
224 #define PUT4(X) (PUT2((X) >> 16), PUT2(X))
225 #define PUTN(P, N) (memcpy(ptr, (P), (N)), ptr += (N))
227 /* Give the number of bytes needed in a .class file for the CPOOL
228 constant pool. Includes the 2-byte constant_pool_count. */
231 count_constant_pool_bytes (cpool)
236 for ( ; i < cpool->count; i++)
239 switch (cpool->tags[i])
241 case CONSTANT_NameAndType:
242 case CONSTANT_Fieldref:
243 case CONSTANT_Methodref:
244 case CONSTANT_InterfaceMethodref:
246 case CONSTANT_Integer:
250 case CONSTANT_String:
254 case CONSTANT_Double:
260 tree t = (tree) cpool->data[i];
261 int len = IDENTIFIER_LENGTH (t);
266 /* Second word of CONSTANT_Long and CONSTANT_Double. */
273 /* Write the constant pool CPOOL into BUFFER.
274 The length of BUFFER is LENGTH, which must match the needed length. */
277 write_constant_pool (cpool, buffer, length)
279 unsigned char *buffer;
282 unsigned char *ptr = buffer;
284 jword *datap = &cpool->data[1];
286 for ( ; i < cpool->count; i++, datap++)
288 int tag = cpool->tags[i];
292 case CONSTANT_NameAndType:
293 case CONSTANT_Fieldref:
294 case CONSTANT_Methodref:
295 case CONSTANT_InterfaceMethodref:
297 case CONSTANT_Integer:
301 case CONSTANT_String:
306 case CONSTANT_Double:
314 tree t = (tree) *datap;
315 int len = IDENTIFIER_LENGTH (t);
317 PUTN (IDENTIFIER_POINTER (t), len);
323 if (ptr != buffer + length)
327 CPool *outgoing_cpool;
333 /* A Cache for build_int_2 (CONSTANT_XXX, 0). */
334 static tree tag_nodes[13];
335 static int initialized_p;
337 /* Register the TAG_NODES with the garbage collector. */
340 ggc_add_tree_root (tag_nodes, 13);
344 if (tag_nodes[tag] == NULL_TREE)
345 tag_nodes[tag] = build_int_2 (tag, 0);
346 return tag_nodes[tag];
349 /* Look for a constant pool entry that matches TAG and NAME.
350 Creates a new entry if not found.
351 TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class.
352 NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class.
353 Returns the index of the entry. */
356 alloc_name_constant (tag, name)
360 return find_constant1 (outgoing_cpool, tag, (jword) name);
363 /* Build an identifier for the internal name of reference type TYPE. */
366 build_internal_class_name (type)
370 if (TYPE_ARRAY_P (type))
371 name = build_java_signature (type);
374 name = TYPE_NAME (type);
375 if (TREE_CODE (name) != IDENTIFIER_NODE)
376 name = DECL_NAME (name);
377 name = identifier_subst (name, "", '.', '/', "");
382 /* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */
385 alloc_class_constant (clas)
388 tree class_name = build_internal_class_name (clas);
390 return alloc_name_constant (CONSTANT_Class,
392 (IDENTIFIER_POINTER(class_name),
393 IDENTIFIER_LENGTH(class_name))));
396 /* Return a reference to the data array of the current constant pool. */
399 build_constant_data_ref ()
401 if (TYPE_CPOOL_DATA_REF (current_class))
402 current_constant_pool_data_ref = TYPE_CPOOL_DATA_REF (current_class);
404 else if (current_constant_pool_data_ref == NULL_TREE)
407 tree decl_name = mangled_classname ("_CD_", current_class);
408 decl = build_decl (VAR_DECL, decl_name,
409 build_array_type (ptr_type_node,
410 one_elt_array_domain_type));
411 TREE_STATIC (decl) = 1;
412 make_decl_rtl (decl, NULL);
413 TYPE_CPOOL_DATA_REF (current_class) = current_constant_pool_data_ref
414 = build1 (ADDR_EXPR, ptr_type_node, decl);
416 return current_constant_pool_data_ref;
419 /* Get the pointer value at the INDEX'th element of the constant pool. */
422 build_ref_from_constant_pool (index)
425 tree t = build_constant_data_ref ();
426 index *= int_size_in_bytes (ptr_type_node);
427 t = fold (build (PLUS_EXPR, ptr_type_node,
428 t, build_int_2 (index, 0)));
429 return build1 (INDIRECT_REF, ptr_type_node, t);
432 /* Build an initializer for the constants field of the current constal pool.
433 Should only be called at top-level, since it may emit declarations. */
436 build_constants_constructor ()
438 tree tags_value, data_value;
440 tree tags_list = NULL_TREE;
441 tree data_list = NULL_TREE;
443 for (i = outgoing_cpool->count; --i > 0; )
446 = tree_cons (NULL_TREE, get_tag_node (outgoing_cpool->tags[i]),
449 = tree_cons (NULL_TREE, build_utf8_ref ((tree)outgoing_cpool->data[i]),
452 if (outgoing_cpool->count > 0)
455 tree data_decl, tags_decl, tags_type;
456 tree max_index = build_int_2 (outgoing_cpool->count - 1, 0);
457 TREE_TYPE (max_index) = sizetype;
458 index_type = build_index_type (max_index);
460 /* Add dummy 0'th element of constant pool. */
461 tags_list = tree_cons (NULL_TREE, get_tag_node (0), tags_list);
462 data_list = tree_cons (NULL_TREE, null_pointer_node, data_list);
464 data_decl = TREE_OPERAND (build_constant_data_ref (), 0);
465 TREE_TYPE (data_decl) = build_array_type (ptr_type_node, index_type),
466 DECL_INITIAL (data_decl) = build (CONSTRUCTOR, TREE_TYPE (data_decl),
467 NULL_TREE, data_list);
468 DECL_SIZE (data_decl) = TYPE_SIZE (TREE_TYPE (data_decl));
469 DECL_SIZE_UNIT (data_decl) = TYPE_SIZE_UNIT (TREE_TYPE (data_decl));
470 rest_of_decl_compilation (data_decl, (char *) 0, 1, 0);
471 data_value = build_address_of (data_decl);
473 tags_type = build_array_type (unsigned_byte_type_node, index_type);
474 tags_decl = build_decl (VAR_DECL, mangled_classname ("_CT_",
477 TREE_STATIC (tags_decl) = 1;
478 DECL_INITIAL (tags_decl) = build (CONSTRUCTOR, tags_type,
479 NULL_TREE, tags_list);
480 rest_of_decl_compilation (tags_decl, (char*) 0, 1, 0);
481 tags_value = build_address_of (tags_decl);
485 data_value = null_pointer_node;
486 tags_value = null_pointer_node;
488 START_RECORD_CONSTRUCTOR (cons, constants_type_node);
489 PUSH_FIELD_VALUE (cons, "size", build_int_2 (outgoing_cpool->count, 0));
490 PUSH_FIELD_VALUE (cons, "tags", tags_value);
491 PUSH_FIELD_VALUE (cons, "data", data_value);
492 FINISH_RECORD_CONSTRUCTOR (cons);