src/vm/builtin.h

   1 /* vm/builtin.h - prototypes of builtin functions
   2
   3    Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
   4    R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
   5    C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
   6    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., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Reinhard Grafl
  28
  29    Changes: Edwin Steiner
  30
  31    $Id: builtin.h 1893 2005-01-31 17:06:41Z twisti $
  32
  33 */
  34
  35
  36 #ifndef _BUILTIN_H
  37 #define _BUILTIN_H
  38
  39 #include "arch.h"
  40 #include "config.h"
  41 #include "toolbox/logging.h"
  42
  43 #if defined(USE_THREADS)
  44 # if defined(NATIVE_THREADS)
  45 #  include "threads/native/threads.h"
  46 # else
  47 #  include "threads/green/threads.h"
  48 # endif
  49 #endif
  50
  51
  52 /* define infinity for floating point numbers */
  53
  54 #define FLT_NAN     0x7fc00000
  55 #define FLT_POSINF  0x7f800000
  56 #define FLT_NEGINF  0xff800000
  57
  58 /* define infinity for double floating point numbers */
  59
  60 #define DBL_NAN     0x7ff8000000000000LL
  61 #define DBL_POSINF  0x7ff0000000000000LL
  62 #define DBL_NEGINF  0xfff0000000000000LL
  63
  64
  65 /* float versions are not defined in gnu classpath's fdlibm */
  66
  67 #define copysignf    copysign
  68 #define finitef      finite
  69 #define fmodf        fmod
  70 #define isnanf       isnan
  71
  72
  73 /**********************************************************************/
  74 /* BUILTIN FUNCTIONS TABLE                                            */
  75 /**********************************************************************/
  76
  77 /* IMPORTANT:
  78  * For each builtin function which is used in a BUILTIN* opcode there
  79  * must be an entry in the builtin_desc table in jit/jit.c.
  80  */
  81
  82 typedef struct builtin_descriptor builtin_descriptor;
  83
  84 /* There is a builtin_descriptor in builtin_desc for every builtin
  85  * function used in BUILTIN* opcodes.
  86  */
  87 struct builtin_descriptor {
  88         int         opcode;   /* opcode which is replaced by this builtin */
  89                               /* (255 means no automatic replacement,     */
  90                               /*    0 means end of list.)                 */
  91         functionptr builtin;  /* the builtin function (specify BUILTIN_...*/
  92                               /* macro)                                   */
  93         int         icmd;     /* the BUILTIN* opcode to use (# of args)   */
  94         u1          type_s1;  /* type of 1st argument                     */
  95         u1          type_s2;  /* type of 2nd argument, or TYPE_VOID       */
  96         u1          type_s3;  /* type of 3rd argument, or TYPE_VOID       */
  97         u1          type_d;   /* type of result (may be TYPE_VOID)        */
  98         bool        supported;/* is <opcode> supported without builtin?   */
  99         bool        isfloat;  /* is this a floating point operation?      */
 100         char        *name;    /* display name of the builtin function     */
 101 };
 102
 103 extern builtin_descriptor builtin_desc[];
 104
 105 /**********************************************************************/
 106 /* GLOBAL VARIABLES                                                   */
 107 /**********************************************************************/
 108
 109 #define THREADSPECIFIC
 110 #define exceptionptr (&_exceptionptr)
 111 #define threadrootmethod (&_threadrootmethod)
 112
 113 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
 114 #ifdef HAVE___THREAD
 115
 116 #undef THREADSPECIFIC
 117 #define THREADSPECIFIC __thread
 118
 119 #endif
 120
 121 #undef exceptionptr
 122 #undef threadrootmethod
 123 #define exceptionptr builtin_get_exceptionptrptr()
 124 #define threadrootmethod  builtin_get_threadrootmethod()
 125 #endif
 126
 127 #if !defined(USE_THREADS) || !defined(NATIVE_THREADS)
 128 extern java_objectheader *_exceptionptr;
 129 extern methodinfo* _threadrootmethod;
 130 #endif
 131
 132
 133 /**********************************************************************/
 134 /* BUILTIN FUNCTIONS                                                  */
 135 /**********************************************************************/
 136
 137 /* NOTE: Builtin functions which are used in the BUILTIN* opcodes must
 138  * have a BUILTIN_... macro defined as seen below. In code dealing
 139  * with the BUILTIN* opcodes the functions may only be addressed by
 140  * these macros, never by their actual name! (This helps to make this
 141  * code more portable.)
 142  *
 143  * C and assembler code which does not deal with the BUILTIN* opcodes,
 144  * can use the builtin functions normally (like all other functions).
 145  *
 146  * IMPORTANT:
 147  * For each builtin function which is used in a BUILTIN* opcode there
 148  * must be an entry in the builtin_desc table in jit/jit.c.
 149  *
 150  * Below each prototype is either the BUILTIN_ macro definition or a
 151  * comment specifiying that this function is not used in BUILTIN*
 152  * opcodes.
 153  *
 154  * (The BUILTIN* opcodes are ICMD_BUILTIN1, ICMD_BUILTIN2 and
 155  * ICMD_BUILTIN3.)
 156  */
 157
 158 s4 builtin_instanceof(java_objectheader *obj, classinfo *class);
 159 #define BUILTIN_instanceof (functionptr) builtin_instanceof
 160 s4 builtin_isanysubclass (classinfo *sub, classinfo *super);
 161 /* NOT AN OP */
 162 s4 builtin_isanysubclass_vftbl (vftbl_t *sub, vftbl_t *super);
 163 /* NOT AN OP */
 164 s4 builtin_checkcast(java_objectheader *obj, classinfo *class);
 165 /* NOT AN OP */
 166 s4 builtin_arrayinstanceof(java_objectheader *obj, vftbl_t *target);
 167 #define BUILTIN_arrayinstanceof (functionptr) builtin_arrayinstanceof
 168
 169 #if defined(__I386__)
 170 s4 asm_builtin_arrayinstanceof(java_objectheader *obj, classinfo *class); /* XXX ? */
 171 #undef  BUILTIN_arrayinstanceof
 172 #define BUILTIN_arrayinstanceof (functionptr) asm_builtin_arrayinstanceof
 173 #endif
 174
 175 s4 builtin_checkarraycast(java_objectheader *obj, vftbl_t *target);
 176 /* NOT AN OP */
 177 s4 asm_builtin_checkarraycast(java_objectheader *obj, vftbl_t *target);
 178 #define BUILTIN_checkarraycast (functionptr) asm_builtin_checkarraycast
 179
 180 java_objectheader *builtin_throw_exception(java_objectheader *exception);
 181 /* NOT AN OP */
 182 java_objectheader *builtin_trace_exception(java_objectheader *xptr,
 183                                                                                    methodinfo *m,
 184                                                                                    void *pos,
 185                                                                                    s4 line,
 186                                                                                    s4 noindent);
 187 /* NOT AN OP */
 188
 189 java_objectheader *builtin_new(classinfo *c);
 190 #ifdef __I386__
 191 java_objectheader *asm_builtin_new(classinfo *c);
 192 #define BUILTIN_new (functionptr) asm_builtin_new
 193 #else
 194 #define BUILTIN_new (functionptr) builtin_new
 195 #endif
 196
 197 java_arrayheader *builtin_newarray(s4 size, vftbl_t *arrayvftbl);
 198 #define BUILTIN_newarray (functionptr) builtin_newarray
 199 java_objectarray *builtin_anewarray(s4 size, classinfo *component);
 200 /* NOT AN OP */
 201
 202 #if defined(__I386__)
 203 void asm_builtin_newarray(s4 size, vftbl_t *arrayvftbl);
 204 #undef  BUILTIN_newarray
 205 #define BUILTIN_newarray (functionptr) asm_builtin_newarray
 206 #endif
 207
 208 java_booleanarray *builtin_newarray_boolean(s4 size);
 209 #define BUILTIN_newarray_boolean (functionptr) builtin_newarray_boolean
 210 java_chararray *builtin_newarray_char(s4 size);
 211 #define BUILTIN_newarray_char (functionptr) builtin_newarray_char
 212 java_floatarray *builtin_newarray_float(s4 size);
 213 #define BUILTIN_newarray_float (functionptr) builtin_newarray_float
 214 java_doublearray *builtin_newarray_double(s4 size);
 215 #define BUILTIN_newarray_double (functionptr) builtin_newarray_double
 216 java_bytearray *builtin_newarray_byte(s4 size);
 217 #define BUILTIN_newarray_byte (functionptr) builtin_newarray_byte
 218 java_shortarray *builtin_newarray_short(s4 size);
 219 #define BUILTIN_newarray_short (functionptr) builtin_newarray_short
 220 java_intarray *builtin_newarray_int(s4 size);
 221 #define BUILTIN_newarray_int (functionptr) builtin_newarray_int
 222 java_longarray *builtin_newarray_long(s4 size);
 223 #define BUILTIN_newarray_long (functionptr) builtin_newarray_long
 224 java_arrayheader *builtin_nmultianewarray(int n, vftbl_t *arrayvftbl, long *dims);
 225 /*  java_arrayheader *builtin_nmultianewarray(int n, classinfo *arrayclass, long *dims); */
 226 /* NOT AN OP */
 227
 228 s4 builtin_canstore(java_objectarray *a, java_objectheader *o);
 229 /* NOT AN OP */
 230 void asm_builtin_aastore(java_objectarray *a, s4 index, java_objectheader *o);
 231 #define BUILTIN_aastore (functionptr) asm_builtin_aastore
 232
 233 #if defined(TRACE_ARGS_NUM)
 234 void builtin_trace_args(s8 a0, s8 a1, s8 a2, s8 a3,
 235 #if TRACE_ARGS_NUM >= 6
 236                                                 s8 a4, s8 a5,
 237 #endif /* TRACE_ARGS_NUM >= 6 */
 238 #if TRACE_ARGS_NUM == 8
 239                                                 s8 a6, s8 a7,
 240 #endif /* TRACE_ARGS_NUM == 8 */
 241                                                 methodinfo *m);
 242 /* NOT AN OP */
 243 #endif /* defined(TRACE_ARGS_NUM) */
 244 void builtin_displaymethodstart(methodinfo *m);
 245 /* NOT AN OP */
 246 void builtin_displaymethodstop(methodinfo *m, s8 l, double d, float f);
 247 /* NOT AN OP */
 248
 249 #if defined(USE_THREADS)
 250 void builtin_monitorenter(java_objectheader *o);
 251 /* NOT AN OP */
 252 void builtin_staticmonitorenter(classinfo *c);
 253 /* NOT AN OP */
 254 void asm_builtin_monitorenter(java_objectheader *o);
 255 #define BUILTIN_monitorenter (functionptr) asm_builtin_monitorenter
 256 void *builtin_monitorexit(java_objectheader *o);
 257 /* NOT AN OP */
 258 void *asm_builtin_monitorexit(java_objectheader *o);
 259 #define BUILTIN_monitorexit (functionptr) asm_builtin_monitorexit
 260 #endif
 261
 262 s4 builtin_idiv(s4 a, s4 b);
 263 /* NOT AN OP */
 264 s4 asm_builtin_idiv(s4 a, s4 b);
 265 #define BUILTIN_idiv (functionptr) asm_builtin_idiv
 266 s4 builtin_irem(s4 a, s4 b);
 267 /* NOT AN OP */
 268 s4 asm_builtin_irem(s4 a, s4 b);
 269 #define BUILTIN_irem (functionptr) asm_builtin_irem
 270
 271 s8 builtin_ladd(s8 a, s8 b);
 272 #define BUILTIN_ladd (functionptr) builtin_ladd
 273 s8 builtin_lsub(s8 a, s8 b);
 274 #define BUILTIN_lsub (functionptr) builtin_lsub
 275 s8 builtin_lmul(s8 a, s8 b);
 276 #define BUILTIN_lmul (functionptr) builtin_lmul
 277 s8 builtin_ldiv(s8 a, s8 b);
 278 /* NOT AN OP */
 279 s8 asm_builtin_ldiv(s8 a, s8 b);
 280 #define BUILTIN_ldiv (functionptr) asm_builtin_ldiv
 281 s8 builtin_lrem(s8 a, s8 b);
 282 /* NOT AN OP */
 283 s8 asm_builtin_lrem(s8 a, s8 b);
 284 #define BUILTIN_lrem (functionptr) asm_builtin_lrem
 285 s8 builtin_lshl(s8 a, s4 b);
 286 #define BUILTIN_lshl (functionptr) builtin_lshl
 287 s8 builtin_lshr(s8 a, s4 b);
 288 #define BUILTIN_lshr (functionptr) builtin_lshr
 289 s8 builtin_lushr(s8 a, s4 b);
 290 #define BUILTIN_lushr (functionptr) builtin_lushr
 291 s8 builtin_land(s8 a, s8 b);
 292 #define BUILTIN_land (functionptr) builtin_land
 293 s8 builtin_lor(s8 a, s8 b);
 294 #define BUILTIN_lor (functionptr) builtin_lor
 295 s8 builtin_lxor(s8 a, s8 b);
 296 #define BUILTIN_lxor (functionptr) builtin_lxor
 297 s8 builtin_lneg(s8 a);
 298 #define BUILTIN_lneg (functionptr) builtin_lneg
 299 s4 builtin_lcmp(s8 a, s8 b);
 300 #define BUILTIN_lcmp (functionptr) builtin_lcmp
 301
 302 float builtin_fadd(float a, float b);
 303 #define BUILTIN_fadd (functionptr) builtin_fadd
 304 float builtin_fsub(float a, float b);
 305 #define BUILTIN_fsub (functionptr) builtin_fsub
 306 float builtin_fmul(float a, float b);
 307 #define BUILTIN_fmul (functionptr) builtin_fmul
 308 float builtin_fdiv(float a, float b);
 309 #define BUILTIN_fdiv (functionptr) builtin_fdiv
 310 float builtin_fneg(float a);
 311 #define BUILTIN_fneg (functionptr) builtin_fneg
 312 s4 builtin_fcmpl(float a, float b);
 313 #define BUILTIN_fcmpl (functionptr) builtin_fcmpl
 314 s4 builtin_fcmpg(float a, float b);
 315 #define BUILTIN_fcmpg (functionptr) builtin_fcmpg
 316 float builtin_frem(float a, float b);
 317 #define BUILTIN_frem (functionptr) builtin_frem
 318
 319 double builtin_dadd(double a, double b);
 320 #define BUILTIN_dadd (functionptr) builtin_dadd
 321 double builtin_dsub(double a, double b);
 322 #define BUILTIN_dsub (functionptr) builtin_dsub
 323 double builtin_dmul(double a, double b);
 324 #define BUILTIN_dmul (functionptr) builtin_dmul
 325 double builtin_ddiv(double a, double b);
 326 #define BUILTIN_ddiv (functionptr) builtin_ddiv
 327 double builtin_dneg(double a);
 328 #define BUILTIN_dneg (functionptr) builtin_dneg
 329 s4 builtin_dcmpl(double a, double b);
 330 #define BUILTIN_dcmpl (functionptr) builtin_dcmpl
 331 s4 builtin_dcmpg(double a, double b);
 332 #define BUILTIN_dcmpg (functionptr) builtin_dcmpg
 333 double builtin_drem(double a, double b);
 334 #define BUILTIN_drem (functionptr) builtin_drem
 335
 336 s8       builtin_i2l(s4 i);
 337 /* NOT AN OP */
 338 float    builtin_i2f(s4 i);
 339 #define BUILTIN_i2f (functionptr) builtin_i2f
 340 double   builtin_i2d(s4 i);
 341 #define BUILTIN_i2d (functionptr) builtin_i2d
 342 s4       builtin_l2i(s8 l);
 343 /* NOT AN OP */
 344 float    builtin_l2f(s8 l);
 345 #define BUILTIN_l2f (functionptr) builtin_l2f
 346 double   builtin_l2d(s8 l);
 347 #define BUILTIN_l2d (functionptr) builtin_l2d
 348
 349 s4       builtin_f2i(float a);
 350 #define BUILTIN_f2i (functionptr) builtin_f2i
 351 s4       asm_builtin_f2i(float a);
 352 /* NOT AN OP */
 353 s8       builtin_f2l(float a);
 354 #define BUILTIN_f2l (functionptr) builtin_f2l
 355 s8       asm_builtin_f2l(float a);
 356 /* NOT AN OP */
 357
 358 double   builtin_f2d(float a);
 359 #define BUILTIN_f2d (functionptr) builtin_f2d
 360
 361 s4       builtin_d2i(double a);
 362 #define BUILTIN_d2i (functionptr) builtin_d2i
 363 s4       asm_builtin_d2i(double a);
 364 /* NOT AN OP */
 365 s8       builtin_d2l(double a);
 366 #define BUILTIN_d2l (functionptr) builtin_d2l
 367 s8       asm_builtin_d2l(double a);
 368 /* NOT AN OP */
 369
 370 float    builtin_d2f(double a);
 371 #define BUILTIN_d2f (functionptr) builtin_d2f
 372
 373 java_arrayheader *builtin_clone_array(void *env, java_arrayheader *o);
 374 /* NOT AN OP */
 375
 376 /* builtin_dummy just panics if it is executed. */
 377 s4 builtin_dummy(void);
 378 /* NOT AN OP */
 379
 380 /* conversion helper functions */
 381 inline float intBitsToFloat(s4 i);
 382 inline float longBitsToDouble(s8 l);
 383
 384 /* this is a wrapper for calls from asmpart */
 385 java_objectheader **builtin_asm_get_exceptionptrptr(void);
 386
 387 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
 388 static inline java_objectheader **builtin_get_exceptionptrptr(void);
 389 /* NOT AN OP */
 390 static inline methodinfo **builtin_get_threadrootmethod(void);
 391 /* NOT AN OP */
 392
 393 inline java_objectheader **builtin_get_exceptionptrptr(void)
 394 {
 395         return &THREADINFO->_exceptionptr;
 396 }
 397
 398 inline methodinfo **builtin_get_threadrootmethod(void)
 399 {
 400         return &THREADINFO->_threadrootmethod;
 401 }
 402 #endif
 403
 404
 405 /* returns the root method of a thread. this is used in asmpart.S and delivers the abort condition
 406    for the stack unwinding for getClassContext and getClassLoader. For the main thread this is the main function.
 407    Otherwhise it is the thread's run method (at least that's how I see it) (jowenn) */
 408 methodinfo *builtin_asm_get_threadrootmethod(void);
 409
 410 /* returns the current top element of the stack frame info list (needed for unwinding across native functions) */
 411 /* on i386 this is a pointer to a structure
 412                 ------------------------------------------------
 413                 | return adress out of native stub              |
 414                 | pointer to method info                        | either i have to save an arbitrary adress within this native stub or the pointer to the method info, both are equaly costly, I have chosen the method  info (JOWENN)
 415                 | pointer to thread specific top of this list   |<----stack frame begin
 416 points here---->| previous element in list                      |
 417                 ------------------------------------------------
 418 */
 419 void *builtin_asm_get_stackframeinfo(void);
 420 stacktraceelement *builtin_stacktrace_copy(stacktraceelement **,stacktraceelement *begin, stacktraceelement *end);
 421 #endif /* _BUILTIN_H */
 422
 423
 424 /*
 425  * These are local overrides for various environment variables in Emacs.
 426  * Please do not remove this and leave it at the end of the file, where
 427  * Emacs will automagically detect them.
 428  * ---------------------------------------------------------------------
 429  * Local variables:
 430  * mode: c
 431  * indent-tabs-mode: t
 432  * c-basic-offset: 4
 433  * tab-width: 4
 434  * End:
 435  */