1 /* Handle the constant pool of the Java(TM) Virtual Machine.
2 Copyright (C) 1997, 98-99, 2000 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"
31 extern struct obstack permanent_obstack
;
33 static void set_constant_entry
PARAMS ((CPool
*, int, int, jword
));
34 static int find_class_or_string_constant
PARAMS ((CPool
*, int, tree
));
35 static int find_name_and_type_constant
PARAMS ((CPool
*, tree
, tree
));
36 static tree get_tag_node
PARAMS ((int));
37 static tree build_constant_data_ref
PARAMS ((void));
39 /* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */
42 set_constant_entry (cpool
, index
, tag
, value
)
48 if (cpool
->data
== NULL
)
50 cpool
->capacity
= 100;
51 cpool
->tags
= (uint8
*) xmalloc (sizeof(uint8
) * cpool
->capacity
);
52 cpool
->data
= (jword
*) xmalloc (sizeof(jword
) * cpool
->capacity
);
55 if (index
>= cpool
->capacity
)
58 if (index
>= cpool
->capacity
)
59 cpool
->capacity
= index
+ 10;
60 cpool
->tags
= (uint8
*) xrealloc (cpool
->tags
,
61 sizeof(uint8
) * cpool
->capacity
);
62 cpool
->data
= (jword
*) xrealloc (cpool
->data
,
63 sizeof(jword
) * cpool
->capacity
);
65 if (index
>= cpool
->count
)
66 cpool
->count
= index
+ 1;
67 cpool
->tags
[index
] = tag
;
68 cpool
->data
[index
] = value
;
71 /* Find (or create) a constant pool entry matching TAG and VALUE. */
74 find_constant1 (cpool
, tag
, value
)
80 for (i
= cpool
->count
; --i
> 0; )
82 if (cpool
->tags
[i
] == tag
&& cpool
->data
[i
] == value
)
85 i
= cpool
->count
== 0 ? 1 : cpool
->count
;
86 set_constant_entry (cpool
, i
, tag
, value
);
90 /* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
93 find_constant2 (cpool
, tag
, word1
, word2
)
99 for (i
= cpool
->count
- 1; --i
> 0; )
101 if (cpool
->tags
[i
] == tag
102 && cpool
->data
[i
] == word1
103 && cpool
->data
[i
+1] == word2
)
106 i
= cpool
->count
== 0 ? 1 : cpool
->count
;
107 set_constant_entry (cpool
, i
, tag
, word1
);
108 set_constant_entry (cpool
, i
+1, 0, word2
);
113 find_utf8_constant (cpool
, name
)
117 if (name
== NULL_TREE
)
119 return find_constant1 (cpool
, CONSTANT_Utf8
, (jword
) name
);
123 find_class_or_string_constant (cpool
, tag
, name
)
128 int j
= find_utf8_constant (cpool
, name
);
130 for (i
= cpool
->count
; --i
> 0; )
132 if (cpool
->tags
[i
] == tag
&& cpool
->data
[i
] == (jword
) j
)
136 set_constant_entry (cpool
, i
, tag
, (jword
) j
);
141 find_class_constant (cpool
, type
)
145 return find_class_or_string_constant (cpool
, CONSTANT_Class
,
146 build_internal_class_name (type
));
149 /* Allocate a CONSTANT_string entry given a STRING_CST. */
152 find_string_constant (cpool
, string
)
156 string
= get_identifier (TREE_STRING_POINTER (string
));
157 return find_class_or_string_constant (cpool
, CONSTANT_String
, string
);
161 /* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
162 Return its index in the constant pool CPOOL. */
165 find_name_and_type_constant (cpool
, name
, type
)
170 int name_index
= find_utf8_constant (cpool
, name
);
171 int type_index
= find_utf8_constant (cpool
, build_java_signature (type
));
172 return find_constant1 (cpool
, CONSTANT_NameAndType
,
173 (name_index
<< 16) | type_index
);
176 /* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL).
177 Return its index in the constant pool CPOOL. */
180 find_fieldref_index (cpool
, decl
)
184 int class_index
= find_class_constant (cpool
, DECL_CONTEXT (decl
));
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
, decl
)
199 tree mclass
= DECL_CONTEXT (decl
);
200 int class_index
= find_class_constant (cpool
, mclass
);
201 tree name
= DECL_CONSTRUCTOR_P (decl
) ? init_identifier_node
204 if (TREE_CODE (name
) == EXPR_WITH_FILE_LOCATION
)
205 name
= EXPR_WFL_NODE (name
);
207 find_name_and_type_constant (cpool
, name
, TREE_TYPE (decl
));
208 return find_constant1 (cpool
,
209 CLASS_INTERFACE (TYPE_NAME (mclass
))
210 ? CONSTANT_InterfaceMethodref
211 : CONSTANT_Methodref
,
212 (class_index
<< 16) | name_type_index
);
215 #define PUT1(X) (*ptr++ = (X))
216 #define PUT2(X) (PUT1((X) >> 8), PUT1(X))
217 #define PUT4(X) (PUT2((X) >> 16), PUT2(X))
218 #define PUTN(P, N) (bcopy(P, ptr, N), ptr += (N))
220 /* Give the number of bytes needed in a .class file for the CPOOL
221 constant pool. Includes the 2-byte constant_pool_count. */
224 count_constant_pool_bytes (cpool
)
229 for ( ; i
< cpool
->count
; i
++)
232 switch (cpool
->tags
[i
])
234 case CONSTANT_NameAndType
:
235 case CONSTANT_Fieldref
:
236 case CONSTANT_Methodref
:
237 case CONSTANT_InterfaceMethodref
:
239 case CONSTANT_Integer
:
243 case CONSTANT_String
:
247 case CONSTANT_Double
:
253 tree t
= (tree
) cpool
->data
[i
];
254 int len
= IDENTIFIER_LENGTH (t
);
259 /* Second word of CONSTANT_Long and CONSTANT_Double. */
266 /* Write the constant pool CPOOL into BUFFER.
267 The length of BUFFER is LENGTH, which must match the needed length. */
270 write_constant_pool (cpool
, buffer
, length
)
272 unsigned char* buffer
;
275 unsigned char* ptr
= buffer
;
277 jword
*datap
= &cpool
->data
[1];
279 for ( ; i
< cpool
->count
; i
++, datap
++)
281 int tag
= cpool
->tags
[i
];
285 case CONSTANT_NameAndType
:
286 case CONSTANT_Fieldref
:
287 case CONSTANT_Methodref
:
288 case CONSTANT_InterfaceMethodref
:
290 case CONSTANT_Integer
:
294 case CONSTANT_String
:
299 case CONSTANT_Double
:
307 tree t
= (tree
) *datap
;
308 int len
= IDENTIFIER_LENGTH (t
);
310 PUTN (IDENTIFIER_POINTER (t
), len
);
315 if (ptr
!= buffer
+ length
)
316 fatal("internal error - incorrect constant pool");
319 CPool
*outgoing_cpool
;
321 /* If non-NULL, an ADDR_EXPR referencing a VAR_DECL containing
322 the constant data array for the current class. */
323 tree current_constant_pool_data_ref
;
325 /* A Cache for build_int_2 (CONSTANT_XXX, 0). */
326 static tree tag_nodes
[13];
332 if (tag_nodes
[tag
] == NULL_TREE
)
334 push_obstacks (&permanent_obstack
, &permanent_obstack
);
335 tag_nodes
[tag
] = build_int_2 (tag
, 0);
338 return tag_nodes
[tag
];
341 /* Look for a constant pool entry that matches TAG and NAME.
342 Creates a new entry if not found.
343 TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class.
344 NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class.
345 Returns the index of the entry. */
348 alloc_name_constant (tag
, name
)
352 return find_constant1 (outgoing_cpool
, tag
, (jword
) name
);
355 /* Build an identifier for the internal name of reference type TYPE. */
358 build_internal_class_name (type
)
362 if (TYPE_ARRAY_P (type
))
363 name
= build_java_signature (type
);
366 name
= TYPE_NAME (type
);
367 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
368 name
= DECL_NAME (name
);
369 name
= identifier_subst (name
, "", '.', '/', "");
374 /* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */
377 alloc_class_constant (clas
)
380 tree class_name
= build_internal_class_name (clas
);
382 return alloc_name_constant (CONSTANT_Class
,
384 (IDENTIFIER_POINTER(class_name
),
385 IDENTIFIER_LENGTH(class_name
))));
388 /* Return a reference to the data array of the current constant pool. */
391 build_constant_data_ref ()
393 if (current_constant_pool_data_ref
== NULL_TREE
)
396 tree decl_name
= mangled_classname ("_CD_", current_class
);
397 push_obstacks (&permanent_obstack
, &permanent_obstack
);
398 decl
= build_decl (VAR_DECL
, decl_name
,
399 build_array_type (ptr_type_node
,
400 one_elt_array_domain_type
));
401 TREE_STATIC (decl
) = 1;
402 make_decl_rtl (decl
, NULL
, 1);
404 current_constant_pool_data_ref
405 = build1 (ADDR_EXPR
, ptr_type_node
, decl
);
407 return current_constant_pool_data_ref
;
410 /* Get the pointer value at the INDEX'th element of the constant pool. */
413 build_ref_from_constant_pool (index
)
416 tree t
= build_constant_data_ref ();
417 index
*= int_size_in_bytes (ptr_type_node
);
418 t
= fold (build (PLUS_EXPR
, ptr_type_node
,
419 t
, build_int_2 (index
, 0)));
420 return build1 (INDIRECT_REF
, ptr_type_node
, t
);
423 /* Build an initializer for the constants field of the current constal pool.
424 Should only be called at top-level, since it may emit declarations. */
427 build_constants_constructor ()
429 tree tags_value
, data_value
;
431 tree tags_list
= NULL_TREE
;
432 tree data_list
= NULL_TREE
;
434 for (i
= outgoing_cpool
->count
; --i
> 0; )
437 = tree_cons (NULL_TREE
, get_tag_node (outgoing_cpool
->tags
[i
]),
440 = tree_cons (NULL_TREE
, build_utf8_ref ((tree
)outgoing_cpool
->data
[i
]),
443 if (outgoing_cpool
->count
> 0)
446 tree data_decl
, tags_decl
, tags_type
;
447 tree max_index
= build_int_2 (outgoing_cpool
->count
- 1, 0);
448 TREE_TYPE (max_index
) = sizetype
;
449 index_type
= build_index_type (max_index
);
451 /* Add dummy 0'th element of constant pool. */
452 tags_list
= tree_cons (NULL_TREE
, get_tag_node (0), tags_list
);
453 data_list
= tree_cons (NULL_TREE
, null_pointer_node
, data_list
);
455 data_decl
= TREE_OPERAND (build_constant_data_ref (), 0);
456 TREE_TYPE (data_decl
) = build_array_type (ptr_type_node
, index_type
),
457 DECL_INITIAL (data_decl
) = build (CONSTRUCTOR
, TREE_TYPE (data_decl
),
458 NULL_TREE
, data_list
);
459 DECL_SIZE (data_decl
) = TYPE_SIZE (TREE_TYPE (data_decl
));
460 rest_of_decl_compilation (data_decl
, (char*) 0, 1, 0);
461 data_value
= build_address_of (data_decl
);
463 tags_type
= build_array_type (unsigned_byte_type_node
, index_type
);
464 tags_decl
= build_decl (VAR_DECL
, mangled_classname ("_CT_",
467 TREE_STATIC (tags_decl
) = 1;
468 DECL_INITIAL (tags_decl
) = build (CONSTRUCTOR
, tags_type
,
469 NULL_TREE
, tags_list
);
470 rest_of_decl_compilation (tags_decl
, (char*) 0, 1, 0);
471 tags_value
= build_address_of (tags_decl
);
475 data_value
= null_pointer_node
;
476 tags_value
= null_pointer_node
;
478 START_RECORD_CONSTRUCTOR (cons
, constants_type_node
);
479 PUSH_FIELD_VALUE (cons
, "size", build_int_2 (outgoing_cpool
->count
, 0));
480 PUSH_FIELD_VALUE (cons
, "tags", tags_value
);
481 PUSH_FIELD_VALUE (cons
, "data", data_value
);
482 FINISH_RECORD_CONSTRUCTOR (cons
);