source: vendor/gcc/3.3.4/libjava/resolve.cc

Last change on this file was 1391, checked in by bird, 21 years ago

GCC v3.3.3 sources.
  • Property cvs2svn:cvs-rev set to 1.1.1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 28.0 KB
Line 
1// resolve.cc - Code for linking and resolving classes and pool entries.
2
3/* Copyright (C) 1999, 2000, 2001 , 2002, 2003 Free Software Foundation
4
5 This file is part of libgcj.
6
7This software is copyrighted work licensed under the terms of the
8Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
9details. */
10
11/* Author: Kresten Krab Thorup <krab@gnu.org> */
12
13#include <config.h>
14
15#include <java-interp.h>
16
17#include <jvm.h>
18#include <gcj/cni.h>
19#include <string.h>
20#include <java-cpool.h>
21#include <java/lang/Class.h>
22#include <java/lang/String.h>
23#include <java/lang/StringBuffer.h>
24#include <java/lang/Thread.h>
25#include <java/lang/InternalError.h>
26#include <java/lang/VirtualMachineError.h>
27#include <java/lang/NoSuchFieldError.h>
28#include <java/lang/NoSuchMethodError.h>
29#include <java/lang/ClassFormatError.h>
30#include <java/lang/IllegalAccessError.h>
31#include <java/lang/AbstractMethodError.h>
32#include <java/lang/NoClassDefFoundError.h>
33#include <java/lang/IncompatibleClassChangeError.h>
34#include <java/lang/reflect/Modifier.h>
35
36using namespace gcj;
37
38void
39_Jv_ResolveField (_Jv_Field *field, java::lang::ClassLoader *loader)
40{
41 if (! field->isResolved ())
42 {
43 _Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type;
44 field->type = _Jv_FindClassFromSignature (sig->data, loader);
45 field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
46 }
47}
48
49#ifdef INTERPRETER
50
51static void throw_internal_error (char *msg)
52 __attribute__ ((__noreturn__));
53static void throw_class_format_error (jstring msg)
54 __attribute__ ((__noreturn__));
55static void throw_class_format_error (char *msg)
56 __attribute__ ((__noreturn__));
57
58static int get_alignment_from_class (jclass);
59
60static _Jv_ResolvedMethod*
61_Jv_BuildResolvedMethod (_Jv_Method*,
62 jclass,
63 jboolean,
64 jint);
65
66
67static void throw_incompatible_class_change_error (jstring msg)
68{
69 throw new java::lang::IncompatibleClassChangeError (msg);
70}
71
72_Jv_word
73_Jv_ResolvePoolEntry (jclass klass, int index)
74{
75 using namespace java::lang::reflect;
76
77 _Jv_Constants *pool = &klass->constants;
78
79 if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0)
80 return pool->data[index];
81
82 switch (pool->tags[index]) {
83 case JV_CONSTANT_Class:
84 {
85 _Jv_Utf8Const *name = pool->data[index].utf8;
86
87 jclass found;
88 if (name->data[0] == '[')
89 found = _Jv_FindClassFromSignature (&name->data[0],
90 klass->loader);
91 else
92 found = _Jv_FindClass (name, klass->loader);
93
94 if (! found)
95 {
96 jstring str = _Jv_NewStringUTF (name->data);
97 // This exception is specified in JLS 2nd Ed, section 5.1.
98 throw new java::lang::NoClassDefFoundError (str);
99 }
100
101 if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC
102 || (_Jv_ClassNameSamePackage (found->name,
103 klass->name)))
104 {
105 pool->data[index].clazz = found;
106 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
107 }
108 else
109 {
110 throw new java::lang::IllegalAccessError (found->getName());
111 }
112 }
113 break;
114
115 case JV_CONSTANT_String:
116 {
117 jstring str;
118 str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
119 pool->data[index].o = str;
120 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
121 }
122 break;
123
124
125 case JV_CONSTANT_Fieldref:
126 {
127 _Jv_ushort class_index, name_and_type_index;
128 _Jv_loadIndexes (&pool->data[index],
129 class_index,
130 name_and_type_index);
131 jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz;
132
133 if (owner != klass)
134 _Jv_InitClass (owner);
135
136 _Jv_ushort name_index, type_index;
137 _Jv_loadIndexes (&pool->data[name_and_type_index],
138 name_index,
139 type_index);
140
141 _Jv_Utf8Const *field_name = pool->data[name_index].utf8;
142 _Jv_Utf8Const *field_type_name = pool->data[type_index].utf8;
143
144 // FIXME: The implementation of this function
145 // (_Jv_FindClassFromSignature) will generate an instance of
146 // _Jv_Utf8Const for each call if the field type is a class name
147 // (Lxx.yy.Z;). This may be too expensive to do for each and
148 // every fieldref being resolved. For now, we fix the problem by
149 // only doing it when we have a loader different from the class
150 // declaring the field.
151
152 jclass field_type = 0;
153
154 if (owner->loader != klass->loader)
155 field_type = _Jv_FindClassFromSignature (field_type_name->data,
156 klass->loader);
157
158 _Jv_Field* the_field = 0;
159
160 for (jclass cls = owner; cls != 0; cls = cls->getSuperclass ())
161 {
162 for (int i = 0; i < cls->field_count; i++)
163 {
164 _Jv_Field *field = &cls->fields[i];
165 if (! _Jv_equalUtf8Consts (field->name, field_name))
166 continue;
167
168 // now, check field access.
169
170 if ( (cls == klass)
171 || ((field->flags & Modifier::PUBLIC) != 0)
172 || (((field->flags & Modifier::PROTECTED) != 0)
173 && cls->isAssignableFrom (klass))
174 || (((field->flags & Modifier::PRIVATE) == 0)
175 && _Jv_ClassNameSamePackage (cls->name,
176 klass->name)))
177 {
178 /* resove the field using the class' own loader
179 if necessary */
180
181 if (!field->isResolved ())
182 _Jv_ResolveField (field, cls->loader);
183
184 if (field_type != 0 && field->type != field_type)
185 throw new java::lang::LinkageError
186 (JvNewStringLatin1
187 ("field type mismatch with different loaders"));
188
189 the_field = field;
190 goto end_of_field_search;
191 }
192 else
193 {
194 throw new java::lang::IllegalAccessError;
195 }
196 }
197 }
198
199 end_of_field_search:
200 if (the_field == 0)
201 {
202 java::lang::StringBuffer *sb = new java::lang::StringBuffer();
203 sb->append(JvNewStringLatin1("field "));
204 sb->append(owner->getName());
205 sb->append(JvNewStringLatin1("."));
206 sb->append(_Jv_NewStringUTF(field_name->data));
207 sb->append(JvNewStringLatin1(" was not found."));
208 throw_incompatible_class_change_error(sb->toString());
209 }
210
211 pool->data[index].field = the_field;
212 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
213 }
214 break;
215
216 case JV_CONSTANT_Methodref:
217 case JV_CONSTANT_InterfaceMethodref:
218 {
219 _Jv_ushort class_index, name_and_type_index;
220 _Jv_loadIndexes (&pool->data[index],
221 class_index,
222 name_and_type_index);
223 jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz;
224
225 if (owner != klass)
226 _Jv_InitClass (owner);
227
228 _Jv_ushort name_index, type_index;
229 _Jv_loadIndexes (&pool->data[name_and_type_index],
230 name_index,
231 type_index);
232
233 _Jv_Utf8Const *method_name = pool->data[name_index].utf8;
234 _Jv_Utf8Const *method_signature = pool->data[type_index].utf8;
235
236 _Jv_Method *the_method = 0;
237 jclass found_class = 0;
238
239 // First search the class itself.
240 the_method = _Jv_SearchMethodInClass (owner, klass,
241 method_name, method_signature);
242
243 if (the_method != 0)
244 {
245 found_class = owner;
246 goto end_of_method_search;
247 }
248
249 // If we are resolving an interface method, search the
250 // interface's superinterfaces (A superinterface is not an
251 // interface's superclass - a superinterface is implemented by
252 // the interface).
253 if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref)
254 {
255 _Jv_ifaces ifaces;
256 ifaces.count = 0;
257 ifaces.len = 4;
258 ifaces.list = (jclass *) _Jv_Malloc (ifaces.len * sizeof (jclass *));
259
260 _Jv_GetInterfaces (owner, &ifaces);
261
262 for (int i = 0; i < ifaces.count; i++)
263 {
264 jclass cls = ifaces.list[i];
265 the_method = _Jv_SearchMethodInClass (cls, klass, method_name,
266 method_signature);
267 if (the_method != 0)
268 {
269 found_class = cls;
270 break;
271 }
272 }
273
274 _Jv_Free (ifaces.list);
275
276 if (the_method != 0)
277 goto end_of_method_search;
278 }
279
280 // Finally, search superclasses.
281 for (jclass cls = owner->getSuperclass (); cls != 0;
282 cls = cls->getSuperclass ())
283 {
284 the_method = _Jv_SearchMethodInClass (cls, klass,
285 method_name, method_signature);
286 if (the_method != 0)
287 {
288 found_class = cls;
289 break;
290 }
291 }
292
293 end_of_method_search:
294
295 // FIXME: if (cls->loader != klass->loader), then we
296 // must actually check that the types of arguments
297 // correspond. That is, for each argument type, and
298 // the return type, doing _Jv_FindClassFromSignature
299 // with either loader should produce the same result,
300 // i.e., exactly the same jclass object. JVMS 5.4.3.3
301
302 if (the_method == 0)
303 {
304 java::lang::StringBuffer *sb = new java::lang::StringBuffer();
305 sb->append(JvNewStringLatin1("method "));
306 sb->append(owner->getName());
307 sb->append(JvNewStringLatin1("."));
308 sb->append(_Jv_NewStringUTF(method_name->data));
309 sb->append(JvNewStringLatin1(" was not found."));
310 throw new java::lang::NoSuchMethodError (sb->toString());
311 }
312
313 int vtable_index = -1;
314 if (pool->tags[index] != JV_CONSTANT_InterfaceMethodref)
315 vtable_index = (jshort)the_method->index;
316
317 pool->data[index].rmethod =
318 _Jv_BuildResolvedMethod(the_method,
319 found_class,
320 (the_method->accflags & Modifier::STATIC) != 0,
321 vtable_index);
322 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
323 }
324 break;
325
326 }
327
328 return pool->data[index];
329}
330
331// Find a method declared in the cls that is referenced from klass and
332// perform access checks.
333_Jv_Method *
334_Jv_SearchMethodInClass (jclass cls, jclass klass,
335 _Jv_Utf8Const *method_name,
336 _Jv_Utf8Const *method_signature)
337{
338 using namespace java::lang::reflect;
339
340 for (int i = 0; i < cls->method_count; i++)
341 {
342 _Jv_Method *method = &cls->methods[i];
343 if ( (!_Jv_equalUtf8Consts (method->name,
344 method_name))
345 || (!_Jv_equalUtf8Consts (method->signature,
346 method_signature)))
347 continue;
348
349 if (cls == klass
350 || ((method->accflags & Modifier::PUBLIC) != 0)
351 || (((method->accflags & Modifier::PROTECTED) != 0)
352 && cls->isAssignableFrom (klass))
353 || (((method->accflags & Modifier::PRIVATE) == 0)
354 && _Jv_ClassNameSamePackage (cls->name,
355 klass->name)))
356 {
357 return method;
358 }
359 else
360 {
361 throw new java::lang::IllegalAccessError;
362 }
363 }
364 return 0;
365}
366
367// A helper for _Jv_PrepareClass. This adds missing `Miranda methods'
368// to a class.
369void
370_Jv_PrepareMissingMethods (jclass base2, jclass iface_class)
371{
372 _Jv_InterpClass *base = reinterpret_cast<_Jv_InterpClass *> (base2);
373 for (int i = 0; i < iface_class->interface_count; ++i)
374 {
375 for (int j = 0; j < iface_class->interfaces[i]->method_count; ++j)
376 {
377 _Jv_Method *meth = &iface_class->interfaces[i]->methods[j];
378 // Don't bother with <clinit>.
379 if (meth->name->data[0] == '<')
380 continue;
381 _Jv_Method *new_meth = _Jv_LookupDeclaredMethod (base, meth->name,
382 meth->signature);
383 if (! new_meth)
384 {
385 // We assume that such methods are very unlikely, so we
386 // just reallocate the method array each time one is
387 // found. This greatly simplifies the searching --
388 // otherwise we have to make sure that each such method
389 // found is really unique among all superinterfaces.
390 int new_count = base->method_count + 1;
391 _Jv_Method *new_m
392 = (_Jv_Method *) _Jv_AllocBytes (sizeof (_Jv_Method)
393 * new_count);
394 memcpy (new_m, base->methods,
395 sizeof (_Jv_Method) * base->method_count);
396
397 // Add new method.
398 new_m[base->method_count] = *meth;
399 new_m[base->method_count].index = (_Jv_ushort) -1;
400 new_m[base->method_count].accflags
401 |= java::lang::reflect::Modifier::INVISIBLE;
402
403 _Jv_MethodBase **new_im
404 = (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
405 * new_count);
406 memcpy (new_im, base->interpreted_methods,
407 sizeof (_Jv_MethodBase *) * base->method_count);
408
409 base->methods = new_m;
410 base->interpreted_methods = new_im;
411 base->method_count = new_count;
412 }
413 }
414
415 _Jv_PrepareMissingMethods (base, iface_class->interfaces[i]);
416 }
417}
418
419void
420_Jv_PrepareClass(jclass klass)
421{
422 using namespace java::lang::reflect;
423
424 /*
425 * The job of this function is to: 1) assign storage to fields, and 2)
426 * build the vtable. static fields are assigned real memory, instance
427 * fields are assigned offsets.
428 *
429 * NOTE: we have a contract with the garbage collector here. Static
430 * reference fields must not be resolved, until after they have storage
431 * assigned which is the check used by the collector to see if it
432 * should indirect the static field reference and mark the object
433 * pointed to.
434 *
435 * Most fields are resolved lazily (i.e. have their class-type
436 * assigned) when they are accessed the first time by calling as part
437 * of _Jv_ResolveField, which is allways called after _Jv_PrepareClass.
438 * Static fields with initializers are resolved as part of this
439 * function, as are fields with primitive types.
440 */
441
442 if (! _Jv_IsInterpretedClass (klass))
443 return;
444
445 if (klass->state >= JV_STATE_PREPARED)
446 return;
447
448 // Make sure super-class is linked. This involves taking a lock on
449 // the super class, so we use the Java method resolveClass, which
450 // will unlock it properly, should an exception happen. If there's
451 // no superclass, do nothing -- Object will already have been
452 // resolved.
453
454 if (klass->superclass)
455 java::lang::ClassLoader::resolveClass0 (klass->superclass);
456
457 _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
458
459 /************ PART ONE: OBJECT LAYOUT ***************/
460
461 int instance_size;
462 int static_size;
463
464 // Although java.lang.Object is never interpreted, an interface can
465 // have a null superclass.
466 if (clz->superclass)
467 instance_size = clz->superclass->size();
468 else
469 instance_size = java::lang::Object::class$.size();
470 static_size = 0;
471
472 for (int i = 0; i < clz->field_count; i++)
473 {
474 int field_size;
475 int field_align;
476
477 _Jv_Field *field = &clz->fields[i];
478
479 if (! field->isRef ())
480 {
481 // it's safe to resolve the field here, since it's
482 // a primitive class, which does not cause loading to happen.
483 _Jv_ResolveField (field, clz->loader);
484
485 field_size = field->type->size ();
486 field_align = get_alignment_from_class (field->type);
487 }
488 else
489 {
490 field_size = sizeof (jobject);
491 field_align = __alignof__ (jobject);
492 }
493
494#ifndef COMPACT_FIELDS
495 field->bsize = field_size;
496#endif
497
498 if (field->flags & Modifier::STATIC)
499 {
500 /* this computes an offset into a region we'll allocate
501 shortly, and then add this offset to the start address */
502
503 static_size = ROUND (static_size, field_align);
504 field->u.boffset = static_size;
505 static_size += field_size;
506 }
507 else
508 {
509 instance_size = ROUND (instance_size, field_align);
510 field->u.boffset = instance_size;
511 instance_size += field_size;
512 }
513 }
514
515 // set the instance size for the class
516 clz->size_in_bytes = instance_size;
517
518 // allocate static memory
519 if (static_size != 0)
520 {
521 char *static_data = (char*)_Jv_AllocBytes (static_size);
522
523 memset (static_data, 0, static_size);
524
525 for (int i = 0; i < clz->field_count; i++)
526 {
527 _Jv_Field *field = &clz->fields[i];
528
529 if ((field->flags & Modifier::STATIC) != 0)
530 {
531 field->u.addr = static_data + field->u.boffset;
532
533 if (clz->field_initializers[i] != 0)
534 {
535 _Jv_ResolveField (field, clz->loader);
536 _Jv_InitField (0, clz, i);
537 }
538 }
539 }
540
541 // now we don't need the field_initializers anymore, so let the
542 // collector get rid of it!
543
544 clz->field_initializers = 0;
545 }
546
547 /************ PART TWO: VTABLE LAYOUT ***************/
548
549 /* preparation: build the vtable stubs (even interfaces can)
550 have code -- for static constructors. */
551 for (int i = 0; i < clz->method_count; i++)
552 {
553 _Jv_MethodBase *imeth = clz->interpreted_methods[i];
554
555 if ((clz->methods[i].accflags & Modifier::NATIVE) != 0)
556 {
557 // You might think we could use a virtual `ncode' method in
558 // the _Jv_MethodBase and unify the native and non-native
559 // cases. Well, we can't, because we don't allocate these
560 // objects using `new', and thus they don't get a vtable.
561 _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth);
562 clz->methods[i].ncode = jnim->ncode ();
563 }
564 else if (imeth != 0) // it could be abstract
565 {
566 _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
567 _Jv_VerifyMethod (im);
568 clz->methods[i].ncode = im->ncode ();
569 }
570 }
571
572 if ((clz->accflags & Modifier::INTERFACE))
573 {
574 clz->state = JV_STATE_PREPARED;
575 clz->notifyAll ();
576 return;
577 }
578
579 // A class might have so-called "Miranda methods". This is a method
580 // that is declared in an interface and not re-declared in an
581 // abstract class. Some compilers don't emit declarations for such
582 // methods in the class; this will give us problems since we expect
583 // a declaration for any method requiring a vtable entry. We handle
584 // this here by searching for such methods and constructing new
585 // internal declarations for them. We only need to do this for
586 // abstract classes.
587 if ((clz->accflags & Modifier::ABSTRACT))
588 _Jv_PrepareMissingMethods (clz, clz);
589
590 clz->vtable_method_count = -1;
591 _Jv_MakeVTable (clz);
592
593 /* wooha! we're done. */
594 clz->state = JV_STATE_PREPARED;
595 clz->notifyAll ();
596}
597
598/** Do static initialization for fields with a constant initializer */
599void
600_Jv_InitField (jobject obj, jclass klass, int index)
601{
602 using namespace java::lang::reflect;
603
604 if (obj != 0 && klass == 0)
605 klass = obj->getClass ();
606
607 if (!_Jv_IsInterpretedClass (klass))
608 return;
609
610 _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
611
612 _Jv_Field * field = (&clz->fields[0]) + index;
613
614 if (index > clz->field_count)
615 throw_internal_error ("field out of range");
616
617 int init = clz->field_initializers[index];
618 if (init == 0)
619 return;
620
621 _Jv_Constants *pool = &clz->constants;
622 int tag = pool->tags[init];
623
624 if (! field->isResolved ())
625 throw_internal_error ("initializing unresolved field");
626
627 if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
628 throw_internal_error ("initializing non-static field with no object");
629
630 void *addr = 0;
631
632 if ((field->flags & Modifier::STATIC) != 0)
633 addr = (void*) field->u.addr;
634 else
635 addr = (void*) (((char*)obj) + field->u.boffset);
636
637 switch (tag)
638 {
639 case JV_CONSTANT_String:
640 {
641 _Jv_MonitorEnter (clz);
642 jstring str;
643 str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
644 pool->data[init].string = str;
645 pool->tags[init] = JV_CONSTANT_ResolvedString;
646 _Jv_MonitorExit (clz);
647 }
648 /* fall through */
649
650 case JV_CONSTANT_ResolvedString:
651 if (! (field->type == &StringClass
652 || field->type == &java::lang::Class::class$))
653 throw_class_format_error ("string initialiser to non-string field");
654
655 *(jstring*)addr = pool->data[init].string;
656 break;
657
658 case JV_CONSTANT_Integer:
659 {
660 int value = pool->data[init].i;
661
662 if (field->type == JvPrimClass (boolean))
663 *(jboolean*)addr = (jboolean)value;
664
665 else if (field->type == JvPrimClass (byte))
666 *(jbyte*)addr = (jbyte)value;
667
668 else if (field->type == JvPrimClass (char))
669 *(jchar*)addr = (jchar)value;
670
671 else if (field->type == JvPrimClass (short))
672 *(jshort*)addr = (jshort)value;
673
674 else if (field->type == JvPrimClass (int))
675 *(jint*)addr = (jint)value;
676
677 else
678 throw_class_format_error ("erroneous field initializer");
679 }
680 break;
681
682 case JV_CONSTANT_Long:
683 if (field->type != JvPrimClass (long))
684 throw_class_format_error ("erroneous field initializer");
685
686 *(jlong*)addr = _Jv_loadLong (&pool->data[init]);
687 break;
688
689 case JV_CONSTANT_Float:
690 if (field->type != JvPrimClass (float))
691 throw_class_format_error ("erroneous field initializer");
692
693 *(jfloat*)addr = pool->data[init].f;
694 break;
695
696 case JV_CONSTANT_Double:
697 if (field->type != JvPrimClass (double))
698 throw_class_format_error ("erroneous field initializer");
699
700 *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]);
701 break;
702
703 default:
704 throw_class_format_error ("erroneous field initializer");
705 }
706}
707
708static int
709get_alignment_from_class (jclass klass)
710{
711 if (klass == JvPrimClass (byte))
712 return __alignof__ (jbyte);
713 else if (klass == JvPrimClass (short))
714 return __alignof__ (jshort);
715 else if (klass == JvPrimClass (int))
716 return __alignof__ (jint);
717 else if (klass == JvPrimClass (long))
718 return __alignof__ (jlong);
719 else if (klass == JvPrimClass (boolean))
720 return __alignof__ (jboolean);
721 else if (klass == JvPrimClass (char))
722 return __alignof__ (jchar);
723 else if (klass == JvPrimClass (float))
724 return __alignof__ (jfloat);
725 else if (klass == JvPrimClass (double))
726 return __alignof__ (jdouble);
727 else
728 return __alignof__ (jobject);
729}
730
731
732inline static unsigned char*
733skip_one_type (unsigned char* ptr)
734{
735 int ch = *ptr++;
736
737 while (ch == '[')
738 {
739 ch = *ptr++;
740 }
741
742 if (ch == 'L')
743 {
744 do { ch = *ptr++; } while (ch != ';');
745 }
746
747 return ptr;
748}
749
750static ffi_type*
751get_ffi_type_from_signature (unsigned char* ptr)
752{
753 switch (*ptr)
754 {
755 case 'L':
756 case '[':
757 return &ffi_type_pointer;
758 break;
759
760 case 'Z':
761 // On some platforms a bool is a byte, on others an int.
762 if (sizeof (jboolean) == sizeof (jbyte))
763 return &ffi_type_sint8;
764 else
765 {
766 JvAssert (sizeof (jbyte) == sizeof (jint));
767 return &ffi_type_sint32;
768 }
769 break;
770
771 case 'B':
772 return &ffi_type_sint8;
773 break;
774
775 case 'C':
776 return &ffi_type_uint16;
777 break;
778
779 case 'S':
780 return &ffi_type_sint16;
781 break;
782
783 case 'I':
784 return &ffi_type_sint32;
785 break;
786
787 case 'J':
788 return &ffi_type_sint64;
789 break;
790
791 case 'F':
792 return &ffi_type_float;
793 break;
794
795 case 'D':
796 return &ffi_type_double;
797 break;
798
799 case 'V':
800 return &ffi_type_void;
801 break;
802 }
803
804 throw_internal_error ("unknown type in signature");
805}
806
807/* this function yields the number of actual arguments, that is, if the
808 * function is non-static, then one is added to the number of elements
809 * found in the signature */
810
811int
812_Jv_count_arguments (_Jv_Utf8Const *signature,
813 jboolean staticp)
814{
815 unsigned char *ptr = (unsigned char*) signature->data;
816 int arg_count = staticp ? 0 : 1;
817
818 /* first, count number of arguments */
819
820 // skip '('
821 ptr++;
822
823 // count args
824 while (*ptr != ')')
825 {
826 ptr = skip_one_type (ptr);
827 arg_count += 1;
828 }
829
830 return arg_count;
831}
832
833/* This beast will build a cif, given the signature. Memory for
834 * the cif itself and for the argument types must be allocated by the
835 * caller.
836 */
837
838static int
839init_cif (_Jv_Utf8Const* signature,
840 int arg_count,
841 jboolean staticp,
842 ffi_cif *cif,
843 ffi_type **arg_types,
844 ffi_type **rtype_p)
845{
846 unsigned char *ptr = (unsigned char*) signature->data;
847
848 int arg_index = 0; // arg number
849 int item_count = 0; // stack-item count
850
851 // setup receiver
852 if (!staticp)
853 {
854 arg_types[arg_index++] = &ffi_type_pointer;
855 item_count += 1;
856 }
857
858 // skip '('
859 ptr++;
860
861 // assign arg types
862 while (*ptr != ')')
863 {
864 arg_types[arg_index++] = get_ffi_type_from_signature (ptr);
865
866 if (*ptr == 'J' || *ptr == 'D')
867 item_count += 2;
868 else
869 item_count += 1;
870
871 ptr = skip_one_type (ptr);
872 }
873
874 // skip ')'
875 ptr++;
876 ffi_type *rtype = get_ffi_type_from_signature (ptr);
877
878 ptr = skip_one_type (ptr);
879 if (ptr != (unsigned char*)signature->data + signature->length)
880 throw_internal_error ("did not find end of signature");
881
882 if (ffi_prep_cif (cif, FFI_DEFAULT_ABI,
883 arg_count, rtype, arg_types) != FFI_OK)
884 throw_internal_error ("ffi_prep_cif failed");
885
886 if (rtype_p != NULL)
887 *rtype_p = rtype;
888
889 return item_count;
890}
891
892#if FFI_NATIVE_RAW_API
893# define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure
894# define FFI_RAW_SIZE ffi_raw_size
895#else
896# define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure
897# define FFI_RAW_SIZE ffi_java_raw_size
898#endif
899
900/* we put this one here, and not in interpret.cc because it
901 * calls the utility routines _Jv_count_arguments
902 * which are static to this module. The following struct defines the
903 * layout we use for the stubs, it's only used in the ncode method. */
904
905typedef struct {
906 ffi_raw_closure closure;
907 ffi_cif cif;
908 ffi_type *arg_types[0];
909} ncode_closure;
910
911typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_raw*,void*);
912
913void *
914_Jv_InterpMethod::ncode ()
915{
916 using namespace java::lang::reflect;
917
918 if (self->ncode != 0)
919 return self->ncode;
920
921 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
922 int arg_count = _Jv_count_arguments (self->signature, staticp);
923
924 ncode_closure *closure =
925 (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
926 + arg_count * sizeof (ffi_type*));
927
928 init_cif (self->signature,
929 arg_count,
930 staticp,
931 &closure->cif,
932 &closure->arg_types[0],
933 NULL);
934
935 ffi_closure_fun fun;
936
937 args_raw_size = FFI_RAW_SIZE (&closure->cif);
938
939 JvAssert ((self->accflags & Modifier::NATIVE) == 0);
940
941 if ((self->accflags & Modifier::SYNCHRONIZED) != 0)
942 {
943 if (staticp)
944 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class;
945 else
946 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object;
947 }
948 else
949 {
950 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
951 }
952
953 FFI_PREP_RAW_CLOSURE (&closure->closure,
954 &closure->cif,
955 fun,
956 (void*)this);
957
958 self->ncode = (void*)closure;
959 return self->ncode;
960}
961
962
963void *
964_Jv_JNIMethod::ncode ()
965{
966 using namespace java::lang::reflect;
967
968 if (self->ncode != 0)
969 return self->ncode;
970
971 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
972 int arg_count = _Jv_count_arguments (self->signature, staticp);
973
974 ncode_closure *closure =
975 (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
976 + arg_count * sizeof (ffi_type*));
977
978 ffi_type *rtype;
979 init_cif (self->signature,
980 arg_count,
981 staticp,
982 &closure->cif,
983 &closure->arg_types[0],
984 &rtype);
985
986 ffi_closure_fun fun;
987
988 args_raw_size = FFI_RAW_SIZE (&closure->cif);
989
990 // Initialize the argument types and CIF that represent the actual
991 // underlying JNI function.
992 int extra_args = 1;
993 if ((self->accflags & Modifier::STATIC))
994 ++extra_args;
995 jni_arg_types = (ffi_type **) _Jv_Malloc ((extra_args + arg_count)
996 * sizeof (ffi_type *));
997 int offset = 0;
998 jni_arg_types[offset++] = &ffi_type_pointer;
999 if ((self->accflags & Modifier::STATIC))
1000 jni_arg_types[offset++] = &ffi_type_pointer;
1001 memcpy (&jni_arg_types[offset], &closure->arg_types[0],
1002 arg_count * sizeof (ffi_type *));
1003
1004 // NOTE: This must agree with the JNICALL definition in jni.h
1005#ifdef WIN32
1006#define FFI_JNI_ABI FFI_STDCALL
1007#else
1008#define FFI_JNI_ABI FFI_DEFAULT_ABI
1009#endif
1010
1011 if (ffi_prep_cif (&jni_cif, FFI_JNI_ABI,
1012 extra_args + arg_count, rtype,
1013 jni_arg_types) != FFI_OK)
1014 throw_internal_error ("ffi_prep_cif failed for JNI function");
1015
1016 JvAssert ((self->accflags & Modifier::NATIVE) != 0);
1017
1018 // FIXME: for now we assume that all native methods for
1019 // interpreted code use JNI.
1020 fun = (ffi_closure_fun) &_Jv_JNIMethod::call;
1021
1022 FFI_PREP_RAW_CLOSURE (&closure->closure,
1023 &closure->cif,
1024 fun,
1025 (void*) this);
1026
1027 self->ncode = (void *) closure;
1028 return self->ncode;
1029}
1030
1031
1032/* A _Jv_ResolvedMethod is what is put in the constant pool for a
1033 * MethodRef or InterfacemethodRef. */
1034static _Jv_ResolvedMethod*
1035_Jv_BuildResolvedMethod (_Jv_Method* method,
1036 jclass klass,
1037 jboolean staticp,
1038 jint vtable_index)
1039{
1040 int arg_count = _Jv_count_arguments (method->signature, staticp);
1041
1042 _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*)
1043 _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod)
1044 + arg_count*sizeof (ffi_type*));
1045
1046 result->stack_item_count
1047 = init_cif (method->signature,
1048 arg_count,
1049 staticp,
1050 &result->cif,
1051 &result->arg_types[0],
1052 NULL);
1053
1054 result->vtable_index = vtable_index;
1055 result->method = method;
1056 result->klass = klass;
1057
1058 return result;
1059}
1060
1061
1062static void
1063throw_class_format_error (jstring msg)
1064{
1065 throw (msg
1066 ? new java::lang::ClassFormatError (msg)
1067 : new java::lang::ClassFormatError);
1068}
1069
1070static void
1071throw_class_format_error (char *msg)
1072{
1073 throw_class_format_error (JvNewStringLatin1 (msg));
1074}
1075
1076static void
1077throw_internal_error (char *msg)
1078{
1079 throw new java::lang::InternalError (JvNewStringLatin1 (msg));
1080}
1081
1082
1083#endif /* INTERPRETER */
Note: See TracBrowser for help on using the repository browser.