ppc_addi (code, this_pos, this_pos, sizeof (MonoObject));
ppc_emit32 (code, short_branch);
} else {
- ppc_load (code, ppc_r0, addr);
+ ppc_load_ptr (code, ppc_r0, addr);
ppc_mtctr (code, ppc_r0);
ppc_addi (code, this_pos, this_pos, sizeof (MonoObject));
ppc_bcctr (code, 20, 0);
/* Compute size of code needed to emit mrgctx */
p = imm_buf;
- ppc_load (p, MONO_ARCH_RGCTX_REG, mrgctx);
+ ppc_load_ptr (p, MONO_ARCH_RGCTX_REG, mrgctx);
imm_size = p - imm_buf;
mono_domain_lock (domain);
mono_domain_unlock (domain);
if (short_branch) {
- ppc_load (code, MONO_ARCH_RGCTX_REG, mrgctx);
+ ppc_load_ptr (code, MONO_ARCH_RGCTX_REG, mrgctx);
ppc_emit32 (code, short_branch);
} else {
- ppc_load (code, ppc_r0, addr);
+ ppc_load_ptr (code, ppc_r0, addr);
ppc_mtctr (code, ppc_r0);
- ppc_load (code, MONO_ARCH_RGCTX_REG, mrgctx);
+ ppc_load_ptr (code, MONO_ARCH_RGCTX_REG, mrgctx);
ppc_bcctr (code, 20, 0);
}
mono_arch_flush_icache (start, code - start);
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
- g_assert_not_reached ();
+ guint32 ins1, ins2, offset;
+
+ /* Patch the jump table entry used by the plt entry */
+
+ /* Should be a lis+ori */
+ ins1 = ((guint32*)code)[0];
+ g_assert (ins1 >> 26 == 15);
+ ins2 = ((guint32*)code)[1];
+ g_assert (ins2 >> 26 == 24);
+ offset = ((ins1 & 0xffff) << 16) | (ins2 & 0xffff);
+
+ /* Either got or regs is set */
+ if (!got)
+ got = (gpointer*)(gsize) regs [30];
+ *(guint8**)((guint8*)got + offset) = addr;
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
mono_arch_patch_callsite (NULL, code, nullified_class_init_trampoline);
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
- g_assert_not_reached ();
+ if (mono_aot_only && !nullified_class_init_trampoline)
+ nullified_class_init_trampoline = mono_aot_get_named_code ("nullified_class_init_trampoline");
+
+ mono_arch_patch_plt_entry (code, NULL, regs, nullified_class_init_trampoline);
}
/* Stack size for trampoline function
* PPC_MINIMAL_STACK_SIZE + 16 (args + alignment to ppc_magic_trampoline)
* + MonoLMF + 14 fp regs + 13 gregs + alignment
- * #define STACK (PPC_MINIMAL_STACK_SIZE + 4 * sizeof (gulong) + sizeof (MonoLMF) + 14 * sizeof (double) + 13 * (sizeof (gulong)))
- * STACK would be 444 for 32 bit darwin
*/
-#ifdef __mono_ppc64__
-#define STACK (PPC_MINIMAL_STACK_SIZE + 4 * sizeof (gulong) + sizeof (MonoLMF) + 14 * sizeof (double) + 31 * sizeof (gulong))
-#else
-#define STACK (448)
-#endif
+#define STACK (((PPC_MINIMAL_STACK_SIZE + 4 * sizeof (mgreg_t) + sizeof (MonoLMF) + 14 * sizeof (double) + 31 * sizeof (mgreg_t)) + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~(MONO_ARCH_FRAME_ALIGNMENT - 1))
/* Method-specific trampoline code fragment size */
#define METHOD_TRAMPOLINE_SIZE 64
*ji = NULL;
*out_unwind_ops = NULL;
- ppc_store_reg_update (buf, ppc_r1, -STACK, ppc_r1);
+ ppc_str_update (buf, ppc_r1, -STACK, ppc_r1);
/* start building the MonoLMF on the stack */
offset = STACK - sizeof (double) * MONO_SAVED_FREGS;
* now the integer registers.
*/
offset = STACK - sizeof (MonoLMF) + G_STRUCT_OFFSET (MonoLMF, iregs);
- ppc_store_multiple_regs (buf, ppc_r13, offset, ppc_r1);
+ ppc_str_multiple (buf, ppc_r13, offset, ppc_r1);
/* Now save the rest of the registers below the MonoLMF struct, first 14
* fp regs and then the 31 gregs.
ppc_stfd (buf, i, offset, ppc_r1);
offset += sizeof (double);
}
-#define GREGS_OFFSET (STACK - sizeof (MonoLMF) - (14 * sizeof (double)) - (31 * sizeof (gulong)))
+#define GREGS_OFFSET (STACK - sizeof (MonoLMF) - (14 * sizeof (double)) - (31 * sizeof (mgreg_t)))
offset = GREGS_OFFSET;
for (i = 0; i < 31; i++) {
- ppc_store_reg (buf, i, offset, ppc_r1);
- offset += sizeof (gulong);
+ ppc_str (buf, i, offset, ppc_r1);
+ offset += sizeof (mgreg_t);
}
/* we got here through a jump to the ctr reg, we must save the lr
* method-specific trampoline)
*/
ppc_mflr (buf, ppc_r0);
- ppc_store_reg (buf, ppc_r0, STACK + PPC_RET_ADDR_OFFSET, ppc_r1);
+ ppc_str (buf, ppc_r0, STACK + PPC_RET_ADDR_OFFSET, ppc_r1);
/* ok, now we can continue with the MonoLMF setup, mostly untouched
* from emit_prolog in mini-ppc.c
if (aot) {
buf = mono_arch_emit_load_aotconst (code, buf, ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr");
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
- ppc_load_reg (buf, ppc_r2, sizeof (gpointer), ppc_r11);
- ppc_load_reg (buf, ppc_r11, 0, ppc_r11);
+ ppc_ldptr (buf, ppc_r2, sizeof (gpointer), ppc_r11);
+ ppc_ldptr (buf, ppc_r11, 0, ppc_r11);
#endif
ppc_mtlr (buf, ppc_r11);
ppc_blrl (buf);
* The pointer to the struct is put in ppc_r11.
*/
ppc_addi (buf, ppc_r11, ppc_sp, STACK - sizeof (MonoLMF));
- ppc_store_reg (buf, ppc_r3, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11);
+ ppc_stptr (buf, ppc_r3, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11);
/* new_lmf->previous_lmf = *lmf_addr */
- ppc_load_reg (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3);
- ppc_store_reg (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11);
+ ppc_ldptr (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3);
+ ppc_stptr (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11);
/* *(lmf_addr) = r11 */
- ppc_store_reg (buf, ppc_r11, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3);
- /* save method info (it's stored on the stack, so get it first and put it
- * in r5 as it's the third argument to the function)
- */
- if (tramp_type == MONO_TRAMPOLINE_GENERIC_CLASS_INIT)
- ppc_load_reg (buf, ppc_r5, GREGS_OFFSET + PPC_FIRST_ARG_REG * sizeof (gpointer), ppc_r1);
- else
- ppc_load_reg (buf, ppc_r5, GREGS_OFFSET, ppc_r1);
- if ((tramp_type == MONO_TRAMPOLINE_JIT) || (tramp_type == MONO_TRAMPOLINE_JUMP))
- ppc_store_reg (buf, ppc_r5, G_STRUCT_OFFSET(MonoLMF, method), ppc_r11);
+ ppc_stptr (buf, ppc_r11, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3);
+ /* save method info (it's stored on the stack, so get it first). */
+ if ((tramp_type == MONO_TRAMPOLINE_JIT) || (tramp_type == MONO_TRAMPOLINE_JUMP)) {
+ ppc_ldr (buf, ppc_r0, GREGS_OFFSET, ppc_r1);
+ ppc_stptr (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r11);
+ } else {
+ ppc_load (buf, ppc_r0, 0);
+ ppc_stptr (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r11);
+ }
/* store the frame pointer of the calling method */
ppc_addi (buf, ppc_r0, ppc_sp, STACK);
- ppc_store_reg (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, ebp), ppc_r11);
+ ppc_stptr (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, ebp), ppc_r11);
/* save the IP (caller ip) */
if (tramp_type == MONO_TRAMPOLINE_JUMP) {
ppc_li (buf, ppc_r0, 0);
} else {
- ppc_load_reg (buf, ppc_r0, STACK + PPC_RET_ADDR_OFFSET, ppc_r1);
+ ppc_ldr (buf, ppc_r0, STACK + PPC_RET_ADDR_OFFSET, ppc_r1);
}
- ppc_store_reg (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r11);
+ ppc_stptr (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r11);
/*
- * Now we're ready to call trampoline (gssize *regs, guint8 *code, gpointer value, guint8 *tramp)
+ * Now we're ready to call trampoline (mgreg_t *regs, guint8 *code, gpointer value, guint8 *tramp)
* Note that the last argument is unused.
*/
/* Arg 1: a pointer to the registers */
if (tramp_type == MONO_TRAMPOLINE_JUMP)
ppc_li (buf, ppc_r4, 0);
else
- ppc_load_reg (buf, ppc_r4, STACK + PPC_RET_ADDR_OFFSET, ppc_r1);
+ ppc_ldr (buf, ppc_r4, STACK + PPC_RET_ADDR_OFFSET, ppc_r1);
- /* Arg 3: MonoMethod *method. It was put in r5 already above */
- /*ppc_mr (buf, ppc_r5, ppc_r5);*/
+ /* Arg 3: trampoline argument */
+ if (tramp_type == MONO_TRAMPOLINE_GENERIC_CLASS_INIT)
+ ppc_ldr (buf, ppc_r5, GREGS_OFFSET + MONO_ARCH_VTABLE_REG * sizeof (mgreg_t), ppc_r1);
+ else
+ ppc_ldr (buf, ppc_r5, GREGS_OFFSET, ppc_r1);
if (aot) {
buf = mono_arch_emit_load_aotconst (code, buf, ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("trampoline_func_%d", tramp_type));
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
- ppc_load_reg (buf, ppc_r2, sizeof (gpointer), ppc_r11);
- ppc_load_reg (buf, ppc_r11, 0, ppc_r11);
+ ppc_ldptr (buf, ppc_r2, sizeof (gpointer), ppc_r11);
+ ppc_ldptr (buf, ppc_r11, 0, ppc_r11);
#endif
ppc_mtlr (buf, ppc_r11);
ppc_blrl (buf);
*/
if (!MONO_TRAMPOLINE_TYPE_MUST_RETURN (tramp_type)) {
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
- ppc_load_reg (buf, ppc_r2, sizeof (gpointer), ppc_r3);
- ppc_load_reg (buf, ppc_r3, 0, ppc_r3);
+ ppc_ldptr (buf, ppc_r2, sizeof (gpointer), ppc_r3);
+ ppc_ldptr (buf, ppc_r3, 0, ppc_r3);
#endif
ppc_mtctr (buf, ppc_r3);
}
*/
ppc_addi (buf, ppc_r11, ppc_r1, STACK - sizeof (MonoLMF));
/* r5 = previous_lmf */
- ppc_load_reg (buf, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11);
+ ppc_ldptr (buf, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11);
/* r6 = lmf_addr */
- ppc_load_reg (buf, ppc_r6, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11);
+ ppc_ldptr (buf, ppc_r6, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11);
/* *(lmf_addr) = previous_lmf */
- ppc_store_reg (buf, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r6);
+ ppc_stptr (buf, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r6);
/* restore iregs */
- ppc_load_multiple_regs (buf, ppc_r13, G_STRUCT_OFFSET(MonoLMF, iregs), ppc_r11);
+ ppc_ldr_multiple (buf, ppc_r13, G_STRUCT_OFFSET(MonoLMF, iregs), ppc_r11);
/* restore fregs */
for (i = 14; i < 32; i++)
ppc_lfd (buf, i, G_STRUCT_OFFSET(MonoLMF, fregs) + ((i-14) * sizeof (gdouble)), ppc_r11);
ppc_lfd (buf, i, offset, ppc_r1);
offset += sizeof (double);
}
- offset = STACK - sizeof (MonoLMF) - (14 * sizeof (double)) - (31 * sizeof (gulong));
- ppc_load_reg (buf, ppc_r0, offset, ppc_r1);
- offset += 2 * sizeof (gulong);
+ offset = STACK - sizeof (MonoLMF) - (14 * sizeof (double)) - (31 * sizeof (mgreg_t));
+ ppc_ldr (buf, ppc_r0, offset, ppc_r1);
+ offset += 2 * sizeof (mgreg_t);
for (i = 2; i < 13; i++) {
if (i != PPC_TOC_REG && (i != 3 || tramp_type != MONO_TRAMPOLINE_RGCTX_LAZY_FETCH))
- ppc_load_reg (buf, i, offset, ppc_r1);
- offset += sizeof (gulong);
+ ppc_ldr (buf, i, offset, ppc_r1);
+ offset += sizeof (mgreg_t);
}
/* Non-standard function epilogue. Instead of doing a proper
* return, we just jump to the compiled code.
*/
/* Restore stack pointer and LR and jump to the code */
- ppc_load_reg (buf, ppc_r1, 0, ppc_r1);
- ppc_load_reg (buf, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_r1);
+ ppc_ldr (buf, ppc_r1, 0, ppc_r1);
+ ppc_ldr (buf, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_r1);
ppc_mtlr (buf, ppc_r11);
if (MONO_TRAMPOLINE_TYPE_MUST_RETURN (tramp_type))
ppc_blr (buf);
mono_domain_unlock (domain);
if (short_branch) {
- ppc_load_sequence (buf, ppc_r0, (gulong) arg1);
+ ppc_load_sequence (buf, ppc_r0, (mgreg_t)(gsize) arg1);
ppc_emit32 (buf, short_branch);
} else {
/* Prepare the jump to the generic trampoline code.*/
- ppc_load (buf, ppc_r0, (gulong) tramp);
+ ppc_load_ptr (buf, ppc_r0, tramp);
ppc_mtctr (buf, ppc_r0);
/* And finally put 'arg1' in r0 and fly! */
- ppc_load (buf, ppc_r0, (gulong) arg1);
+ ppc_load_ptr (buf, ppc_r0, arg1);
ppc_bcctr (buf, 20, 0);
}
if (short_branch) {
ppc_emit32 (code, short_branch);
} else {
- ppc_load (code, ppc_r0, tramp);
+ ppc_load_ptr (code, ppc_r0, tramp);
ppc_mtctr (code, ppc_r0);
ppc_bcctr (code, 20, 0);
}
mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
index = MONO_RGCTX_SLOT_INDEX (slot);
if (mrgctx)
- index += sizeof (MonoMethodRuntimeGenericContext) / sizeof (gpointer);
+ index += MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT / sizeof (gpointer);
for (depth = 0; ; ++depth) {
int size = mono_class_rgctx_get_array_size (depth, mrgctx);
ppc_mr (code, ppc_r4, PPC_FIRST_ARG_REG);
} else {
/* load rgctx ptr from vtable */
- ppc_load_reg (code, ppc_r4, G_STRUCT_OFFSET (MonoVTable, runtime_generic_context), PPC_FIRST_ARG_REG);
+ ppc_ldptr (code, ppc_r4, G_STRUCT_OFFSET (MonoVTable, runtime_generic_context), PPC_FIRST_ARG_REG);
/* is the rgctx ptr null? */
ppc_compare_reg_imm (code, 0, ppc_r4, 0);
/* if yes, jump to actual trampoline */
for (i = 0; i < depth; ++i) {
/* load ptr to next array */
if (mrgctx && i == 0)
- ppc_load_reg (code, ppc_r4, sizeof (MonoMethodRuntimeGenericContext), ppc_r4);
+ ppc_ldptr (code, ppc_r4, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT, ppc_r4);
else
- ppc_load_reg (code, ppc_r4, 0, ppc_r4);
+ ppc_ldptr (code, ppc_r4, 0, ppc_r4);
/* is the ptr null? */
ppc_compare_reg_imm (code, 0, ppc_r4, 0);
/* if yes, jump to actual trampoline */
}
/* fetch slot */
- ppc_load_reg (code, ppc_r4, sizeof (gpointer) * (index + 1), ppc_r4);
+ ppc_ldptr (code, ppc_r4, sizeof (gpointer) * (index + 1), ppc_r4);
/* is the slot null? */
ppc_compare_reg_imm (code, 0, ppc_r4, 0);
/* if yes, jump to actual trampoline */
code = mono_arch_emit_load_aotconst (buf, code, ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot));
/* Branch to the trampoline */
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
- ppc_load_reg (code, ppc_r11, 0, ppc_r11);
+ ppc_ldptr (code, ppc_r11, 0, ppc_r11);
#endif
ppc_mtctr (code, ppc_r11);
ppc_bcctr (code, PPC_BR_ALWAYS, 0);
if (byte_offset < 0)
mono_marshal_find_bitfield_offset (MonoVTable, initialized, &byte_offset, &bitmask);
- ppc_lbz (code, ppc_r4, byte_offset, PPC_FIRST_ARG_REG);
+ ppc_lbz (code, ppc_r4, byte_offset, MONO_ARCH_VTABLE_REG);
ppc_andid (code, ppc_r4, ppc_r4, bitmask);
jump = code;
ppc_bc (code, PPC_BR_TRUE, PPC_BR_EQ, 0);
code = mono_arch_emit_load_aotconst (buf, code, ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_generic_class_init");
/* Branch to the trampoline */
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
- ppc_load_reg (code, ppc_r11, 0, ppc_r11);
+ ppc_ldptr (code, ppc_r11, 0, ppc_r11);
#endif
ppc_mtctr (code, ppc_r11);
ppc_bcctr (code, PPC_BR_ALWAYS, 0);
projects / mono.git / blobdiff