src/cacaoh/dummy.c

   1 /* src/cacaoh/dummy.c - dummy functions for cacaoh
   2
   3    Copyright (C) 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25 */
  26
  27
  28 #include "config.h"
  29
  30 #include <assert.h>
  31 #include <stdarg.h>
  32 #include <stdint.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35
  36 #include "mm/memory.h"
  37
  38 #include "native/llni.h"
  39
  40 #include "toolbox/logging.h"
  41
  42 #include "vm/global.h"
  43 #include "vm/primitive.h"
  44 #include "vm/vm.h"
  45
  46 #include "vmcore/class.h"
  47 #include "vmcore/method.h"
  48 #include "vmcore/utf8.h"
  49 #include "vmcore/classcache.h"
  50 #include "vmcore/loader.h"
  51
  52
  53 /* global variables ***********************************************************/
  54
  55 char *_Jv_bootclasspath;
  56
  57
  58 java_handle_t *javastring_new_slash_to_dot(utf *u)
  59 {
  60         vm_abort("javastring_new_slash_to_dot");
  61
  62         return NULL;
  63 }
  64
  65
  66 /* access *********************************************************************/
  67
  68 bool access_is_accessible_class(classinfo *referer, classinfo *cls)
  69 {
  70         return true;
  71 }
  72
  73 bool access_is_accessible_member(classinfo *referer, classinfo *declarer,
  74                                                                  int32_t memberflags)
  75 {
  76         vm_abort("access_is_accessible_member");
  77
  78         return true;
  79 }
  80
  81
  82 /* array **********************************************************************/
  83
  84 java_handle_t *array_objectarray_element_get(java_handle_objectarray_t *a, int32_t index)
  85 {
  86         java_handle_t *value;
  87         int32_t        size;
  88
  89         if (a == NULL) {
  90                 log_println("array_objectarray_element_get(a=%p, index=%d): NullPointerException", a, index);
  91                 return NULL;
  92         }
  93
  94         size = LLNI_array_size(a);
  95
  96         if ((index < 0) || (index > size)) {
  97                 log_println("array_objectarray_element_get(a=%p, index=%d): ArrayIndexOutOfBoundsException", a, index);
  98                 return NULL;
  99         }
 100
 101         value = LLNI_array_direct(a, index);
 102
 103         return value;
 104 }
 105
 106 void array_objectarray_element_set(java_handle_objectarray_t *a, int32_t index, java_handle_t *value)
 107 {
 108         int32_t size;
 109
 110         if (a == NULL) {
 111                 log_println("array_objectarray_element_set(a=%p, index=%d): NullPointerException", a, index);
 112                 return;
 113         }
 114
 115         size = LLNI_array_size(a);
 116
 117         if ((index < 0) || (index > size)) {
 118                 log_println("array_objectarray_element_set(a=%p, index=%d): ArrayIndexOutOfBoundsException", a, index);
 119                 return;
 120         }
 121
 122         LLNI_array_direct(a, index) = value;
 123 }
 124
 125 int32_t array_length_get(java_handle_t *a)
 126 {
 127         if (a == NULL) {
 128                 log_println("array_length_get(a=%p): NullPointerException", a);
 129                 return 0;
 130         }
 131
 132         return LLNI_array_size(a);
 133 }
 134
 135
 136 /* asm ************************************************************************/
 137
 138 void asm_abstractmethoderror(void)
 139 {
 140         abort();
 141 }
 142
 143 void intrp_asm_abstractmethoderror(void)
 144 {
 145         abort();
 146 }
 147
 148 void asm_getclassvalues_atomic(vftbl_t *super, vftbl_t *sub, castinfo *out)
 149 {
 150         abort();
 151 }
 152
 153 void intrp_asm_getclassvalues_atomic(vftbl_t *super, vftbl_t *sub, castinfo *out)
 154 {
 155         abort();
 156 }
 157
 158
 159 /* builtin ********************************************************************/
 160
 161 java_handle_t *builtin_clone(void *env, java_handle_t *o)
 162 {
 163         abort();
 164
 165         return NULL;
 166 }
 167
 168 int32_t builtin_isanysubclass(classinfo *sub, classinfo *super)
 169 {
 170         abort();
 171
 172         return 0;
 173 }
 174
 175 java_handle_t *builtin_new(classinfo *c)
 176 {
 177         abort();
 178
 179         return NULL;
 180 }
 181
 182 java_handle_objectarray_t *builtin_anewarray(int32_t size, classinfo *componentclass)
 183 {
 184         java_handle_objectarray_t *oa = (java_handle_objectarray_t*)mem_alloc(
 185                 sizeof(java_array_t) + size * sizeof(java_object_t*));
 186
 187         if (oa != NULL) {
 188                 LLNI_array_size(oa) = size;
 189         }
 190
 191         return oa;
 192 }
 193
 194 java_handle_bytearray_t *builtin_newarray_byte(int32_t size)
 195 {
 196         java_handle_bytearray_t *ba = (java_handle_bytearray_t*)mem_alloc(
 197                 sizeof(java_array_t) + size * sizeof(int8_t));
 198
 199         if (ba != NULL) {
 200                 LLNI_array_size(ba) = size;
 201         }
 202
 203         return ba;
 204 }
 205
 206
 207 /* code ***********************************************************************/
 208
 209 void code_free_code_of_method(methodinfo *m)
 210 {
 211 }
 212
 213
 214 methodinfo *code_get_methodinfo_for_pv(u1 *pv)
 215 {
 216         return NULL;
 217 }
 218
 219
 220 /* codegen ********************************************************************/
 221
 222 u1 *codegen_generate_stub_compiler(methodinfo *m)
 223 {
 224         return NULL;
 225 }
 226
 227 codeinfo *codegen_generate_stub_native(methodinfo *m, functionptr f)
 228 {
 229         return NULL;
 230 }
 231
 232 #if defined(ENABLE_INTRP)
 233 u1 *intrp_createcompilerstub(methodinfo *m)
 234 {
 235         return NULL;
 236 }
 237 #endif
 238
 239 void removecompilerstub(u1 *stub)
 240 {
 241 }
 242
 243 void removenativestub(u1 *stub)
 244 {
 245 }
 246
 247
 248 /* exceptions *****************************************************************/
 249
 250 void exceptions_clear_exception(void)
 251 {
 252 }
 253
 254 void exceptions_print_current_exception(void)
 255 {
 256         abort();
 257 }
 258
 259 void exceptions_throw_abstractmethoderror(void)
 260 {
 261         fprintf(stderr, "java.lang.AbstractMethodError\n");
 262
 263         abort();
 264 }
 265
 266 void exceptions_throw_classcircularityerror(classinfo *c)
 267 {
 268         fprintf(stderr, "java.lang.ClassCircularityError: ");
 269
 270         utf_display_printable_ascii(c->name);
 271         fputc('\n', stderr);
 272
 273         abort();
 274 }
 275
 276 void exceptions_throw_classformaterror(classinfo *c, const char *message, ...)
 277 {
 278         va_list ap;
 279
 280         fprintf(stderr, "java.lang.ClassFormatError: ");
 281
 282         utf_display_printable_ascii(c->name);
 283         fprintf(stderr, ": ");
 284
 285         va_start(ap, message);
 286         vfprintf(stderr, message, ap);
 287         va_end(ap);
 288
 289         fputc('\n', stderr);
 290
 291         abort();
 292 }
 293
 294 void exceptions_throw_incompatibleclasschangeerror(classinfo *c)
 295 {
 296         fprintf(stderr, "java.lang.IncompatibleClassChangeError: ");
 297
 298         if (c != NULL)
 299                 utf_fprint_printable_ascii_classname(stderr, c->name);
 300
 301         fputc('\n', stderr);
 302
 303         abort();
 304 }
 305
 306 void exceptions_throw_internalerror(const char *message, ...)
 307 {
 308         va_list ap;
 309
 310         fprintf(stderr, "java.lang.InternalError: ");
 311
 312         va_start(ap, message);
 313         vfprintf(stderr, message, ap);
 314         va_end(ap);
 315
 316         abort();
 317 }
 318
 319 void exceptions_throw_linkageerror(const char *message, classinfo *c)
 320 {
 321         fprintf(stderr, "java.lang.LinkageError: %s", message);
 322
 323         if (c != NULL)
 324                 utf_fprint_printable_ascii_classname(stderr, c->name);
 325
 326         fputc('\n', stderr);
 327
 328         abort();
 329 }
 330
 331 void exceptions_throw_noclassdeffounderror(utf *name)
 332 {
 333         fprintf(stderr, "java.lang.NoClassDefFoundError: ");
 334         utf_fprint_printable_ascii(stderr, name);
 335         fputc('\n', stderr);
 336
 337         abort();
 338 }
 339
 340 void exceptions_throw_noclassdeffounderror_wrong_name(classinfo *c, utf *name)
 341 {
 342         fprintf(stderr, "java.lang.NoClassDefFoundError: ");
 343         utf_fprint_printable_ascii(stderr, c->name);
 344         fprintf(stderr, " (wrong name: ");
 345         utf_fprint_printable_ascii(stderr, name);
 346         fprintf(stderr, ")\n");
 347
 348         abort();
 349 }
 350
 351 void exceptions_throw_verifyerror(methodinfo *m, const char *message)
 352 {
 353         fprintf(stderr, "java.lang.VerifyError: ");
 354         utf_fprint_printable_ascii(stderr, m->name);
 355         fprintf(stderr, ": %s", message);
 356
 357         abort();
 358 }
 359
 360 void exceptions_throw_nosuchfielderror(classinfo *c, utf *name)
 361 {
 362         fprintf(stderr, "java.lang.NoSuchFieldError: ");
 363         utf_fprint_printable_ascii(stderr, c->name);
 364         fprintf(stderr, ".");
 365         utf_fprint_printable_ascii(stderr, name);
 366         fputc('\n', stderr);
 367
 368         abort();
 369 }
 370
 371 void exceptions_throw_nosuchmethoderror(classinfo *c, utf *name, utf *desc)
 372 {
 373         fprintf(stderr, "java.lang.NoSuchMethodError: ");
 374         utf_fprint_printable_ascii(stderr, c->name);
 375         fprintf(stderr, ".");
 376         utf_fprint_printable_ascii(stderr, name);
 377         utf_fprint_printable_ascii(stderr, desc);
 378         fputc('\n', stderr);
 379
 380         abort();
 381 }
 382
 383 void exceptions_throw_unsupportedclassversionerror(classinfo *c,
 384                                                                                                    const char *message, ...)
 385 {
 386         va_list ap;
 387
 388         fprintf(stderr, "java.lang.UnsupportedClassVersionError: " );
 389
 390         utf_display_printable_ascii(c->name);
 391         fprintf(stderr, ": ");
 392
 393         va_start(ap, message);
 394         vfprintf(stderr, message, ap);
 395         va_end(ap);
 396
 397         fputc('\n', stderr);
 398
 399         abort();
 400 }
 401
 402 void exceptions_throw_classnotfoundexception(utf *name)
 403 {
 404         fprintf(stderr, "java.lang.ClassNotFoundException: ");
 405         utf_fprint_printable_ascii(stderr, name);
 406         fputc('\n', stderr);
 407
 408         abort();
 409 }
 410
 411 void exceptions_throw_nullpointerexception(void)
 412 {
 413         fprintf(stderr, "java.lang.NullPointerException\n");
 414
 415         abort();
 416 }
 417
 418
 419 /* finalizer ******************************************************************/
 420
 421 void finalizer_notify(void)
 422 {
 423         vm_abort("finalizer_notify");
 424 }
 425
 426 void finalizer_run(void *o, void *p)
 427 {
 428         vm_abort("finalizer_run");
 429 }
 430
 431
 432 /* gc *************************************************************************/
 433
 434 void gc_reference_register(java_object_t **ref, int32_t reftype)
 435 {
 436         vm_abort("gc_reference_register");
 437 }
 438
 439 int64_t gc_get_heap_size(void)
 440 {
 441         return 0;
 442 }
 443
 444 int64_t gc_get_free_bytes(void)
 445 {
 446         return 0;
 447 }
 448
 449 int64_t gc_get_total_bytes(void)
 450 {
 451         return 0;
 452 }
 453
 454 int64_t gc_get_max_heap_size(void)
 455 {
 456         return 0;
 457 }
 458
 459
 460 /* heap ***********************************************************************/
 461
 462 void *heap_alloc_uncollectable(uint32_t bytelength)
 463 {
 464         return calloc(bytelength, 1);
 465 }
 466
 467 s4 heap_get_hashcode(java_object_t *o)
 468 {
 469         return 0;
 470 }
 471
 472
 473 /* jit ************************************************************************/
 474
 475 void jit_invalidate_code(methodinfo *m)
 476 {
 477         vm_abort("jit_invalidate_code");
 478 }
 479
 480
 481 /* llni ***********************************************************************/
 482
 483 void llni_critical_start()
 484 {
 485         vm_abort("llni_critical_start");
 486 }
 487
 488 void llni_critical_end()
 489 {
 490         vm_abort("llni_critical_end");
 491 }
 492
 493
 494 /* lock ***********************************************************************/
 495
 496 void lock_init_object_lock(java_object_t *o)
 497 {
 498 }
 499
 500 bool lock_monitor_enter(java_object_t *o)
 501 {
 502         return true;
 503 }
 504
 505 bool lock_monitor_exit(java_object_t *o)
 506 {
 507         return true;
 508 }
 509
 510
 511 /* md *************************************************************************/
 512
 513 void md_param_alloc(methoddesc *md)
 514 {
 515 }
 516
 517 void md_param_alloc_native(methoddesc *md)
 518 {
 519 }
 520
 521
 522 /* memory *********************************************************************/
 523
 524 void *mem_alloc(int32_t size)
 525 {
 526         /* real implementation in src/mm/memory.c clears memory */
 527
 528         return calloc(size, 1);
 529 }
 530
 531 void *mem_realloc(void *src, int32_t len1, int32_t len2)
 532 {
 533         return realloc(src, len2);
 534 }
 535
 536 void mem_free(void *m, int32_t size)
 537 {
 538         free(m);
 539 }
 540
 541 void *dump_alloc(int32_t size)
 542 {
 543         return malloc(size);
 544 }
 545
 546 void dump_release(int32_t size)
 547 {
 548 }
 549
 550 int32_t dump_size(void)
 551 {
 552         return 0;
 553 }
 554
 555
 556 /* primitive ******************************************************************/
 557
 558 classinfo *primitive_arrayclass_get_by_type(int type)
 559 {
 560         return NULL;
 561 }
 562
 563 classinfo *primitive_class_get_by_type(int type)
 564 {
 565         abort();
 566         return NULL;
 567 }
 568
 569 classinfo *primitive_class_get_by_char(char ch)
 570 {
 571         abort();
 572         return NULL;
 573 }
 574
 575
 576 /* properties *****************************************************************/
 577
 578 void properties_add(char *key, char *value)
 579 {
 580 }
 581
 582 char *properties_get(char *key)
 583 {
 584         return NULL;
 585 }
 586
 587
 588 /* resolve ********************************************************************/
 589
 590 bool resolve_class_from_typedesc(typedesc *d, bool checkaccess, bool link, classinfo **result)
 591 {
 592         abort();
 593
 594         return false;
 595 }
 596
 597 /* stupid resolving implementation used by resolve_classref_or_classinfo_eager */
 598 /* This function does eager resolving without any access checks.               */
 599
 600 static classinfo * dummy_resolve_class_from_name(classinfo *referer,
 601                                                  utf *classname,
 602                                                  bool checkaccess)
 603 {
 604         classinfo *cls = NULL;
 605         char *utf_ptr;
 606         int len;
 607
 608         assert(referer);
 609         assert(classname);
 610
 611         /* lookup if this class has already been loaded */
 612
 613         cls = classcache_lookup(referer->classloader, classname);
 614
 615         if (!cls) {
 616                 /* resolve array types */
 617
 618                 if (classname->text[0] == '[') {
 619                         utf_ptr = classname->text + 1;
 620                         len = classname->blength - 1;
 621
 622                         /* classname is an array type name */
 623
 624                         switch (*utf_ptr) {
 625                                 case 'L':
 626                                         utf_ptr++;
 627                                         len -= 2;
 628                                         /* FALLTHROUGH */
 629                                 case '[':
 630                                         /* the component type is a reference type */
 631                                         /* resolve the component type */
 632                                         if ((cls = dummy_resolve_class_from_name(referer,
 633                                                                            utf_new(utf_ptr,len),
 634                                                                            checkaccess)) == NULL)
 635                                                 return NULL; /* exception */
 636
 637                                         /* create the array class */
 638                                         cls = class_array_of(cls,false);
 639                                         if (!cls)
 640                                                 return NULL; /* exception */
 641                         }
 642                 }
 643
 644                 /* load the class */
 645                 if (!cls) {
 646                         if (!(cls = load_class_from_classloader(classname,
 647                                                                                                         referer->classloader)))
 648                                 return false; /* exception */
 649                 }
 650         }
 651
 652         /* the class is now loaded */
 653         assert(cls);
 654         assert(cls->state & CLASS_LOADED);
 655
 656         return cls;
 657 }
 658
 659
 660 classinfo * resolve_classref_or_classinfo_eager(classref_or_classinfo cls,
 661                                                                                                 bool checkaccess)
 662 {
 663         classinfo         *c;
 664
 665         assert(cls.any);
 666
 667         if (IS_CLASSREF(cls)) {
 668                 /* we must resolve this reference */
 669
 670                 if ((c = dummy_resolve_class_from_name(cls.ref->referer, cls.ref->name,
 671                                                                                    checkaccess)) == NULL)
 672                         return NULL;
 673         }
 674         else {
 675                 /* cls has already been resolved */
 676                 c = cls.cls;
 677         }
 678
 679         assert(c);
 680         assert(c->state & CLASS_LOADED);
 681
 682         /* succeeded */
 683         return c;
 684 }
 685
 686
 687 /* stacktrace *****************************************************************/
 688
 689 java_handle_objectarray_t *stacktrace_getClassContext()
 690 {
 691         return NULL;
 692 }
 693
 694
 695 /* threads ********************************************************************/
 696
 697 intptr_t threads_get_current_tid(void)
 698 {
 699         return 0;
 700 }
 701
 702 void threads_cast_stopworld(void)
 703 {
 704 }
 705
 706 void threads_cast_startworld(void)
 707 {
 708 }
 709
 710
 711 /* vm *************************************************************************/
 712
 713 void vm_printconfig(void)
 714 {
 715 }
 716
 717 void vm_abort(const char *text, ...)
 718 {
 719         va_list ap;
 720
 721         /* print the log message */
 722
 723         va_start(ap, text);
 724         vfprintf(stderr, text, ap);
 725         va_end(ap);
 726
 727         /* now abort the VM */
 728
 729         abort();
 730 }
 731
 732 java_handle_t *vm_call_method(methodinfo *m, java_handle_t *o, ...)
 733 {
 734         return NULL;
 735 }
 736
 737
 738 /* XXX */
 739
 740 void stringtable_update(void)
 741 {
 742         log_println("stringtable_update: REMOVE ME!");
 743 }
 744
 745 java_object_t *literalstring_new(utf *u)
 746 {
 747         log_println("literalstring_new: REMOVE ME!");
 748
 749         return NULL;
 750 }
 751
 752
 753 void print_dynamic_super_statistics(void)
 754 {
 755 }
 756
 757
 758 /*
 759  * These are local overrides for various environment variables in Emacs.
 760  * Please do not remove this and leave it at the end of the file, where
 761  * Emacs will automagically detect them.
 762  * ---------------------------------------------------------------------
 763  * Local variables:
 764  * mode: c
 765  * indent-tabs-mode: t
 766  * c-basic-offset: 4
 767  * tab-width: 4
 768  * End:
 769  * vim:noexpandtab:sw=4:ts=4:
 770  */