Author: leo
Date: Thu Oct 20 05:05:55 2005
New Revision: 9520
Modified:
trunk/include/parrot/interpreter.h
trunk/src/embed.c
trunk/src/inter_call.c
trunk/src/inter_create.c
trunk/src/register.c
trunk/src/sub.c
Log:
Variable-sized reg frames 9 - rename BP_REG_*
* BP_REG_* are now called CTX_REG_* as these address regs from a ctx ptr
* rename All_Context to Interp_Context
* unify the first 3 words of Interp_Context and Parrot_Context
structures, so that both can be used to address registers
* switch PMC and STRING regs to use the ctx.bp_ps pointers
Modified: trunk/include/parrot/interpreter.h
==============================================================================
--- trunk/include/parrot/interpreter.h (original)
+++ trunk/include/parrot/interpreter.h Thu Oct 20 05:05:55 2005
@@ -175,10 +175,12 @@ typedef union {
} Regs_ps;
typedef struct Parrot_Context {
+ /* common header with Interp_Context */
struct Parrot_Context *prev;
- INTVAL ref_count; /* how often refered to */
struct parrot_regs_t *bp; /* register base pointer */
- Regs_ps *bp_ps; /* yet unused */
+ Regs_ps bp_ps; /* pointers to PMC & STR */
+ /* end common header */
+ INTVAL ref_count; /* how often refered to */
struct Stack_Chunk *reg_stack; /* register stack */
struct Stack_Chunk *pad_stack; /* Base of the lex pad stack */
@@ -228,10 +230,12 @@ typedef struct _Prederef {
} Prederef;
-struct All_Context {
+struct Interp_Context {
+ /* common header */
+ struct Parrot_Context *state; /* context */
struct parrot_regs_t *bp; /* register base pointer */
- Regs_ps *bp_ps; /* yet unused */
- struct Parrot_Context *state; /* ontext */
+ Regs_ps bp_ps; /* pointers to PMC & STR */
+ /* end common header */
};
#define CONTEXT(ctx) ((ctx).state)
@@ -246,7 +250,7 @@ typedef struct _context_mem {
* The actual interpreter structure
*/
struct parrot_interp_t {
- struct All_Context ctx;
+ struct Interp_Context ctx;
context_mem ctx_mem; /* ctx memory managment */
struct Stash *globals; /* Pointer to the global variable
@@ -360,15 +364,15 @@ typedef enum {
* Macros to make accessing registers more convenient/readable.
*/
-# define INTERP_REG_INT(i, x) i->ctx.bp->int_reg.registers[x]
# define INTERP_REG_NUM(i, x) i->ctx.bp->num_reg.registers[x]
-# define INTERP_REG_STR(i, x) i->ctx.bp->string_reg.registers[x]
-# define INTERP_REG_PMC(i, x) i->ctx.bp->pmc_reg.registers[x]
+# define INTERP_REG_INT(i, x) i->ctx.bp->int_reg.registers[x]
+# define INTERP_REG_PMC(i, x) i->ctx.bp_ps.regs_p[-32+x]
+# define INTERP_REG_STR(i, x) i->ctx.bp_ps.regs_s[x]
-# define BP_REG_INT(bp, x) (bp)->int_reg.registers[x]
-# define BP_REG_NUM(bp, x) (bp)->num_reg.registers[x]
-# define BP_REG_STR(bp, x) (bp)->string_reg.registers[x]
-# define BP_REG_PMC(bp, x) (bp)->pmc_reg.registers[x]
+# define CTX_REG_NUM(ctx, x) (ctx)->bp->num_reg.registers[x]
+# define CTX_REG_INT(ctx, x) (ctx)->bp->int_reg.registers[x]
+# define CTX_REG_PMC(ctx, x) (ctx)->bp_ps.regs_p[-32+x]
+# define CTX_REG_STR(ctx, x) (ctx)->bp_ps.regs_s[x]
#define REG_BASE struct parrot_regs_t
Modified: trunk/src/embed.c
==============================================================================
--- trunk/src/embed.c (original)
+++ trunk/src/embed.c Thu Oct 20 05:05:55 2005
@@ -475,7 +475,7 @@ setup_argv(Interp *interpreter, int argc
}
/* XXX @ARGS should propably be a ResizableStringArray */
- REG_PMC(5) = userargv = pmc_new_noinit(interpreter, enum_class_SArray);
+ userargv = pmc_new_noinit(interpreter, enum_class_SArray);
/* immediately anchor pmc to root set */
VTABLE_set_pmc_keyed_int(interpreter, interpreter->iglobals,
(INTVAL)IGLOBALS_ARGV_LIST, userargv);
Modified: trunk/src/inter_call.c
==============================================================================
--- trunk/src/inter_call.c (original)
+++ trunk/src/inter_call.c Thu Oct 20 05:05:55 2005
@@ -166,7 +166,7 @@ fetch_arg_int_op(Interp *interpreter, st
idx = *st->src.u.op.pc;
if (!(st->src.sig & PARROT_ARG_CONSTANT)) {
- idx = BP_REG_INT(st->src.ctx->bp, idx);
+ idx = CTX_REG_INT(st->src.ctx, idx);
}
UVal_int(st->val) = idx;
st->src.mode |= CALL_STATE_NEXT_ARG;
@@ -184,7 +184,7 @@ fetch_arg_str_op(Interp *interpreter, st
s_arg = st->src.constants[idx]->u.string;
}
else {
- s_arg = BP_REG_STR(st->src.ctx->bp, idx);
+ s_arg = CTX_REG_STR(st->src.ctx, idx);
}
UVal_str(st->val) = s_arg;
st->src.mode |= CALL_STATE_NEXT_ARG;
@@ -202,7 +202,7 @@ fetch_arg_num_op(Interp *interpreter, st
f_arg = st->src.constants[idx]->u.number;
}
else {
- f_arg = BP_REG_NUM(st->src.ctx->bp, idx);
+ f_arg = CTX_REG_NUM(st->src.ctx, idx);
}
UVal_num(st->val) = f_arg;
st->src.mode |= CALL_STATE_NEXT_ARG;
@@ -221,7 +221,7 @@ fetch_arg_pmc_op(Interp *interpreter, st
p_arg = st->src.constants[idx]->u.key;
}
else {
- p_arg = BP_REG_PMC(st->src.ctx->bp, idx);
+ p_arg = CTX_REG_PMC(st->src.ctx, idx);
}
if (st->src.sig & PARROT_ARG_FLATTEN) {
_array = CONST_STRING(interpreter, "array");
@@ -533,7 +533,7 @@ again:
if (st->opt_so_far > 1)
real_exception(interpreter, NULL, E_ValueError,
":opt_flag preceeded by more then one :optional");
- BP_REG_INT(st->dest.ctx->bp, *st->dest.u.op.pc) = st->opt_so_far;
+ CTX_REG_INT(st->dest.ctx, *st->dest.u.op.pc) = st->opt_so_far;
st->opt_so_far = 0;
if (!next_arg(interpreter, &st->dest))
return 0;
@@ -577,7 +577,7 @@ Parrot_store_arg(Interp *interpreter, st
st->dest.slurp = pmc_new(interpreter,
Parrot_get_ctx_HLL_type(interpreter,
enum_class_ResizablePMCArray));
- BP_REG_PMC(st->dest.ctx->bp, *st->dest.u.op.pc) = st->dest.slurp;
+ CTX_REG_PMC(st->dest.ctx, *st->dest.u.op.pc) = st->dest.slurp;
st->dest.mode |= CALL_STATE_FLATTEN;
return Parrot_store_arg(interpreter, st);
}
@@ -589,16 +589,16 @@ Parrot_store_arg(Interp *interpreter, st
assert(st->dest.mode & CALL_STATE_OP);
switch (st->dest.sig & PARROT_ARG_TYPE_MASK) {
case PARROT_ARG_INTVAL:
- BP_REG_INT(st->dest.ctx->bp, *st->dest.u.op.pc) =
UVal_int(st->val);
+ CTX_REG_INT(st->dest.ctx, *st->dest.u.op.pc) = UVal_int(st->val);
break;
case PARROT_ARG_FLOATVAL:
- BP_REG_NUM(st->dest.ctx->bp, *st->dest.u.op.pc) =
UVal_num(st->val);
+ CTX_REG_NUM(st->dest.ctx, *st->dest.u.op.pc) = UVal_num(st->val);
break;
case PARROT_ARG_STRING:
- BP_REG_STR(st->dest.ctx->bp, *st->dest.u.op.pc) =
UVal_str(st->val);
+ CTX_REG_STR(st->dest.ctx, *st->dest.u.op.pc) = UVal_str(st->val);
break;
case PARROT_ARG_PMC:
- BP_REG_PMC(st->dest.ctx->bp, *st->dest.u.op.pc) =
UVal_pmc(st->val);
+ CTX_REG_PMC(st->dest.ctx, *st->dest.u.op.pc) = UVal_pmc(st->val);
break;
}
st->dest.mode |= CALL_STATE_NEXT_ARG;
Modified: trunk/src/inter_create.c
==============================================================================
--- trunk/src/inter_create.c (original)
+++ trunk/src/inter_create.c Thu Oct 20 05:05:55 2005
@@ -164,13 +164,21 @@ static void
create_initial_context(Interp *interpreter)
{
size_t to_alloc = sizeof(struct parrot_regs_t) + ALIGNED_CTX_SIZE;
+ void *p;
+ parrot_context_t *ctx;
new_context_mem(interpreter, &interpreter->ctx_mem);
- LVALUE_CAST(char *, interpreter->ctx.bp) =
- interpreter->ctx_mem.free + ALIGNED_CTX_SIZE;
+ p = interpreter->ctx_mem.free;
+ CONTEXT(interpreter->ctx) = ctx = p;
+ p = interpreter->ctx_mem.free + ALIGNED_CTX_SIZE;
+ interpreter->ctx.bp = p;
+ interpreter->ctx.bp_ps.regs_s = (STRING**) ((char*)p +
+ offsetof(struct parrot_regs_t, string_reg.registers[0]));
interpreter->ctx_mem.free += to_alloc;
- memset(CONTEXT(interpreter->ctx), 0, sizeof(struct Parrot_Context));
- CONTEXT(interpreter->ctx)->prev = NULL;
+ memset(ctx, 0, sizeof(struct Parrot_Context));
+ ctx->bp = interpreter->ctx.bp;
+ ctx->bp_ps = interpreter->ctx.bp_ps;
+ ctx->prev = NULL;
}
#else
@@ -185,16 +193,21 @@ create_initial_context(Interp *interpret
{
size_t to_alloc = sizeof(struct parrot_regs_t) + ALIGNED_CTX_SIZE;
void *p;
+ parrot_context_t *ctx;
- p = mem_sys_allocate_zeroed(to_alloc);
+ ctx = p = mem_sys_allocate_zeroed(to_alloc);
#if CTX_LEAK_DEBUG
fprintf(stderr, "alloc %p\n", p);
#endif
- CONTEXT(interpreter->ctx) = p;
+ CONTEXT(interpreter->ctx) = ctx;
p = (void *) ((char *)p + ALIGNED_CTX_SIZE);
- interpreter->ctx.bp = CONTEXT(interpreter->ctx)->bp = p;
+ interpreter->ctx.bp = p;
+ interpreter->ctx.bp_ps.regs_s = (STRING**) ((char*)p +
+ offsetof(struct parrot_regs_t, string_reg.registers[0]));
interpreter->ctx_mem.free = NULL;
- CONTEXT(interpreter->ctx)->prev = NULL;
+ ctx->bp = interpreter->ctx.bp;
+ ctx->bp_ps = interpreter->ctx.bp_ps;
+ ctx->prev = NULL;
}
#endif
@@ -237,10 +250,10 @@ parrot_gc_context(Interp *interpreter)
}
static void
-init_context(Interp *interpreter, struct Parrot_Context *old_state)
+init_context(Interp *interpreter, parrot_context_t *old_state)
{
- struct parrot_regs_t *bp;
int i;
+ parrot_context_t *ctx;
memcpy(CONTEXT(interpreter->ctx),
old_state, sizeof(struct Parrot_Context));
@@ -254,21 +267,23 @@ init_context(Interp *interpreter, struct
* if the architecture has 0x := NULL and 0.0 we could memset too
*
*/
- CONTEXT(interpreter->ctx)->bp = bp = interpreter->ctx.bp;
+ ctx = CONTEXT(interpreter->ctx);
+ ctx->bp = interpreter->ctx.bp;
+ ctx->bp_ps = interpreter->ctx.bp_ps;
for (i = 0; i < NUM_REGISTERS; i++) {
- BP_REG_PMC(bp, i) = PMCNULL;
- BP_REG_STR(bp, i) = NULL;
+ CTX_REG_PMC(ctx, i) = PMCNULL;
+ CTX_REG_STR(ctx, i) = NULL;
#ifndef NDEBUG
/* depending on -D40 we set int, num to garbage or zero
*/
if (Interp_debug_TEST(interpreter, PARROT_REG_DEBUG_FLAG)) {
/* TODO better use rand values */
- BP_REG_INT(bp, i) = -999;
- BP_REG_NUM(bp, i) = -99.9;
+ CTX_REG_INT(ctx, i) = -999;
+ CTX_REG_NUM(ctx, i) = -99.9;
}
else {
- BP_REG_INT(bp, i) = 0;
- BP_REG_NUM(bp, i) = 0.0;
+ CTX_REG_INT(ctx, i) = 0;
+ CTX_REG_NUM(ctx, i) = 0.0;
}
#endif
}
@@ -403,7 +418,11 @@ Parrot_alloc_context(Interp *interpreter
#if CTX_LEAK_DEBUG
fprintf(stderr, "alloc %p\n", p);
#endif
+ /* XXX .bp this still points to start */
interpreter->ctx.bp = p;
+ /* this points to S0 - currently fixed regs still */
+ interpreter->ctx.bp_ps.regs_s = (STRING**) ((char*)p +
+ offsetof(struct parrot_regs_t, string_reg.registers[0]));
init_context(interpreter, old);
}
Modified: trunk/src/register.c
==============================================================================
--- trunk/src/register.c (original)
+++ trunk/src/register.c Thu Oct 20 05:05:55 2005
@@ -128,17 +128,21 @@ mark_register_stack(Parrot_Interp interp
struct parrot_regs_t *regs;
int i;
PObj *obj;
+ struct Interp_Context ctx;
for (; ; chunk = chunk->prev) {
pobject_lives(interpreter, (PObj*)chunk);
if (chunk == chunk->prev)
break;
regs = (struct parrot_regs_t *)STACK_DATAP(chunk);
+ /* XXX intermediate hack */
+ ctx.bp = regs;
+ ctx.bp_ps.regs_p = regs->pmc_reg.registers;
for (i = 0; i < NUM_REGISTERS; ++i) {
- obj = (PObj *)BP_REG_PMC(regs, i);
+ obj = (PObj *)CTX_REG_PMC(&ctx, i);
if (obj)
pobject_lives(interpreter, obj);
- obj = (PObj *)BP_REG_STR(regs, i);
+ obj = (PObj *)CTX_REG_STR(&ctx, i);
if (obj)
pobject_lives(interpreter, obj);
}
Modified: trunk/src/sub.c
==============================================================================
--- trunk/src/sub.c (original)
+++ trunk/src/sub.c Thu Oct 20 05:05:55 2005
@@ -37,7 +37,6 @@ mark_context(Interp* interpreter, parrot
{
PObj *obj;
int i, n;
- struct parrot_regs_t *regs;
mark_stack(interpreter, ctx->pad_stack);
mark_stack(interpreter, ctx->user_stack);
@@ -66,12 +65,11 @@ mark_context(Interp* interpreter, parrot
obj = (PObj*)ctx->current_package;
if (obj)
pobject_lives(interpreter, obj);
- regs = ctx->bp;
for (i = 0; i < NUM_REGISTERS; ++i) {
- obj = (PObj*) BP_REG_PMC(regs, i);
+ obj = (PObj*) CTX_REG_PMC(ctx, i);
if (obj)
pobject_lives(interpreter, obj);
- obj = (PObj*) BP_REG_STR(regs, i);
+ obj = (PObj*) CTX_REG_STR(ctx, i);
if (obj)
pobject_lives(interpreter, obj);
}
