A CIL Tutorial - Department of Computer Science - ETH Zürich

CHAPTER 4. INSTRUMENTATION 38
findOrCreateFunc : file → string → typ → varinfo.
If the function is found, the varinfo for it is returned, otherwise a prototype for the function is
added to the le, and the varinfo for it is returned.
let initTutFunctions (f : file) : unit =
let focf : string → typ → varinfo = findOrCreateFunc f in
let bl type = mkFunTyp voidType ["f", charConstPtrType; "l", intType] in
let el type = mkFunTyp voidType ["f", charConstPtrType; "l", intType; "c", intType; ] in
tutfuns.begin loop ← focf begin loop str bl type;
tutfuns.end loop ← focf end loop str el type
4.1.2 Loop instrumentation
The function makeInstrStmts creates four statements that we'll add to loops. In the returned tuple,
the rst statement calls the loop begin instrumentation function. The second statement initializes
the iteration counter to zero. The third statement increments the iteration counter, and the fourth
statement calls the loop end instrumentation function.
In makeInstrStmts we use some shorthand. mkString turns an OCaml string into a Cil.exp
constant expression. The integer function does the same for OCaml ints. The v2e function creates
an exp out of a varinfo. The var function creates an lval from a varinfo, and the i2s function
creates a stmt from an instr. All these can be found in Tututil or Cil.
let makeInstrStmts (counter : varinfo) (loc : location)
: stmt × stmt × stmt × stmt =
let f, l = mkString loc.file, integer loc.line in
i2s (Call(None, v2e tutfuns.begin loop, [f; l], loc)),
i2s (Set(var counter, zero, loc)),
i2s (Set(var counter, BinOp(PlusA, v2e counter, one, counter.vtype), loc)),
i2s (Call(None, v2e tutfuns.end loop, [f; l; v2e counter], loc))
The class loopInstrumenterClass is a visitor that uses makeInstrStmts to instrument loops. In
vstmt we update the statement s by writing to the mutable skind eld instead of rebuilding a
whole new statement so that we don't have to worry about copying over all the other elds, which
we'd like to remain the same. In particular, it is very easy to forget about statement labels.
Further, we use ChangeDoChildrenPost because there might be nested loops. Remember:
ChangeDoChildrenPost recurses into s's children before handling s. That way, we have no innite
loops due to turning s into a statement that contains the original s.
class loopInstrumenterClass (fd : fundec) = object(self)
inherit nopCilVisitor