Obfuscation of Abstract Data-Types - Rowan

CHAPTER 2. OBFUSCATIONS FOR INTERMEDIATE LANGUAGE 31
For a slightly more complicated example, the expression x + 5 (where x is a
local variable) is represented by
expr type(applyatom(add(false,true),
expr type(localvar(sname(“x”)),
int(true,b32)),
expr type(ldc(int(true,b32), 5),
int(true,b32))),
int(true,b32))
The term localvar(sname(“x”)) refers to the local variable x — the seemingly
redundant constructor sname reflects the fact that it is also possible to use a
different constructor to refer to local variables by their position in the method’s
declaration list, although this facility is not used.
The constructor applyatom exists to simplify the relationship between IL
and EIL — the term add(false,true) directly corresponds to the IL instruction
add, which adds the top two items on the stack as signed values without overflow.
Thus, the meaning of applyatom can be summarised as: “apply the IL
instruction in the first parameter to the rest of the parameters, as if they were
on the stack”.
Finally, it remains to explain how EIL instructions are defined. It is these
that will be used to label the edges and nodes of flow graphs. An instruction
is either an expression, a branch or a return statement, combined with a list
of labels for that statement using the constructor instr label. For example, the
following defines a conditional branch to the label target:
instr label(“conditional” : nil,
branch(cond(. . .), “target”))
Note that we borrow the notation for lists from functional programming, writing
X : Xs instead of [X |Xs]. If the current instruction is an expression, then exp
enclosing an expression would be used in place of branch, and similarly return
is used in the case of a return statement.
2.3.3 Predicates for EIL
The nodes of the flow graph are labelled with the logic term corresponding to
the EIL instruction at that node. In addition, each edge is labelled with the
term of the EIL instruction at the node that the edge points to; it is these labels
that are used to solve the existential and universal queries.
The logic language provides primitives to access the relevant label given
a node or an edge — @elabel(E,I) holds if I is the instruction at edge E,
and @vlabel(V ,I) holds if I is the instruction at node V (where @ denotes a
primitive).
We can define the set predicate used in Section 2.3.1 as follows:
set(X,A,E) :−
@elabel(E,instr label( ,exp(expr type(assign(X,A), )))).
Note that we denote unbound variables by using an underscore. It is straightforward
to define def in terms of set:
def (X,E) :− set(X, ,E)