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. */
26 #include "coretypes.h"
30 #include "java-tree.h"
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
= xmalloc (sizeof(uint8
) * cpool
->capacity
);
53 cpool
->data
= xmalloc (sizeof(jword
) * cpool
->capacity
);
56 if (index
>= cpool
->capacity
)
59 if (index
>= cpool
->capacity
)
60 cpool
->capacity
= index
+ 10;
61 cpool
->tags
= xrealloc (cpool
->tags
, sizeof(uint8
) * cpool
->capacity
);
62 cpool
->data
= xrealloc (cpool
->data
, sizeof(jword
) * cpool
->capacity
);
64 if (index
>= cpool
->count
)
65 cpool
->count
= index
+ 1;
66 cpool
->tags
[index
] = tag
;
67 cpool
->data
[index
] = value
;
70 /* Find (or create) a constant pool entry matching TAG and VALUE. */
73 find_constant1 (cpool
, tag
, value
)
79 for (i
= cpool
->count
; --i
> 0; )
81 if (cpool
->tags
[i
] == tag
&& cpool
->data
[i
] == value
)
84 i
= cpool
->count
== 0 ? 1 : cpool
->count
;
85 set_constant_entry (cpool
, i
, tag
, value
);
89 /* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
92 find_constant2 (cpool
, tag
, word1
, word2
)
98 for (i
= cpool
->count
- 1; --i
> 0; )
100 if (cpool
->tags
[i
] == tag
101 && cpool
->data
[i
] == word1
102 && cpool
->data
[i
+1] == 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_utf8_constant (cpool
, name
)
116 if (name
== NULL_TREE
)
118 return find_constant1 (cpool
, CONSTANT_Utf8
, (jword
) name
);
122 find_class_or_string_constant (cpool
, tag
, name
)
127 int j
= find_utf8_constant (cpool
, name
);
129 for (i
= cpool
->count
; --i
> 0; )
131 if (cpool
->tags
[i
] == tag
&& cpool
->data
[i
] == (jword
) j
)
135 set_constant_entry (cpool
, i
, tag
, (jword
) j
);
140 find_class_constant (cpool
, type
)
144 return find_class_or_string_constant (cpool
, CONSTANT_Class
,
145 build_internal_class_name (type
));
148 /* Allocate a CONSTANT_string entry given a STRING_CST. */
151 find_string_constant (cpool
, string
)
155 string
= get_identifier (TREE_STRING_POINTER (string
));
156 return find_class_or_string_constant (cpool
, CONSTANT_String
, string
);
160 /* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
161 Return its index in the constant pool CPOOL. */
164 find_name_and_type_constant (cpool
, name
, type
)
169 int name_index
= find_utf8_constant (cpool
, name
);
170 int type_index
= find_utf8_constant (cpool
, build_java_signature (type
));
171 return find_constant1 (cpool
, CONSTANT_NameAndType
,
172 (name_index
<< 16) | type_index
);
175 /* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL).
176 Return its index in the constant pool CPOOL. */
179 find_fieldref_index (cpool
, decl
)
183 int class_index
= find_class_constant (cpool
, DECL_CONTEXT (decl
));
185 = find_name_and_type_constant (cpool
, DECL_NAME (decl
), TREE_TYPE (decl
));
186 return find_constant1 (cpool
, CONSTANT_Fieldref
,
187 (class_index
<< 16) | name_type_index
);
190 /* Find (or create) a CONSTANT_Methodref for DECL (a FUNCTION_DECL).
191 Return its index in the constant pool CPOOL. */
194 find_methodref_index (cpool
, decl
)
198 return find_methodref_with_class_index (cpool
, decl
, DECL_CONTEXT (decl
));
202 find_methodref_with_class_index (cpool
, decl
, mclass
)
207 int class_index
= find_class_constant (cpool
, mclass
);
208 tree name
= DECL_CONSTRUCTOR_P (decl
) ? init_identifier_node
212 find_name_and_type_constant (cpool
, name
, TREE_TYPE (decl
));
213 return find_constant1 (cpool
,
214 CLASS_INTERFACE (TYPE_NAME (mclass
))
215 ? CONSTANT_InterfaceMethodref
216 : CONSTANT_Methodref
,
217 (class_index
<< 16) | name_type_index
);
220 #define PUT1(X) (*ptr++ = (X))
221 #define PUT2(X) (PUT1((X) >> 8), PUT1(X))
222 #define PUT4(X) (PUT2((X) >> 16), PUT2(X))
223 #define PUTN(P, N) (memcpy(ptr, (P), (N)), ptr += (N))
225 /* Give the number of bytes needed in a .class file for the CPOOL
226 constant pool. Includes the 2-byte constant_pool_count. */
229 count_constant_pool_bytes (cpool
)
234 for ( ; i
< cpool
->count
; i
++)
237 switch (cpool
->tags
[i
])
239 case CONSTANT_NameAndType
:
240 case CONSTANT_Fieldref
:
241 case CONSTANT_Methodref
:
242 case CONSTANT_InterfaceMethodref
:
244 case CONSTANT_Integer
:
248 case CONSTANT_String
:
252 case CONSTANT_Double
:
258 tree t
= (tree
) cpool
->data
[i
];
259 int len
= IDENTIFIER_LENGTH (t
);
264 /* Second word of CONSTANT_Long and CONSTANT_Double. */
271 /* Write the constant pool CPOOL into BUFFER.
272 The length of BUFFER is LENGTH, which must match the needed length. */
275 write_constant_pool (cpool
, buffer
, length
)
277 unsigned char *buffer
;
280 unsigned char *ptr
= buffer
;
282 jword
*datap
= &cpool
->data
[1];
284 for ( ; i
< cpool
->count
; i
++, datap
++)
286 int tag
= cpool
->tags
[i
];
290 case CONSTANT_NameAndType
:
291 case CONSTANT_Fieldref
:
292 case CONSTANT_Methodref
:
293 case CONSTANT_InterfaceMethodref
:
295 case CONSTANT_Integer
:
299 case CONSTANT_String
:
304 case CONSTANT_Double
:
312 tree t
= (tree
) *datap
;
313 int len
= IDENTIFIER_LENGTH (t
);
315 PUTN (IDENTIFIER_POINTER (t
), len
);
321 if (ptr
!= buffer
+ length
)
325 CPool
*outgoing_cpool
;
327 static GTY(()) tree tag_nodes
[13];
332 /* A Cache for build_int_2 (CONSTANT_XXX, 0). */
334 if (tag_nodes
[tag
] == NULL_TREE
)
335 tag_nodes
[tag
] = build_int_2 (tag
, 0);
336 return tag_nodes
[tag
];
339 /* Look for a constant pool entry that matches TAG and NAME.
340 Creates a new entry if not found.
341 TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class.
342 NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class.
343 Returns the index of the entry. */
346 alloc_name_constant (tag
, name
)
350 return find_constant1 (outgoing_cpool
, tag
, (jword
) name
);
353 /* Build an identifier for the internal name of reference type TYPE. */
356 build_internal_class_name (type
)
360 if (TYPE_ARRAY_P (type
))
361 name
= build_java_signature (type
);
364 name
= TYPE_NAME (type
);
365 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
366 name
= DECL_NAME (name
);
367 name
= identifier_subst (name
, "", '.', '/', "");
372 /* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */
375 alloc_class_constant (clas
)
378 tree class_name
= build_internal_class_name (clas
);
380 return alloc_name_constant (CONSTANT_Class
,
382 (IDENTIFIER_POINTER(class_name
),
383 IDENTIFIER_LENGTH(class_name
))));
386 /* Return a reference to the data array of the current constant pool. */
389 build_constant_data_ref ()
391 if (TYPE_CPOOL_DATA_REF (current_class
))
392 current_constant_pool_data_ref
= TYPE_CPOOL_DATA_REF (current_class
);
394 else if (current_constant_pool_data_ref
== NULL_TREE
)
397 tree decl_name
= mangled_classname ("_CD_", current_class
);
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
);
403 TYPE_CPOOL_DATA_REF (current_class
) = current_constant_pool_data_ref
404 = build1 (ADDR_EXPR
, ptr_type_node
, decl
);
406 return current_constant_pool_data_ref
;
409 /* Get the pointer value at the INDEX'th element of the constant pool. */
412 build_ref_from_constant_pool (index
)
415 tree t
= build_constant_data_ref ();
416 index
*= int_size_in_bytes (ptr_type_node
);
417 t
= fold (build (PLUS_EXPR
, ptr_type_node
,
418 t
, build_int_2 (index
, 0)));
419 return build1 (INDIRECT_REF
, ptr_type_node
, t
);
422 /* Build an initializer for the constants field of the current constal pool.
423 Should only be called at top-level, since it may emit declarations. */
426 build_constants_constructor ()
428 tree tags_value
, data_value
;
430 tree tags_list
= NULL_TREE
;
431 tree data_list
= NULL_TREE
;
433 for (i
= outgoing_cpool
->count
; --i
> 0; )
436 = tree_cons (NULL_TREE
, get_tag_node (outgoing_cpool
->tags
[i
]),
439 = tree_cons (NULL_TREE
, build_utf8_ref ((tree
)outgoing_cpool
->data
[i
]),
442 if (outgoing_cpool
->count
> 0)
445 tree data_decl
, tags_decl
, tags_type
;
446 tree max_index
= build_int_2 (outgoing_cpool
->count
- 1, 0);
447 TREE_TYPE (max_index
) = sizetype
;
448 index_type
= build_index_type (max_index
);
450 /* Add dummy 0'th element of constant pool. */
451 tags_list
= tree_cons (NULL_TREE
, get_tag_node (0), tags_list
);
452 data_list
= tree_cons (NULL_TREE
, null_pointer_node
, data_list
);
454 data_decl
= TREE_OPERAND (build_constant_data_ref (), 0);
455 TREE_TYPE (data_decl
) = build_array_type (ptr_type_node
, index_type
),
456 DECL_INITIAL (data_decl
) = build (CONSTRUCTOR
, TREE_TYPE (data_decl
),
457 NULL_TREE
, data_list
);
458 DECL_SIZE (data_decl
) = TYPE_SIZE (TREE_TYPE (data_decl
));
459 DECL_SIZE_UNIT (data_decl
) = TYPE_SIZE_UNIT (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
);
486 #include "gt-java-constants.h"