Converted all functions visible from vg_skin.h with names in CamelCaps to
use_under_scores instead, to be consistent.
Also added some missing 'extern's on function declarations in vg_skin.h.
Also added a quick note in vg_regtest.in on the simplest way to run regression
tests.
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@1135 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/memcheck/mc_errcontext.c b/memcheck/mc_errcontext.c
index 01f574c..31cdcea 100644
--- a/memcheck/mc_errcontext.c
+++ b/memcheck/mc_errcontext.c
@@ -558,7 +558,7 @@
Bool eof;
if (s->skind == ParamSupp) {
- eof = VG_(getLine) ( fd, buf, nBuf );
+ eof = VG_(get_line) ( fd, buf, nBuf );
if (eof) return False;
s->string = VG_(strdup)(buf);
}
diff --git a/memcheck/mc_from_ucode.c b/memcheck/mc_from_ucode.c
index 84e4386..485e4b2 100644
--- a/memcheck/mc_from_ucode.c
+++ b/memcheck/mc_from_ucode.c
@@ -35,8 +35,8 @@
/*--- Renamings of frequently-used global functions. ---*/
/*------------------------------------------------------------*/
-#define nameIReg VG_(nameOfIntReg)
-#define nameISize VG_(nameOfIntSize)
+#define nameIReg VG_(name_of_int_reg)
+#define nameISize VG_(name_of_int_size)
#define dis VG_(print_codegen)
@@ -54,7 +54,7 @@
static void emit_testv_lit_reg ( Int sz, UInt lit, Int reg )
{
- VG_(newEmit)();
+ VG_(new_emit)();
if (sz == 2) {
VG_(emitB) ( 0x66 );
} else {
@@ -70,7 +70,7 @@
static void emit_testv_lit_offregmem ( Int sz, UInt lit, Int off, Int reg )
{
- VG_(newEmit)();
+ VG_(new_emit)();
if (sz == 2) {
VG_(emitB) ( 0x66 );
} else {
@@ -174,19 +174,19 @@
switch (sz) {
case 4:
emit_testv_lit_offregmem (
- 4, 0xFFFFFFFF, VG_(shadowRegOffset)(val), R_EBP );
+ 4, 0xFFFFFFFF, VG_(shadow_reg_offset)(val), R_EBP );
break;
case 2:
emit_testv_lit_offregmem (
- 4, 0x0000FFFF, VG_(shadowRegOffset)(val), R_EBP );
+ 4, 0x0000FFFF, VG_(shadow_reg_offset)(val), R_EBP );
break;
case 1:
if (val < 4) {
emit_testv_lit_offregmem (
- 4, 0x000000FF, VG_(shadowRegOffset)(val), R_EBP );
+ 4, 0x000000FF, VG_(shadow_reg_offset)(val), R_EBP );
} else {
emit_testv_lit_offregmem (
- 4, 0x0000FF00, VG_(shadowRegOffset)(val-4), R_EBP );
+ 4, 0x0000FF00, VG_(shadow_reg_offset)(val-4), R_EBP );
}
break;
case 0:
@@ -237,20 +237,20 @@
/* VG_(printf)("synth_GETV %d of Arch %s\n", sz, nameIReg(sz, arch)); */
switch (sz) {
case 4:
- VG_(emit_movv_offregmem_reg) ( 4, VG_(shadowRegOffset)(arch),
+ VG_(emit_movv_offregmem_reg) ( 4, VG_(shadow_reg_offset)(arch),
R_EBP, reg );
break;
case 2:
- VG_(emit_movzwl_offregmem_reg) ( VG_(shadowRegOffset)(arch),
+ VG_(emit_movzwl_offregmem_reg) ( VG_(shadow_reg_offset)(arch),
R_EBP, reg );
VG_(emit_nonshiftopv_lit_reg) ( 4, OR, 0xFFFF0000, reg );
break;
case 1:
if (arch < 4) {
- VG_(emit_movzbl_offregmem_reg) ( VG_(shadowRegOffset)(arch),
+ VG_(emit_movzbl_offregmem_reg) ( VG_(shadow_reg_offset)(arch),
R_EBP, reg );
} else {
- VG_(emit_movzbl_offregmem_reg) ( VG_(shadowRegOffset)(arch-4)+1,
+ VG_(emit_movzbl_offregmem_reg) ( VG_(shadow_reg_offset)(arch-4)+1,
R_EBP, reg );
}
VG_(emit_nonshiftopv_lit_reg) ( 4, OR, 0xFFFFFF00, reg );
@@ -271,21 +271,21 @@
case 4:
vg_assert(lit == 0x00000000);
VG_(emit_movv_lit_offregmem) ( 4, 0x00000000,
- VG_(shadowRegOffset)(arch), R_EBP );
+ VG_(shadow_reg_offset)(arch), R_EBP );
break;
case 2:
vg_assert(lit == 0xFFFF0000);
VG_(emit_movv_lit_offregmem) ( 2, 0x0000,
- VG_(shadowRegOffset)(arch), R_EBP );
+ VG_(shadow_reg_offset)(arch), R_EBP );
break;
case 1:
vg_assert(lit == 0xFFFFFF00);
if (arch < 4) {
VG_(emit_movb_lit_offregmem) ( 0x00,
- VG_(shadowRegOffset)(arch), R_EBP );
+ VG_(shadow_reg_offset)(arch), R_EBP );
} else {
VG_(emit_movb_lit_offregmem) ( 0x00,
- VG_(shadowRegOffset)(arch-4)+1,
+ VG_(shadow_reg_offset)(arch-4)+1,
R_EBP );
}
break;
@@ -310,19 +310,19 @@
switch (sz) {
case 4:
VG_(emit_movv_reg_offregmem) ( 4, reg,
- VG_(shadowRegOffset)(arch), R_EBP );
+ VG_(shadow_reg_offset)(arch), R_EBP );
break;
case 2:
VG_(emit_movv_reg_offregmem) ( 2, reg,
- VG_(shadowRegOffset)(arch), R_EBP );
+ VG_(shadow_reg_offset)(arch), R_EBP );
break;
case 1:
if (arch < 4) {
VG_(emit_movb_reg_offregmem) ( reg,
- VG_(shadowRegOffset)(arch), R_EBP );
+ VG_(shadow_reg_offset)(arch), R_EBP );
} else {
VG_(emit_movb_reg_offregmem) ( reg,
- VG_(shadowRegOffset)(arch-4)+1, R_EBP );
+ VG_(shadow_reg_offset)(arch-4)+1, R_EBP );
}
break;
default:
@@ -338,7 +338,7 @@
static void synth_GETVF ( Int reg )
{
- VG_(emit_movv_offregmem_reg) ( 4, VG_(shadowFlagsOffset)(), R_EBP, reg );
+ VG_(emit_movv_offregmem_reg) ( 4, VG_(shadow_flags_offset)(), R_EBP, reg );
/* paranoia only; should be unnecessary ... */
/* VG_(emit_nonshiftopv_lit_reg) ( 4, OR, 0xFFFFFFFE, reg ); */
}
@@ -346,7 +346,7 @@
static void synth_PUTVF ( UInt reg )
{
- VG_(emit_movv_reg_offregmem) ( 4, reg, VG_(shadowFlagsOffset)(), R_EBP );
+ VG_(emit_movv_reg_offregmem) ( 4, reg, VG_(shadow_flags_offset)(), R_EBP );
}
@@ -444,7 +444,7 @@
for (i = 0; i < VG_MAX_REALREGS; i++) {
if (! IS_RREG_LIVE(i, regs_live_after)) {
- reg_of_i = VG_(rankToRealRegNum)(i);
+ reg_of_i = VG_(rank_to_realreg)(i);
if (reg != reg_of_i) {
dead_reg = reg_of_i;
break;
@@ -564,7 +564,7 @@
/*--- Generate code for a single UInstr. ---*/
/*----------------------------------------------------*/
-void SK_(emitExtUInstr) ( UInstr* u, RRegSet regs_live_before )
+void SK_(emit_XUInstr) ( UInstr* u, RRegSet regs_live_before )
{
switch (u->opcode) {
@@ -631,9 +631,9 @@
break;
default:
- VG_(printf)("emitExtUInstr: unhandled extension insn:\n");
- VG_(ppUInstr)(0,u);
- VG_(panic)("emitExtUInstr: unhandled extension opcode");
+ VG_(printf)("emit_XUInstr: unhandled extension insn:\n");
+ VG_(pp_UInstr)(0,u);
+ VG_(panic)("emit_XUInstr: unhandled extension opcode");
}
}
diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index 286edea..281e895 100644
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -1601,7 +1601,7 @@
vg_freed_list_start = sc1->next;
}
sc1->next = NULL; /* just paranoia */
- VG_(freeShadowChunk) ( sc1 );
+ VG_(free_ShadowChunk) ( sc1 );
}
}
diff --git a/memcheck/mc_translate.c b/memcheck/mc_translate.c
index 139b3d1..e41e5e4 100644
--- a/memcheck/mc_translate.c
+++ b/memcheck/mc_translate.c
@@ -38,7 +38,7 @@
vg_translate.c:VG_(saneUInstr)(). Everything general said there applies
here too.
*/
-Bool SK_(saneExtUInstr)(Bool beforeRA, Bool beforeLiveness, UInstr* u)
+Bool SK_(sane_XUInstr)(Bool beforeRA, Bool beforeLiveness, UInstr* u)
{
// SSS: duplicating these macros really sucks
# define LIT0 (u->lit32 == 0)
@@ -93,7 +93,7 @@
case TAG2: return LIT0 && SZ0 && CC0 && TR1 && TR2 && Ls3 && XOTHER;
default:
VG_(printf)("unhandled opcode: %u\n", u->opcode);
- VG_(panic)("SK_(saneExtUInstr): unhandled opcode");
+ VG_(panic)("SK_(sane_XUInstr): unhandled opcode");
}
# undef LIT0
# undef LIT1
@@ -160,7 +160,7 @@
}
-Char* SK_(nameExtUOpcode)(Opcode opc)
+Char* SK_(name_XUOpcode)(Opcode opc)
{
switch (opc) {
case GETVF: return "GETVF";
@@ -175,7 +175,7 @@
case SETV: return "SETV";
default:
VG_(printf)("unhandled opcode: %u\n", opc);
- VG_(panic)("SK_(nameExtUOpcode): unhandled case");
+ VG_(panic)("SK_(name_XUOpcode): unhandled case");
}
}
@@ -183,60 +183,60 @@
Debugging stuff.
------------------------------------------------------------------ */
-void SK_(ppExtUInstr)(UInstr* u)
+void SK_(pp_XUInstr)(UInstr* u)
{
switch (u->opcode) {
case TAG1:
VG_(printf)("\t");
- VG_(ppUOperand)(u, 1, 4, False);
+ VG_(pp_UOperand)(u, 1, 4, False);
VG_(printf)(" = %s ( ", nameOfTagOp( u->val3 ));
- VG_(ppUOperand)(u, 1, 4, False);
+ VG_(pp_UOperand)(u, 1, 4, False);
VG_(printf)(" )");
break;
case TAG2:
VG_(printf)("\t");
- VG_(ppUOperand)(u, 2, 4, False);
+ VG_(pp_UOperand)(u, 2, 4, False);
VG_(printf)(" = %s ( ", nameOfTagOp( u->val3 ));
- VG_(ppUOperand)(u, 1, 4, False);
+ VG_(pp_UOperand)(u, 1, 4, False);
VG_(printf)(", ");
- VG_(ppUOperand)(u, 2, 4, False);
+ VG_(pp_UOperand)(u, 2, 4, False);
VG_(printf)(" )");
break;
case STOREV: case LOADV:
VG_(printf)("\t");
- VG_(ppUOperand)(u, 1, u->size, u->opcode==LOADV);
+ VG_(pp_UOperand)(u, 1, u->size, u->opcode==LOADV);
VG_(printf)(", ");
- VG_(ppUOperand)(u, 2, u->size, u->opcode==STOREV);
+ VG_(pp_UOperand)(u, 2, u->size, u->opcode==STOREV);
break;
case PUTVF: case GETVF:
VG_(printf)("\t");
- VG_(ppUOperand)(u, 1, 0, False);
+ VG_(pp_UOperand)(u, 1, 0, False);
break;
case GETV: case PUTV:
VG_(printf)("\t");
- VG_(ppUOperand)(u, 1, u->opcode==PUTV ? 4 : u->size, False);
+ VG_(pp_UOperand)(u, 1, u->opcode==PUTV ? 4 : u->size, False);
VG_(printf)(", ");
- VG_(ppUOperand)(u, 2, u->opcode==GETV ? 4 : u->size, False);
+ VG_(pp_UOperand)(u, 2, u->opcode==GETV ? 4 : u->size, False);
break;
case TESTV: case SETV:
VG_(printf)("\t");
- VG_(ppUOperand)(u, 1, u->size, False);
+ VG_(pp_UOperand)(u, 1, u->size, False);
break;
default:
VG_(printf)("unhandled opcode: %u\n", u->opcode);
- VG_(panic)("SK_(ppExtUInstr): unhandled opcode");
+ VG_(panic)("SK_(pp_XUInstr): unhandled opcode");
}
}
-Int SK_(getExtRegUsage)(UInstr* u, Tag tag, RegUse* arr)
+Int SK_(get_Xreg_usage)(UInstr* u, Tag tag, RegUse* arr)
{
# define RD(ono) VG_UINSTR_READS_REG(ono)
# define WR(ono) VG_UINSTR_WRITES_REG(ono)
@@ -263,7 +263,7 @@
default:
VG_(printf)("unhandled opcode: %u\n", u->opcode);
- VG_(panic)("SK_(getExtRegUsage): unhandled opcode");
+ VG_(panic)("SK_(get_Xreg_usage): unhandled opcode");
}
return n;
@@ -275,13 +275,13 @@
/*--- New instrumentation machinery. ---*/
/*------------------------------------------------------------*/
-#define uInstr1 VG_(newUInstr1)
-#define uInstr2 VG_(newUInstr2)
-#define uInstr3 VG_(newUInstr3)
-#define uLiteral VG_(setLiteralField)
-#define uCCall VG_(setCCallFields)
-#define newTemp VG_(getNewTemp)
-#define newShadow VG_(getNewShadow)
+#define uInstr1 VG_(new_UInstr1)
+#define uInstr2 VG_(new_UInstr2)
+#define uInstr3 VG_(new_UInstr3)
+#define uLiteral VG_(set_lit_field)
+#define uCCall VG_(set_ccall_fields)
+#define newTemp VG_(get_new_temp)
+#define newShadow VG_(get_new_shadow)
static
TagOp get_Tag_ImproveOR_TQ ( Int sz )
@@ -511,7 +511,7 @@
Int i, j;
UInstr* u_in;
Int qs, qd, qt, qtt;
- cb = VG_(allocCodeBlock)();
+ cb = VG_(alloc_UCodeBlock)();
cb->nextTemp = cb_in->nextTemp;
for (i = 0; i < cb_in->used; i++) {
@@ -524,7 +524,7 @@
break;
case INCEIP:
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* Loads and stores. Test the V bits for the address. 24
@@ -545,7 +545,7 @@
uInstr2(cb, LOADV, u_in->size,
TempReg, u_in->val1,
TempReg, SHADOW(u_in->val2));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
case STORE:
@@ -556,7 +556,7 @@
uInstr2(cb, STOREV, u_in->size,
TempReg, SHADOW(u_in->val1),
TempReg, u_in->val2);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* Moving stuff around. Make the V bits follow accordingly,
@@ -566,26 +566,26 @@
uInstr2(cb, GETV, u_in->size,
ArchReg, u_in->val1,
TempReg, SHADOW(u_in->val2));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
case PUT:
uInstr2(cb, PUTV, u_in->size,
TempReg, SHADOW(u_in->val1),
ArchReg, u_in->val2);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
case GETF:
/* This is not the smartest way to do it, but should work. */
qd = create_GETVF(cb, u_in->size);
uInstr2(cb, MOV, 4, TempReg, qd, TempReg, SHADOW(u_in->val1));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
case PUTF:
create_PUTVF(cb, u_in->size, SHADOW(u_in->val1));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
case MOV:
@@ -602,7 +602,7 @@
default:
VG_(panic)("memcheck_instrument: MOV");
}
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* Special case of add, where one of the operands is a literal.
@@ -610,12 +610,12 @@
Therefore: lea1#(qa) = left(qa)
*/
case LEA1:
- vg_assert(u_in->size == 4 && !VG_(anyFlagUse)(u_in));
+ vg_assert(u_in->size == 4 && !VG_(any_flag_use)(u_in));
qs = SHADOW(u_in->val1);
qd = SHADOW(u_in->val2);
uInstr2(cb, MOV, 4, TempReg, qs, TempReg, qd);
create_Left(cb, u_in->size, qd);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* Another form of add.
@@ -628,7 +628,7 @@
*/
case LEA2: {
Int shift;
- vg_assert(u_in->size == 4 && !VG_(anyFlagUse)(u_in));
+ vg_assert(u_in->size == 4 && !VG_(any_flag_use)(u_in));
switch (u_in->extra4b) {
case 1: shift = 0; break;
case 2: shift = 1; break;
@@ -646,7 +646,7 @@
}
create_UifU(cb, 4, qs, qd);
create_Left(cb, u_in->size, qd);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
}
@@ -656,7 +656,7 @@
create_Left(cb, u_in->size, qd);
if (u_in->flags_w != FlagsEmpty)
create_PUTVF(cb, u_in->size, qd);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* This is a HACK (approximation :-) */
@@ -691,7 +691,7 @@
create_UifU(cb, 0, qs, qd);
create_PUTVF(cb, 0, qd);
create_PCast(cb, 0, u_in->size, qd);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* for OP in shl shr sar rol ror
@@ -741,7 +741,7 @@
uInstr2(cb, MOV, 4, TempReg, qs, TempReg, qt);
create_PCast(cb, 1, u_in->size, qt);
create_UifU(cb, u_in->size, qt, qd);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
}
@@ -750,20 +750,20 @@
vg_assert(u_in->tag1 == TempReg);
create_Widen(cb, u_in->signed_widen, u_in->extra4b, u_in->size,
SHADOW(u_in->val1));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* not#(x) = x (since bitwise independent) */
case NOT:
vg_assert(u_in->tag1 == TempReg);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* neg#(x) = left(x) (derivable from case for SUB) */
case NEG:
vg_assert(u_in->tag1 == TempReg);
create_Left(cb, u_in->size, SHADOW(u_in->val1));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* bswap#(x) = bswap(x) */
@@ -772,7 +772,7 @@
vg_assert(u_in->size == 4);
qd = SHADOW(u_in->val1);
uInstr1(cb, BSWAP, 4, TempReg, qd);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* cc2val#(qd) = pcast-0-to-size(eflags#) */
@@ -781,7 +781,7 @@
vg_assert(u_in->flags_r != FlagsEmpty);
qt = create_GETVF(cb, u_in->size);
uInstr2(cb, MOV, 4, TempReg, qt, TempReg, SHADOW(u_in->val1));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* cmov#(qs,qd) = cmov(qs,qd)
@@ -807,7 +807,7 @@
LAST_UINSTR(cb).cond = u_in->cond;
LAST_UINSTR(cb).flags_r = u_in->flags_r;
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* add#/sub#(qs,qd)
@@ -833,7 +833,7 @@
if (u_in->flags_w != FlagsEmpty) {
create_PUTVF(cb, u_in->size, qd);
}
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* xor#(qs,qd) = qs `UifU` qd */
@@ -844,7 +844,7 @@
if (u_in->flags_w != FlagsEmpty) {
create_PUTVF(cb, u_in->size, qd);
}
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* and#/or#(qs,qd)
@@ -888,7 +888,7 @@
if (u_in->flags_w != FlagsEmpty) {
create_PUTVF(cb, u_in->size, qd);
}
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* Machinery to do with supporting CALLM. Copy the start and
@@ -896,7 +896,7 @@
(debug); they generate no code and have no effect.
*/
case CALLM_S: case CALLM_E:
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* Copy PUSH and POP verbatim. Arg/result absval
@@ -905,7 +905,7 @@
needs to be copied.
*/
case PUSH: case POP: case CLEAR:
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* In short:
@@ -974,7 +974,7 @@
... */
uInstr1(cb, SETV, 0, TempReg, qt);
}
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
}
/* Whew ... */
@@ -994,13 +994,13 @@
... */
uInstr1(cb, SETV, 0, TempReg, qt);
}
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
case JIFZ:
uInstr1(cb, TESTV, 4, TempReg, SHADOW(u_in->val1));
uInstr1(cb, SETV, 4, TempReg, SHADOW(u_in->val1));
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
/* Emit a check on the address used. The value loaded into the
@@ -1021,24 +1021,24 @@
: (Addr) & SK_(fpu_write_check),
2, 2, False);
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
}
/* For FPU insns not referencing memory, just copy thru. */
case FPU:
- VG_(copyUInstr)(cb, u_in);
+ VG_(copy_UInstr)(cb, u_in);
break;
default:
- VG_(ppUInstr)(0, u_in);
+ VG_(pp_UInstr)(0, u_in);
VG_(panic)( "memcheck_instrument: unhandled case");
} /* end of switch (u_in->opcode) */
} /* end of for loop */
- VG_(freeCodeBlock)(cb_in);
+ VG_(free_UCodeBlock)(cb_in);
return cb;
}
@@ -1056,10 +1056,10 @@
#define VGC_VALUE ((UChar)101)
#define NOP_no_msg(uu) \
- do { VG_(newNOP)(uu); } while (False)
+ do { VG_(new_NOP)(uu); } while (False)
#define NOP_tag1_op(uu) \
- do { VG_(newNOP)(uu); \
+ do { VG_(new_NOP)(uu); \
if (dis) \
VG_(printf)(" at %2d: delete %s due to defd arg\n", \
i, nameOfTagOp(u->val3)); \
@@ -1106,7 +1106,7 @@
if (u->opcode == GETV && VGC_IS_SHADOW(u->val2)
&& next_is_write[u->val2]
&& !SK_(clo_check_addrVs)) {
- VG_(newNOP)(u);
+ VG_(new_NOP)(u);
if (dis)
VG_(printf)(" at %2d: delete GETV\n", i);
} else
@@ -1114,7 +1114,7 @@
if (u->opcode == TAG1 && VGC_IS_SHADOW(u->val1)
&& next_is_write[u->val1]
&& !SK_(clo_check_addrVs)) {
- VG_(newNOP)(u);
+ VG_(new_NOP)(u);
if (dis)
VG_(printf)(" at %2d: delete TAG1\n", i);
} else
@@ -1122,7 +1122,7 @@
if (u->opcode == TAG2 && VGC_IS_SHADOW(u->val2)
&& next_is_write[u->val2]
&& !SK_(clo_check_addrVs)) {
- VG_(newNOP)(u);
+ VG_(new_NOP)(u);
if (dis)
VG_(printf)(" at %2d: delete TAG2\n", i);
} else
@@ -1134,7 +1134,7 @@
&& next_is_write[u->val2]) {
/* This MOV is pointless because the target is dead at this
point. Delete it. */
- VG_(newNOP)(u);
+ VG_(new_NOP)(u);
if (dis)
VG_(printf)(" at %2d: delete MOV\n", i);
} else
@@ -1144,7 +1144,7 @@
vg_assert(VGC_IS_SHADOW(u->val1));
if (next_is_write[u->val1]) {
/* This write is pointless, so annul it. */
- VG_(newNOP)(u);
+ VG_(new_NOP)(u);
if (dis)
VG_(printf)(" at %2d: delete SETV\n", i);
} else {
@@ -1157,7 +1157,7 @@
} else {
/* Find out what this insn does to the temps. */
- k = VG_(getRegUsage)(u, TempReg, &tempUse[0]);
+ k = VG_(get_reg_usage)(u, TempReg, &tempUse[0]);
vg_assert(k <= 3);
for (j = k-1; j >= 0; j--) {
next_is_write[ tempUse[j].num ]
@@ -1172,7 +1172,7 @@
property. This removes a lot of redundant tag-munging code.
Unfortunately it requires intimate knowledge of how each uinstr and
tagop modifies its arguments. This duplicates knowledge of uinstr
- tempreg uses embodied in VG_(getRegUsage)(), which is unfortunate.
+ tempreg uses embodied in VG_(get_reg_usage)(), which is unfortunate.
The supplied UCodeBlock* is modified in-place.
For each value temp, def[] should hold VGC_VALUE.
@@ -1415,7 +1415,7 @@
unhandled:
/* We don't know how to handle this uinstr. Be safe, and
set to VGC_VALUE or VGC_UNDEF all temps written by it. */
- k = VG_(getRegUsage)(u, TempReg, &tempUse[0]);
+ k = VG_(get_reg_usage)(u, TempReg, &tempUse[0]);
vg_assert(k <= 3);
for (j = 0; j < k; j++) {
t = tempUse[j].num;
@@ -1425,7 +1425,7 @@
if (0&& VGC_IS_SHADOW(t) && def[t] <= 4)
VG_(printf)("ignoring def %d at %s %s\n",
def[t],
- VG_(nameUOpcode)(True, u->opcode),
+ VG_(name_UOpcode)(True, u->opcode),
(u->opcode == TAG1 || u->opcode == TAG2)
? nameOfTagOp(u->val3)
: (Char*)"");
@@ -1454,7 +1454,7 @@
cb = memcheck_instrument ( cb );
if (SK_(clo_cleanup)) {
if (dis) {
- VG_(ppUCodeBlock) ( cb, "Unimproved instrumented UCode:" );
+ VG_(pp_UCodeBlock) ( cb, "Unimproved instrumented UCode:" );
VG_(printf)("Instrumentation improvements:\n");
}
vg_cleanup(cb);