/* src/vm/jit/dseg.c - data segment handling stuff
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
This file is part of CACAO.
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Reinhard Grafl
- Andreas Krall
-
- Changes: Christian Thalinger
- Joseph Wenninger
-
- $Id: dseg.c 4595 2006-03-14 20:51:12Z edwin $
-
*/
#include "config.h"
+#include <assert.h>
+
#include "vm/types.h"
-#include <assert.h>
-#include "mm/memory.h"
-#include "vm/jit/codegen-common.h"
+#include "mm/memory.hpp"
+
+#include "vm/options.h"
+
+#include "vm/jit/codegen-common.hpp"
+#include "vm/jit/methodheader.h"
-/* desg_increase ***************************************************************
+/* dseg_finish *****************************************************************
- Doubles data area.
+ Fills the data segment with the values stored.
*******************************************************************************/
-void dseg_increase(codegendata *cd)
+void dseg_finish(jitdata *jd)
{
- u1 *newstorage;
+ codeinfo *code;
+ codegendata *cd;
+ dsegentry *de;
+
+ /* get required compiler data */
+
+ code = jd->code;
+ cd = jd->cd;
+
+ /* process all data segment entries */
- newstorage = DMNEW(u1, cd->dsegsize * 2);
+ for (de = cd->dseg; de != NULL; de = de->next) {
+ switch (de->type) {
+ case TYPE_INT:
+ *((s4 *) (code->entrypoint + de->disp)) = de->val.i;
+ break;
- MCOPY(newstorage + cd->dsegsize, cd->dsegtop - cd->dsegsize, u1,
- cd->dsegsize);
+ case TYPE_LNG:
+ *((s8 *) (code->entrypoint + de->disp)) = de->val.l;
+ break;
- cd->dsegtop = newstorage;
- cd->dsegsize *= 2;
- cd->dsegtop += cd->dsegsize;
+ case TYPE_FLT:
+ *((float *) (code->entrypoint + de->disp)) = de->val.f;
+ break;
+
+ case TYPE_DBL:
+ *((double *) (code->entrypoint + de->disp)) = de->val.d;
+ break;
+
+ case TYPE_ADR:
+ *((void **) (code->entrypoint + de->disp)) = de->val.a;
+ break;
+ }
+ }
}
-s4 dseg_adds4_increase(codegendata *cd, s4 value)
+static s4 dseg_find_s4(codegendata *cd, s4 value)
{
- dseg_increase(cd);
+ dsegentry *de;
+
+ /* search all data segment entries for a matching entry */
+
+ for (de = cd->dseg; de != NULL; de = de->next) {
+ if (IS_INT_TYPE(de->type))
+ if (de->flags & DSEG_FLAG_READONLY)
+ if (de->val.i == value)
+ return de->disp;
+ }
- *((s4 *) (cd->dsegtop - cd->dseglen)) = value;
+ /* no matching entry was found */
- return -(cd->dseglen);
+ return 0;
}
-s4 dseg_adds4(codegendata *cd, s4 value)
+static s4 dseg_find_s8(codegendata *cd, s8 value)
{
- s4 *dataptr;
+ dsegentry *de;
- cd->dseglen += 4;
- dataptr = (s4 *) (cd->dsegtop - cd->dseglen);
+ /* search all data segment entries for a matching entry */
- if (cd->dseglen > cd->dsegsize)
- return dseg_adds4_increase(cd, value);
+ for (de = cd->dseg; de != NULL; de = de->next) {
+ if (IS_LNG_TYPE(de->type))
+ if (de->flags & DSEG_FLAG_READONLY)
+ if (de->val.l == value)
+ return de->disp;
+ }
- *dataptr = value;
+ /* no matching entry was found */
- return -(cd->dseglen);
+ return 0;
}
-s4 dseg_adds8_increase(codegendata *cd, s8 value)
+static s4 dseg_find_float(codegendata *cd, float value)
{
- dseg_increase(cd);
+ dsegentry *de;
+ imm_union val;
+
+ /* we compare the hex value of the float as 0.0 == -0.0 */
- *((s8 *) (cd->dsegtop - cd->dseglen)) = value;
+ val.f = value;
+
+ /* search all data segment entries for a matching entry */
+
+ for (de = cd->dseg; de != NULL; de = de->next) {
+ if (IS_FLT_TYPE(de->type))
+ if (de->flags & DSEG_FLAG_READONLY)
+ if (de->val.i == val.i)
+ return de->disp;
+ }
- return -(cd->dseglen);
+ /* no matching entry was found */
+
+ return 0;
}
-s4 dseg_adds8(codegendata *cd, s8 value)
+static s4 dseg_find_double(codegendata *cd, double value)
{
- s8 *dataptr;
+ dsegentry *de;
+ imm_union val;
+
+ /* we compare the hex value of the double as 0.0 == -0.0 */
+
+ val.d = value;
- cd->dseglen = ALIGN(cd->dseglen + 8, 8);
- dataptr = (s8 *) (cd->dsegtop - cd->dseglen);
+ /* search all data segment entries for a matching entry */
- if (cd->dseglen > cd->dsegsize)
- return dseg_adds8_increase(cd, value);
+ for (de = cd->dseg; de != NULL; de = de->next) {
+ if (IS_DBL_TYPE(de->type))
+ if (de->flags & DSEG_FLAG_READONLY)
+ if (de->val.l == val.l)
+ return de->disp;
+ }
- *dataptr = value;
+ /* no matching entry was found */
- return -(cd->dseglen);
+ return 0;
}
-s4 dseg_addfloat_increase(codegendata *cd, float value)
+static s4 dseg_find_address(codegendata *cd, void *value)
{
- dseg_increase(cd);
+ dsegentry *de;
+
+ /* search all data segment entries for a matching entry */
+
+ for (de = cd->dseg; de != NULL; de = de->next) {
+ if (IS_ADR_TYPE(de->type))
+ if (de->flags & DSEG_FLAG_READONLY)
+ if (de->val.a == value)
+ return de->disp;
+ }
- *((float *) (cd->dsegtop - cd->dseglen)) = value;
+ /* no matching entry was found */
- return -(cd->dseglen);
+ return 0;
}
-s4 dseg_addfloat(codegendata *cd, float value)
+/* dseg_add_s4_intern **********************************************************
+
+ Internal function to add an s4 value to the data segment.
+
+*******************************************************************************/
+
+static s4 dseg_add_s4_intern(codegendata *cd, s4 value, u4 flags)
{
- float *dataptr;
+ dsegentry *de;
+
+ /* Increase data segment size, which is also the displacement into
+ the data segment. */
cd->dseglen += 4;
- dataptr = (float *) (cd->dsegtop - cd->dseglen);
- if (cd->dseglen > cd->dsegsize)
- return dseg_addfloat_increase(cd, value);
+ /* allocate new entry */
- *dataptr = value;
+ de = DNEW(dsegentry);
- return -(cd->dseglen);
+ de->type = TYPE_INT;
+ de->flags = flags;
+ de->disp = -(cd->dseglen);
+ de->val.i = value;
+ de->next = cd->dseg;
+
+ /* insert into the chain */
+
+ cd->dseg = de;
+
+ return de->disp;
}
-s4 dseg_adddouble_increase(codegendata *cd, double value)
+/* dseg_add_unique_s4 **********************************************************
+
+ Adds uniquely an s4 value to the data segment.
+
+*******************************************************************************/
+
+s4 dseg_add_unique_s4(codegendata *cd, s4 value)
{
- dseg_increase(cd);
+ s4 disp;
- *((double *) (cd->dsegtop - cd->dseglen)) = value;
+ disp = dseg_add_s4_intern(cd, value, DSEG_FLAG_UNIQUE);
- return -(cd->dseglen);
+ return disp;
}
-s4 dseg_adddouble(codegendata *cd, double value)
+/* dseg_add_s4 *****************************************************************
+
+ Adds an s4 value to the data segment. It tries to reuse previously
+ added values.
+
+*******************************************************************************/
+
+s4 dseg_add_s4(codegendata *cd, s4 value)
{
- double *dataptr;
+ s4 disp;
- cd->dseglen = ALIGN(cd->dseglen + 8, 8);
- dataptr = (double *) (cd->dsegtop - cd->dseglen);
+ /* search the data segment if the value is already stored */
- if (cd->dseglen > cd->dsegsize)
- return dseg_adddouble_increase(cd, value);
+ disp = dseg_find_s4(cd, value);
- *dataptr = value;
+ if (disp != 0)
+ return disp;
+
+ disp = dseg_add_s4_intern(cd, value, DSEG_FLAG_READONLY);
- return -(cd->dseglen);
+ return disp;
}
-void dseg_addtarget(codegendata *cd, basicblock *target)
+/* dseg_add_s8_intern **********************************************************
+
+ Internal function to add an s8 value to the data segment.
+
+*******************************************************************************/
+
+static s4 dseg_add_s8_intern(codegendata *cd, s8 value, u4 flags)
{
- jumpref *jr;
+ dsegentry *de;
- jr = DNEW(jumpref);
+ /* Increase data segment size, which is also the displacement into
+ the data segment. */
- jr->tablepos = dseg_addaddress(cd, NULL);
- jr->target = target;
- jr->next = cd->jumpreferences;
+ cd->dseglen = MEMORY_ALIGN(cd->dseglen + 8, 8);
- cd->jumpreferences = jr;
+ /* allocate new entry */
+
+ de = DNEW(dsegentry);
+
+ de->type = TYPE_LNG;
+ de->flags = flags;
+ de->disp = -(cd->dseglen);
+ de->val.l = value;
+ de->next = cd->dseg;
+
+ /* insert into the chain */
+
+ cd->dseg = de;
+
+ return de->disp;
}
-/* dseg_addlinenumbertablesize *************************************************
+/* dseg_add_unique_s8 **********************************************************
- XXX
+ Adds uniquely an s8 value to the data segment.
*******************************************************************************/
-void dseg_addlinenumbertablesize(codegendata *cd)
+s4 dseg_add_unique_s8(codegendata *cd, s8 value)
{
-#if SIZEOF_VOID_P == 8
- /* 4-byte ALIGNMENT PADDING */
+ s4 disp;
- dseg_adds4(cd, 0);
-#endif
+ disp = dseg_add_s8_intern(cd, value, DSEG_FLAG_UNIQUE);
- cd->linenumbertablesizepos = dseg_addaddress(cd, NULL);
- cd->linenumbertablestartpos = dseg_addaddress(cd, NULL);
+ return disp;
+}
-#if SIZEOF_VOID_P == 8
- /* 4-byte ALIGNMENT PADDING */
- dseg_adds4(cd, 0);
-#endif
+/* dseg_add_s8 *****************************************************************
+
+ Adds an s8 value to the data segment. It tries to reuse previously
+ added values.
+
+*******************************************************************************/
+
+s4 dseg_add_s8(codegendata *cd, s8 value)
+{
+ s4 disp;
+
+ /* search the data segment if the value is already stored */
+
+ disp = dseg_find_s8(cd, value);
+
+ if (disp != 0)
+ return disp;
+
+ disp = dseg_add_s8_intern(cd, value, DSEG_FLAG_READONLY);
+
+ return disp;
+}
+
+
+/* dseg_add_float_intern *******************************************************
+
+ Internal function to add a float value to the data segment.
+
+*******************************************************************************/
+
+static s4 dseg_add_float_intern(codegendata *cd, float value, u4 flags)
+{
+ dsegentry *de;
+
+ /* Increase data segment size, which is also the displacement into
+ the data segment. */
+
+ cd->dseglen += 4;
+
+ /* allocate new entry */
+
+ de = DNEW(dsegentry);
+
+ de->type = TYPE_FLT;
+ de->flags = flags;
+ de->disp = -(cd->dseglen);
+ de->val.f = value;
+ de->next = cd->dseg;
+
+ /* insert into the chain */
+
+ cd->dseg = de;
+
+ return de->disp;
+}
+
+
+/* dseg_add_unique_float *******************************************************
+
+ Adds uniquely an float value to the data segment.
+
+*******************************************************************************/
+
+s4 dseg_add_unique_float(codegendata *cd, float value)
+{
+ s4 disp;
+
+ disp = dseg_add_float_intern(cd, value, DSEG_FLAG_UNIQUE);
+
+ return disp;
}
-/* dseg_addlinenumber **********************************************************
+/* dseg_add_float **************************************************************
+
+ Adds an float value to the data segment. It tries to reuse
+ previously added values.
+
+*******************************************************************************/
+
+s4 dseg_add_float(codegendata *cd, float value)
+{
+ s4 disp;
+
+ /* search the data segment if the value is already stored */
+
+ disp = dseg_find_float(cd, value);
+
+ if (disp != 0)
+ return disp;
+
+ disp = dseg_add_float_intern(cd, value, DSEG_FLAG_READONLY);
+
+ return disp;
+}
+
- Add a line number reference.
+/* dseg_add_double_intern ******************************************************
- IN:
- cd.............current codegen data
- linenumber.....number of line that starts with the given mcodeptr
- mcodeptr.......start mcodeptr of line
+ Internal function to add a double value to the data segment.
*******************************************************************************/
-void dseg_addlinenumber(codegendata *cd, u2 linenumber, u1 *mcodeptr)
+static s4 dseg_add_double_intern(codegendata *cd, double value, u4 flags)
{
- linenumberref *lr;
+ dsegentry *de;
+
+ /* Increase data segment size, which is also the displacement into
+ the data segment. */
+
+ cd->dseglen = MEMORY_ALIGN(cd->dseglen + 8, 8);
+
+ /* allocate new entry */
+
+ de = DNEW(dsegentry);
+
+ de->type = TYPE_DBL;
+ de->flags = flags;
+ de->disp = -(cd->dseglen);
+ de->val.d = value;
+ de->next = cd->dseg;
- lr = DNEW(linenumberref);
+ /* insert into the chain */
- lr->linenumber = linenumber;
- lr->tablepos = 0;
- lr->targetmpc = mcodeptr - cd->mcodebase;
- lr->next = cd->linenumberreferences;
+ cd->dseg = de;
- cd->linenumberreferences = lr;
+ return de->disp;
}
-/* dseg_addlinenumber_inline_start *********************************************
+/* dseg_add_unique_double ******************************************************
- Add a marker to the line number table indicating the start of an inlined
- method body. (see doc/inlining_stacktrace.txt)
+ Adds uniquely a double value to the data segment.
- IN:
- cd.............current codegen data
- iptr...........the ICMD_INLINE_START instruction
- mcodeptr.......start mcodeptr of inlined body
+*******************************************************************************/
+
+s4 dseg_add_unique_double(codegendata *cd, double value)
+{
+ s4 disp;
+
+ disp = dseg_add_double_intern(cd, value, DSEG_FLAG_UNIQUE);
+
+ return disp;
+}
+
+
+/* dseg_add_double *************************************************************
+
+ Adds a double value to the data segment. It tries to reuse
+ previously added values.
*******************************************************************************/
-void dseg_addlinenumber_inline_start(codegendata *cd,
- instruction *iptr,
- u1 *mcodeptr)
+s4 dseg_add_double(codegendata *cd, double value)
{
- linenumberref *lr;
+ s4 disp;
- lr = DNEW(linenumberref);
+ /* search the data segment if the value is already stored */
- lr->linenumber = (-2); /* marks start of inlined method */
- lr->tablepos = 0;
- lr->targetmpc = mcodeptr - cd->mcodebase;
- lr->next = cd->linenumberreferences;
+ disp = dseg_find_double(cd, value);
- cd->linenumberreferences = lr;
+ if (disp != 0)
+ return disp;
+
+ disp = dseg_add_double_intern(cd, value, DSEG_FLAG_READONLY);
- iptr->target = mcodeptr; /* store for corresponding INLINE_END */
+ return disp;
}
-/* dseg_addlinenumber_inline_end ***********************************************
+/* dseg_add_address_intern *****************************************************
- Add a marker to the line number table indicating the end of an inlined
- method body. (see doc/inlining_stacktrace.txt)
+ Internal function to add an address pointer to the data segment.
- IN:
- cd.............current codegen data
- iptr...........the ICMD_INLINE_END instruction
+*******************************************************************************/
+
+static s4 dseg_add_address_intern(codegendata *cd, void *value, u4 flags)
+{
+ dsegentry *de;
- Note:
- iptr->method must point to the inlined callee.
+ /* Increase data segment size, which is also the displacement into
+ the data segment. */
+
+#if SIZEOF_VOID_P == 8
+ cd->dseglen = MEMORY_ALIGN(cd->dseglen + 8, 8);
+#else
+ cd->dseglen += 4;
+#endif
+
+ /* allocate new entry */
+
+ de = DNEW(dsegentry);
+
+ de->type = TYPE_ADR;
+ de->flags = flags;
+ de->disp = -(cd->dseglen);
+ de->val.a = value;
+ de->next = cd->dseg;
+
+ /* insert into the chain */
+
+ cd->dseg = de;
+
+ return de->disp;
+}
+
+
+/* dseg_add_unique_address *****************************************************
+
+ Adds uniquely an address value to the data segment.
*******************************************************************************/
-void dseg_addlinenumber_inline_end(codegendata *cd, instruction *iptr)
+s4 dseg_add_unique_address(codegendata *cd, void *value)
{
- linenumberref *lr;
- linenumberref *prev;
- instruction *inlinestart;
+ s4 disp;
+
+ disp = dseg_add_address_intern(cd, value, DSEG_FLAG_UNIQUE);
+
+ return disp;
+}
+
+
+/* dseg_add_address ************************************************************
- /* get the pointer to the corresponding ICMD_INLINE_START */
- inlinestart = (instruction *)iptr->target;
+ Adds an address value to the data segment. It tries to reuse
+ previously added values.
- assert(inlinestart);
- assert(iptr->method);
+*******************************************************************************/
- lr = DNEW(linenumberref);
+s4 dseg_add_address(codegendata *cd, void *value)
+{
+ s4 disp;
- /* special entry containing the methodinfo * */
- lr->linenumber = (-3) - iptr->line;
- lr->tablepos = 0;
- lr->targetmpc = (ptrint) iptr->method;
- lr->next = cd->linenumberreferences;
+ /* search the data segment if the value is already stored */
- prev = lr;
- lr = DNEW(linenumberref);
+ disp = dseg_find_address(cd, value);
- /* end marker with PC of start of body */
- lr->linenumber = (-1);
- lr->tablepos = 0;
- lr->targetmpc = (u1*)inlinestart->target - cd->mcodebase;
- lr->next = prev;
+ if (disp != 0)
+ return disp;
+
+ disp = dseg_add_address_intern(cd, value, DSEG_FLAG_READONLY);
- cd->linenumberreferences = lr;
+ return disp;
}
-/* dseg_createlinenumbertable **************************************************
+/* dseg_add_target *************************************************************
- Creates a line number table in the data segment from the created
- entries in linenumberreferences.
+ XXX
*******************************************************************************/
-void dseg_createlinenumbertable(codegendata *cd)
+void dseg_add_target(codegendata *cd, basicblock *target)
{
- linenumberref *lr;
+ jumpref *jr;
- for (lr = cd->linenumberreferences; lr != NULL; lr = lr->next) {
- lr->tablepos = dseg_addaddress(cd, NULL);
+ jr = DNEW(jumpref);
- if (cd->linenumbertab == 0)
- cd->linenumbertab = lr->tablepos;
+ jr->tablepos = dseg_add_unique_address(cd, NULL);
+ jr->target = target;
+ jr->next = cd->jumpreferences;
- dseg_addaddress(cd, lr->linenumber);
- }
+ cd->jumpreferences = jr;
}
*******************************************************************************/
-#if defined(__I386__) || defined(__X86_64__) || defined(__XDSPCORE__) || defined(ENABLE_INTRP)
-void dseg_adddata(codegendata *cd, u1 *mcodeptr)
+#if defined(__I386__) || defined(__X86_64__) || defined(__S390__) || defined(__XDSPCORE__) || defined(__M68K__) || defined(ENABLE_INTRP)
+void dseg_adddata(codegendata *cd)
{
dataref *dr;
dr = DNEW(dataref);
- dr->datapos = mcodeptr - cd->mcodebase;
+ dr->datapos = cd->mcodeptr - cd->mcodebase;
dr->next = cd->datareferences;
cd->datareferences = dr;
*******************************************************************************/
-#if defined(__I386__) || defined(__X86_64__) || defined(__XDSPCORE__) || defined(ENABLE_INTRP)
-void dseg_resolve_datareferences(codegendata *cd, methodinfo *m)
+#if defined(__I386__) || defined(__X86_64__) || defined(__XDSPCORE__) || defined(__M68K__) || defined(ENABLE_INTRP)
+void dseg_resolve_datareferences(jitdata *jd)
{
- dataref *dr;
+ codeinfo *code;
+ codegendata *cd;
+ dataref *dr;
+
+ /* get required compiler data */
+
+ code = jd->code;
+ cd = jd->cd;
/* data segment references resolving */
for (dr = cd->datareferences; dr != NULL; dr = dr->next)
- *((u1 **) (m->entrypoint + dr->datapos - SIZEOF_VOID_P)) = m->entrypoint;
+ *((u1 **) (code->entrypoint + dr->datapos - SIZEOF_VOID_P)) = code->entrypoint;
}
#endif
*******************************************************************************/
#if !defined(NDEBUG)
-void dseg_display(methodinfo *m, codegendata *cd)
+void dseg_display(jitdata *jd)
{
- s4 *s4ptr;
- s4 i;
-
- s4ptr = (s4 *) (ptrint) cd->code->mcode;
+ codeinfo *code;
+ codegendata *cd;
+ dsegentry *de;
+ imm_union val;
+
+ /* get required compiler data */
+
+ code = jd->code;
+ cd = jd->cd;
+
+ if (opt_debugcolor)
+ printf("\033[34m"); /* blue */
printf(" --- dump of datasegment\n");
- for (i = cd->dseglen; i > 0 ; i -= 4) {
+ /* process all data segment entries */
+
+ for (de = cd->dseg; de != NULL; de = de->next) {
+#if SIZEOF_VOID_P == 8
+ printf("0x%016lx:", (ptrint) (code->entrypoint + de->disp));
+#else
+ printf("0x%08x:", (ptrint) (code->entrypoint + de->disp));
+#endif
+
+ printf(" %6x (%6d): ", de->disp, de->disp);
+
+ /* We read the values from the data segment as some values,
+ like the line number table, have been written directly to
+ the data segment. */
+
+ switch (de->type) {
+ case TYPE_INT:
+ val.i = *((s4 *) (code->entrypoint + de->disp));
+ printf("(INT) %d (0x%08x)", val.i, val.i);
+ break;
+
+ case TYPE_LNG:
+ val.l = *((s8 *) (code->entrypoint + de->disp));
#if SIZEOF_VOID_P == 8
- printf("0x%016lx: -%6x (%6d): %8x\n",
- (ptrint) s4ptr, i, i, (s4) *s4ptr);
+ printf("(LNG) %ld (0x%016lx)", val.l, val.l);
#else
- printf("0x%08x: -%6x (%6d): %8x\n",
- (ptrint) s4ptr, i, i, (s4) *s4ptr);
+ printf("(LNG) %lld (0x%016llx)", val.l, val.l);
#endif
- s4ptr++;
+ break;
+
+ case TYPE_FLT:
+ val.f = *((float *) (code->entrypoint + de->disp));
+ printf("(FLT) %g (0x%08x)", val.f, val.i);
+ break;
+
+ case TYPE_DBL:
+ val.d = *((double *) (code->entrypoint + de->disp));
+#if SIZEOF_VOID_P == 8
+ printf("(DBL) %g (0x%016lx)", val.d, val.l);
+#else
+ printf("(DBL) %g (0x%016llx)", val.d, val.l);
+#endif
+ break;
+
+ case TYPE_ADR:
+ val.a = *((void **) (code->entrypoint + de->disp));
+#if SIZEOF_VOID_P == 8
+ printf("(ADR) %016lx", (ptrint) val.a);
+#else
+ printf("(ADR) %08x", (ptrint) val.a);
+#endif
+ break;
+ }
+
+ printf("\n");
}
- printf(" --- begin of data segment: %p\n", (void *) s4ptr);
+ printf(" --- begin of data segment: ");
+#if SIZEOF_VOID_P == 8
+ printf("0x%016lx\n", (ptrint) code->entrypoint);
+#else
+ printf("0x%08x\n", (ptrint) code->entrypoint);
+#endif
+
+ if (opt_debugcolor)
+ printf("\033[m");
}
#endif /* !defined(NDEBUG) */
projects / cacao.git / blobdiff