static guint32
get_metadata_stream_header (test_entry_t *entry, guint32 idx)
{
guint32 offset;
offset = get_cli_metadata_root (entry);
offset = pad4 (offset + 16 + READ_VAR (guint32, entry->data + offset + 12));
offset += 4;
while (idx--) {
int i;
offset += 8;
for (i = 0; i < 32; ++i) {
if (!READ_VAR (guint8, entry->data + offset++))
break;
}
offset = pad4 (offset);
}
return offset;
}
void XICATTRIBUTE::write_icattr_to_packet(TxPacket *p)
{
int i, l;
char tmp[4];
for (i = 0; i < 4; i++) {
tmp[i] = 0;
}
for (i = 0, l = 0; i < (int)(sizeof(xic_attributes) / sizeof(XICATTRIBUTE)); i++) {
l += 6;
l += static_cast<int>(strlen(xic_attributes[i].name));
l += pad4(static_cast<int>(strlen(xic_attributes[i].name)) + 2);
}
p->pushC16((C16)l);
p->pushC16(0);
for (i = 0; i < (int)(sizeof(xic_attributes) / sizeof(XICATTRIBUTE)); i++) {
p->pushC16((C16)i);
p->pushC16(xic_attributes[i].type);
p->pushC16((C16)strlen(xic_attributes[i].name));
p->pushBytes(xic_attributes[i].name,
static_cast<int>(strlen(xic_attributes[i].name)));
p->pushBytes(tmp, pad4(static_cast<int>(
strlen(xic_attributes[i].name)) + 2));
}
}
void Connection::push_error_packet(C16 imid, C16 icid, C16 er, const char *str)
{
TxPacket *t;
t = createTxPacket(XIM_ERROR, 0);
t->pushC16(imid);
t->pushC16(icid);
int m = 0;
if (imid)
m += 1;
if (icid)
m += 2;
t->pushC16((C16)m);
t->pushC16(er);
int l = static_cast<int>(strlen(str));
char tmp[4];
t->pushC16((C16)l);
t->pushC16(0);
t->pushBytes(str, l);
t->pushBytes(tmp, pad4(l));
push_packet(t);
}
void CodeVerifier::verifyFunctionLayout(SEXP sexp, InterpreterInstance* ctx) {
if (TYPEOF(sexp) != EXTERNALSXP)
Rf_error("RIR Verifier: Invalid SEXPTYPE");
Function* f = Function::unpack(sexp);
// get the code objects
std::vector<Code*> objs;
objs.push_back(f->body());
for (size_t i = 0; i < f->numArgs; ++i)
if (f->defaultArg(i))
objs.push_back(f->defaultArg(i));
if (f->size > XLENGTH(sexp))
Rf_error("RIR Verifier: Reported size must be smaller than the size of "
"the vector");
// check that the call instruction has proper arguments and number of
// instructions is valid
while (!objs.empty()) {
auto c = objs.back();
objs.pop_back();
if (c->info.magic != CODE_MAGIC)
Rf_error("RIR Verifier: Invalid code magic number");
if (c->src == 0)
Rf_error("RIR Verifier: Code must have AST");
unsigned oldo = c->stackLength;
calculateAndVerifyStack(c);
if (oldo != c->stackLength)
Rf_error("RIR Verifier: Invalid stack layout reported");
if (((uintptr_t)(c + 1) + pad4(c->codeSize) +
c->srcLength * sizeof(Code::SrclistEntry)) == 0)
Rf_error("RIR Verifier: Invalid code length reported");
Opcode* cptr = c->code();
Opcode* start = cptr;
Opcode* end = start + c->codeSize;
while (true) {
if (cptr > end)
Rf_error("RIR Verifier: Bytecode overflow");
BC cur = BC::decode(cptr, c);
switch (hasSources(cur.bc)) {
case Sources::Required:
if (c->getSrcIdxAt(cptr, true) == 0)
Rf_error("RIR Verifier: Source required but not found");
break;
case Sources::NotNeeded:
if (c->getSrcIdxAt(cptr, true) != 0)
Rf_error("RIR Verifier: Sources not needed but stored");
break;
case Sources::May: {
}
}
if (*cptr == Opcode::br_ || *cptr == Opcode::brobj_ ||
*cptr == Opcode::brtrue_ || *cptr == Opcode::brfalse_) {
int off = *reinterpret_cast<int*>(cptr + 1);
if (cptr + cur.size() + off < start ||
cptr + cur.size() + off > end)
Rf_error("RIR Verifier: Branch outside closure");
}
if (*cptr == Opcode::ldvar_) {
unsigned* argsIndex = reinterpret_cast<Immediate*>(cptr + 1);
if (*argsIndex >= cp_pool_length(ctx))
Rf_error("RIR Verifier: Invalid arglist index");
SEXP sym = cp_pool_at(ctx, *argsIndex);
if (TYPEOF(sym) != SYMSXP)
Rf_error("RIR Verifier: LdVar binding not a symbol");
if (!(strlen(CHAR(PRINTNAME(sym)))))
Rf_error("RIR Verifier: LdVar empty binding name");
}
if (*cptr == Opcode::promise_) {
unsigned* promidx = reinterpret_cast<Immediate*>(cptr + 1);
objs.push_back(c->getPromise(*promidx));
}
if (*cptr == Opcode::ldarg_) {
unsigned idx = *reinterpret_cast<Immediate*>(cptr + 1);
if (idx >= MAX_ARG_IDX)
Rf_error("RIR Verifier: Loading out of index argument");
}
if (*cptr == Opcode::call_implicit_ ||
*cptr == Opcode::named_call_implicit_) {
uint32_t nargs = *reinterpret_cast<Immediate*>(cptr + 1);
for (size_t i = 0, e = nargs; i != e; ++i) {
uint32_t offset = cur.callExtra().immediateCallArguments[i];
if (offset == MISSING_ARG_IDX || offset == DOTS_ARG_IDX)
continue;
objs.push_back(c->getPromise(offset));
}
if (*cptr == Opcode::named_call_implicit_) {
for (size_t i = 0, e = nargs; i != e; ++i) {
uint32_t offset = cur.callExtra().callArgumentNames[i];
if (offset) {
SEXP name = cp_pool_at(ctx, offset);
if (TYPEOF(name) != SYMSXP && name != R_NilValue)
Rf_error("RIR Verifier: Calling target not a "
"symbol");
}
}
}
}
if (*cptr == Opcode::named_call_) {
uint32_t nargs = *reinterpret_cast<Immediate*>(cptr + 1);
for (size_t i = 0, e = nargs; i != e; ++i) {
uint32_t offset = cur.callExtra().callArgumentNames[i];
if (offset) {
SEXP name = cp_pool_at(ctx, offset);
if (TYPEOF(name) != SYMSXP && name != R_NilValue)
Rf_error(
"RIR Verifier: Calling target not a symbol");
}
}
}
if (*cptr == Opcode::mk_env_ || *cptr == Opcode::mk_stub_env_) {
uint32_t nargs = *reinterpret_cast<Immediate*>(cptr + 1);
for (size_t i = 0, e = nargs; i != e; ++i) {
uint32_t offset = cur.mkEnvExtra().names[i];
SEXP name = cp_pool_at(ctx, offset);
if (TYPEOF(name) != SYMSXP)
Rf_error(
"RIR Verifier: environment argument not a symbol");
}
}
cptr += cur.size();
if (cptr == start + c->codeSize) {
if (!(cur.isJmp() && cur.immediate.offset < 0) &&
!(cur.isExit()))
Rf_error("RIR Verifier: Last opcode should jump backwards "
"or exit");
break;
}
}
}
}
