private void VarMapToGraph(VarVersionPair varpaar, SFormsFastMapDirect varmap)
{
VBStyleCollection <VarVersionNode, VarVersionPair> nodes = ssuversions.nodes;
VarVersionNode node = nodes.GetWithKey(varpaar);
node.live = new SFormsFastMapDirect(varmap);
}
private VBStyleCollection <BasicBlock, int> CreateBasicBlocks(short[] startblock,
InstructionSequence instrseq, Dictionary <int, BasicBlock> mapInstrBlocks)
{
VBStyleCollection <BasicBlock, int> col = new VBStyleCollection <BasicBlock, int>();
InstructionSequence currseq = null;
List <int> lstOffs = null;
int len = startblock.Length;
short counter = 0;
int blockoffset = 0;
BasicBlock currentBlock = null;
for (int i = 0; i < len; i++)
{
if (startblock[i] == 1)
{
currentBlock = new BasicBlock(++counter);
currseq = currentBlock.GetSeq();
lstOffs = currentBlock.GetInstrOldOffsets();
col.AddWithKey(currentBlock, currentBlock.id);
blockoffset = instrseq.GetOffset(i);
}
startblock[i] = counter;
Sharpen.Collections.Put(mapInstrBlocks, i, currentBlock);
currseq.AddInstruction(instrseq.GetInstr(i), instrseq.GetOffset(i) - blockoffset);
lstOffs.Add(instrseq.GetOffset(i));
}
last_id = counter;
return(col);
}
protected internal InstructionSequence(VBStyleCollection <Instruction, int> collinstr
)
{
// *****************************************************************************
// private fields
// *****************************************************************************
this.collinstr = collinstr;
}
private static void ProcessClassRec(ClassesProcessor.ClassNode node, IDictionary
<ClassWrapper, MethodWrapper> mapClassMeths, HashSet <ClassWrapper> setFound)
{
ClassWrapper wrapper = node.GetWrapper();
// search code
foreach (MethodWrapper meth in wrapper.GetMethods())
{
RootStatement root = meth.root;
if (root != null)
{
DirectGraph graph = meth.GetOrBuildGraph();
graph.IterateExprents((Exprent exprent) => {
foreach (KeyValuePair <ClassWrapper, MethodWrapper> ent in mapClassMeths)
{
if (ReplaceInvocations(exprent, ent.Key, ent.Value))
{
setFound.Add(ent.Key);
}
}
return(0);
}
);
}
}
// search initializers
for (int j = 0; j < 2; j++)
{
VBStyleCollection <Exprent, string> initializers = j == 0 ? wrapper.GetStaticFieldInitializers
() : wrapper.GetDynamicFieldInitializers();
for (int i = 0; i < initializers.Count; i++)
{
foreach (KeyValuePair <ClassWrapper, MethodWrapper> ent in mapClassMeths)
{
Exprent exprent = initializers[i];
if (ReplaceInvocations(exprent, ent.Key, ent.Value))
{
setFound.Add(ent.Key);
}
string cl = IsClass14Invocation(exprent, ent.Key, ent.Value);
if (cl != null)
{
initializers[i] = new ConstExprent(VarType.Vartype_Class, cl.Replace('.', '/'), exprent
.bytecode);
setFound.Add(ent.Key);
}
}
}
}
// iterate nested classes
foreach (ClassesProcessor.ClassNode nd in node.nested)
{
ProcessClassRec(nd, mapClassMeths, setFound);
}
}
//return ranges.isEmpty() ? null : ranges;
// public String getExceptionsUniqueString(BasicBlock handler, BasicBlock block) {
//
// List<ExceptionRangeCFG> ranges = getExceptionRange(handler, block);
//
// if(ranges == null) {
// return null;
// } else {
// Set<String> setExceptionStrings = new HashSet<String>();
// for(ExceptionRangeCFG range : ranges) {
// setExceptionStrings.add(range.getExceptionType());
// }
//
// String ret = "";
// for(String exception : setExceptionStrings) {
// ret += exception;
// }
//
// return ret;
// }
// }
// *****************************************************************************
// private methods
// *****************************************************************************
private void BuildBlocks(InstructionSequence instrseq)
{
short[] states = FindStartInstructions(instrseq);
Dictionary <int, BasicBlock> mapInstrBlocks = new Dictionary <int, BasicBlock>();
VBStyleCollection <BasicBlock, int> colBlocks = CreateBasicBlocks(states, instrseq
, mapInstrBlocks);
blocks = colBlocks;
ConnectBlocks(colBlocks, mapInstrBlocks);
SetExceptionEdges(instrseq, mapInstrBlocks);
SetSubroutineEdges();
SetFirstAndLastBlocks();
}
private void BuildDominatorTree()
{
VBStyleCollection <int?, int> orderedIDoms = domEngine.GetOrderedIDoms();
List <int> lstKeys = orderedIDoms.GetLstKeys();
for (int index = lstKeys.Count - 1; index >= 0; index--)
{
int key = lstKeys[index];
int?idom = orderedIDoms[index];
mapTreeBranches.ComputeIfAbsent(idom, (k) => new HashSet <int>()).Add(key);
}
int firstid = statement.GetFirst().id;
mapTreeBranches.GetOrNull(firstid).Remove(firstid);
}
public FullInstructionSequence(VBStyleCollection <Instruction, int> collinstr, ExceptionTable
extable)
: base(collinstr)
{
// *****************************************************************************
// constructors
// *****************************************************************************
this.exceptionTable = extable;
// translate raw exception handlers to instr
foreach (ExceptionHandler handler in extable.GetHandlers())
{
handler.from_instr = this.GetPointerByAbsOffset(handler.from);
handler.to_instr = this.GetPointerByAbsOffset(handler.to);
handler.handler_instr = this.GetPointerByAbsOffset(handler.handler);
}
}
private static IGraphNode GetCommonIDom(IGraphNode node1, IGraphNode node2, VBStyleCollection
<IGraphNode, IGraphNode> orderedIDoms)
{
IGraphNode nodeOld;
if (node1 == null)
{
return(node2);
}
else if (node2 == null)
{
return(node1);
}
int index1 = orderedIDoms.GetIndexByKey(node1);
int index2 = orderedIDoms.GetIndexByKey(node2);
while (index1 != index2)
{
if (index1 > index2)
{
nodeOld = node1;
node1 = orderedIDoms.GetWithKey(node1);
if (nodeOld == node1)
{
// no idom - root or merging point
return(null);
}
index1 = orderedIDoms.GetIndexByKey(node1);
}
else
{
nodeOld = node2;
node2 = orderedIDoms.GetWithKey(node2);
if (nodeOld == node2)
{
// no idom - root or merging point
return(null);
}
index2 = orderedIDoms.GetIndexByKey(node2);
}
}
return(node1);
}
/// <exception cref="System.IO.IOException"/>
private InstructionSequence ParseBytecode(DataInputFullStream @in, int length, ConstantPool
pool)
{
VBStyleCollection <Instruction, int> instructions = new VBStyleCollection <Instruction
, int>();
int bytecode_version = classStruct.GetBytecodeVersion();
for (int i = 0; i < length;)
{
int offset = i;
int opcode = @in.ReadUnsignedByte();
int group = Group_General;
bool wide = (opcode == opc_wide);
if (wide)
{
i++;
opcode = @in.ReadUnsignedByte();
}
List <int> operands = new List <int>();
if (opcode >= opc_iconst_m1 && opcode <= opc_iconst_5)
{
operands.Add(opr_iconst[opcode - opc_iconst_m1]);
opcode = opc_bipush;
}
else if (opcode >= opc_iload_0 && opcode <= opc_aload_3)
{
operands.Add(opr_loadstore[opcode - opc_iload_0]);
opcode = opcs_load[(opcode - opc_iload_0) / 4];
}
else if (opcode >= opc_istore_0 && opcode <= opc_astore_3)
{
operands.Add(opr_loadstore[opcode - opc_istore_0]);
opcode = opcs_store[(opcode - opc_istore_0) / 4];
}
else
{
switch (opcode)
{
case opc_bipush:
{
operands.Add((int)@in.ReadByte());
i++;
break;
}
case opc_ldc:
case opc_newarray:
{
operands.Add(@in.ReadUnsignedByte());
i++;
break;
}
case opc_sipush:
case opc_ifeq:
case opc_ifne:
case opc_iflt:
case opc_ifge:
case opc_ifgt:
case opc_ifle:
case opc_if_icmpeq:
case opc_if_icmpne:
case opc_if_icmplt:
case opc_if_icmpge:
case opc_if_icmpgt:
case opc_if_icmple:
case opc_if_acmpeq:
case opc_if_acmpne:
case opc_goto:
case opc_jsr:
case opc_ifnull:
case opc_ifnonnull:
{
if (opcode != opc_sipush)
{
group = Group_Jump;
}
operands.Add((int)@in.ReadShort());
i += 2;
break;
}
case opc_ldc_w:
case opc_ldc2_w:
case opc_getstatic:
case opc_putstatic:
case opc_getfield:
case opc_putfield:
case opc_invokevirtual:
case opc_invokespecial:
case opc_invokestatic:
case opc_new:
case opc_anewarray:
case opc_checkcast:
case opc_instanceof:
{
operands.Add(@in.ReadUnsignedShort());
i += 2;
if (opcode >= opc_getstatic && opcode <= opc_putfield)
{
group = Group_Fieldaccess;
}
else if (opcode >= opc_invokevirtual && opcode <= opc_invokestatic)
{
group = Group_Invocation;
}
break;
}
case opc_invokedynamic:
{
if (classStruct.IsVersionGE_1_7())
{
// instruction unused in Java 6 and before
operands.Add(@in.ReadUnsignedShort());
@in.Discard(2);
group = Group_Invocation;
i += 4;
}
break;
}
case opc_iload:
case opc_lload:
case opc_fload:
case opc_dload:
case opc_aload:
case opc_istore:
case opc_lstore:
case opc_fstore:
case opc_dstore:
case opc_astore:
case opc_ret:
{
if (wide)
{
operands.Add(@in.ReadUnsignedShort());
i += 2;
}
else
{
operands.Add(@in.ReadUnsignedByte());
i++;
}
if (opcode == opc_ret)
{
group = Group_Return;
}
break;
}
case opc_iinc:
{
if (wide)
{
operands.Add(@in.ReadUnsignedShort());
operands.Add((int)@in.ReadShort());
i += 4;
}
else
{
operands.Add(@in.ReadUnsignedByte());
operands.Add((int)@in.ReadByte());
i += 2;
}
break;
}
case opc_goto_w:
case opc_jsr_w:
{
opcode = opcode == opc_jsr_w ? opc_jsr : opc_goto;
operands.Add(@in.ReadInt());
group = Group_Jump;
i += 4;
break;
}
case opc_invokeinterface:
{
operands.Add(@in.ReadUnsignedShort());
operands.Add(@in.ReadUnsignedByte());
@in.Discard(1);
group = Group_Invocation;
i += 4;
break;
}
case opc_multianewarray:
{
operands.Add(@in.ReadUnsignedShort());
operands.Add(@in.ReadUnsignedByte());
i += 3;
break;
}
case opc_tableswitch:
{
@in.Discard((4 - (i + 1) % 4) % 4);
i += ((4 - (i + 1) % 4) % 4);
// padding
operands.Add(@in.ReadInt());
i += 4;
int low = @in.ReadInt();
operands.Add(low);
i += 4;
int high = @in.ReadInt();
operands.Add(high);
i += 4;
for (int j = 0; j < high - low + 1; j++)
{
operands.Add(@in.ReadInt());
i += 4;
}
group = Group_Switch;
break;
}
case opc_lookupswitch:
{
@in.Discard((4 - (i + 1) % 4) % 4);
i += ((4 - (i + 1) % 4) % 4);
// padding
operands.Add(@in.ReadInt());
i += 4;
int npairs = @in.ReadInt();
operands.Add(npairs);
i += 4;
for (int j = 0; j < npairs; j++)
{
operands.Add(@in.ReadInt());
i += 4;
operands.Add(@in.ReadInt());
i += 4;
}
group = Group_Switch;
break;
}
case opc_ireturn:
case opc_lreturn:
case opc_freturn:
case opc_dreturn:
case opc_areturn:
case opc_return:
case opc_athrow:
{
group = Group_Return;
break;
}
}
}
int[] ops = null;
if (!(operands.Count == 0))
{
ops = new int[operands.Count];
for (int j = 0; j < operands.Count; j++)
{
ops[j] = operands[j];
}
}
Instruction instr = Instruction.Create(opcode, wide, group, bytecode_version, ops
);
instructions.AddWithKey(instr, offset);
i++;
}
// initialize exception table
List <ExceptionHandler> lstHandlers = new List <ExceptionHandler>();
int exception_count = @in.ReadUnsignedShort();
for (int i = 0; i < exception_count; i++)
{
ExceptionHandler handler = new ExceptionHandler();
handler.from = @in.ReadUnsignedShort();
handler.to = @in.ReadUnsignedShort();
handler.handler = @in.ReadUnsignedShort();
int excclass = @in.ReadUnsignedShort();
if (excclass != 0)
{
handler.exceptionClass = pool.GetPrimitiveConstant(excclass).GetString();
}
lstHandlers.Add(handler);
}
InstructionSequence seq = new FullInstructionSequence(instructions, new ExceptionTable
(lstHandlers));
// initialize instructions
int i_1 = seq.Length() - 1;
seq.SetPointer(i_1);
while (i_1 >= 0)
{
Instruction instr = seq.GetInstr(i_1--);
if (instr.group != Group_General)
{
instr.InitInstruction(seq);
}
seq.AddToPointer(-1);
}
return(seq);
}
public virtual void CollapseNodesToStatement(Statement stat)
{
Statement head = stat.GetFirst();
Statement post = stat.GetPost();
VBStyleCollection <Statement, int> setNodes = stat.GetStats();
// post edges
if (post != null)
{
foreach (StatEdge edge in post.GetEdges(Statedge_Direct_All, Direction_Backward))
{
if (stat.ContainsStatementStrict(edge.GetSource()))
{
edge.GetSource().ChangeEdgeType(Direction_Forward, edge, StatEdge.Type_Break);
stat.AddLabeledEdge(edge);
}
}
}
// regular head edges
foreach (StatEdge prededge in head.GetAllPredecessorEdges())
{
if (prededge.GetType() != StatEdge.Type_Exception && stat.ContainsStatementStrict
(prededge.GetSource()))
{
prededge.GetSource().ChangeEdgeType(Direction_Forward, prededge, StatEdge.Type_Continue
);
stat.AddLabeledEdge(prededge);
}
head.RemovePredecessor(prededge);
prededge.GetSource().ChangeEdgeNode(Direction_Forward, prededge, stat);
stat.AddPredecessor(prededge);
}
if (setNodes.ContainsKey(first.id))
{
first = stat;
}
// exception edges
HashSet <Statement> setHandlers = new HashSet <Statement>(head.GetNeighbours(StatEdge
.Type_Exception, Direction_Forward));
foreach (Statement node in setNodes)
{
setHandlers.UnionWith(node.GetNeighbours(StatEdge.Type_Exception, Direction_Forward
));
}
if (!(setHandlers.Count == 0))
{
foreach (StatEdge edge in head.GetEdges(StatEdge.Type_Exception, Direction_Forward
))
{
Statement handler = edge.GetDestination();
if (setHandlers.Contains(handler))
{
if (!setNodes.ContainsKey(handler.id))
{
stat.AddSuccessor(new StatEdge(stat, handler, edge.GetExceptions()));
}
}
}
foreach (Statement node in setNodes)
{
foreach (StatEdge edge in node.GetEdges(StatEdge.Type_Exception, Direction_Forward
))
{
if (setHandlers.Contains(edge.GetDestination()))
{
node.RemoveSuccessor(edge);
}
}
}
}
if (post != null && !stat.GetNeighbours(StatEdge.Type_Exception, Direction_Forward
).Contains(post))
{
// TODO: second condition redundant?
stat.AddSuccessor(new StatEdge(StatEdge.Type_Regular, stat, post));
}
// adjust statement collection
foreach (Statement st in setNodes)
{
stats.RemoveWithKey(st.id);
}
stats.AddWithKey(stat, stat.id);
stat.SetAllParent();
stat.SetParent(this);
stat.BuildContinueSet();
// monitorenter and monitorexit
stat.BuildMonitorFlags();
if (stat.type == Type_Switch)
{
// special case switch, sorting leaf nodes
((SwitchStatement)stat).SortEdgesAndNodes();
}
}
public static VBStyleCollection <List <int>, int> CalcPostDominators(Statement container
)
{
Dictionary <Statement, FastFixedSetFactory <Statement> .FastFixedSet <Statement> > lists = new Dictionary
<Statement, FastFixedSetFactory <Statement> .FastFixedSet <Statement> >();
StrongConnectivityHelper schelper = new StrongConnectivityHelper(container);
List <List <Statement> > components = schelper.GetComponents();
List <Statement> lstStats = container.GetPostReversePostOrderList(StrongConnectivityHelper
.GetExitReps(components));
FastFixedSetFactory <Statement> factory = new FastFixedSetFactory <Statement>(lstStats
);
FastFixedSetFactory <Statement> .FastFixedSet <Statement> setFlagNodes = factory.SpawnEmptySet(
);
setFlagNodes.SetAllElements();
FastFixedSetFactory <Statement> .FastFixedSet <Statement> initSet = factory.SpawnEmptySet();
initSet.SetAllElements();
foreach (List <Statement> lst in components)
{
FastFixedSetFactory <Statement> .FastFixedSet <Statement> tmpSet;
if (StrongConnectivityHelper.IsExitComponent(lst))
{
tmpSet = factory.SpawnEmptySet();
tmpSet.AddAll(lst);
}
else
{
tmpSet = initSet.GetCopy();
}
foreach (Statement stat in lst)
{
Sharpen.Collections.Put(lists, stat, tmpSet);
}
}
do
{
foreach (Statement stat in lstStats)
{
if (!setFlagNodes.Contains(stat))
{
continue;
}
setFlagNodes.Remove(stat);
FastFixedSetFactory <Statement> .FastFixedSet <Statement> doms = lists.GetOrNull(stat);
FastFixedSetFactory <Statement> .FastFixedSet <Statement> domsSuccs = factory.SpawnEmptySet();
List <Statement> lstSuccs = stat.GetNeighbours(StatEdge.Type_Regular, Statement.Direction_Forward
);
for (int j = 0; j < lstSuccs.Count; j++)
{
Statement succ = lstSuccs[j];
FastFixedSetFactory <Statement> .FastFixedSet <Statement> succlst = lists.GetOrNull(succ);
if (j == 0)
{
domsSuccs.Union(succlst);
}
else
{
domsSuccs.Intersection(succlst);
}
}
if (!domsSuccs.Contains(stat))
{
domsSuccs.Add(stat);
}
if (!InterpreterUtil.EqualObjects(domsSuccs, doms))
{
Sharpen.Collections.Put(lists, stat, domsSuccs);
List <Statement> lstPreds = stat.GetNeighbours(StatEdge.Type_Regular, Statement.Direction_Backward
);
foreach (Statement pred in lstPreds)
{
setFlagNodes.Add(pred);
}
}
}
}while (!setFlagNodes.IsEmpty());
VBStyleCollection <List <int>, int> ret = new VBStyleCollection <List <int>, int>();
List <Statement> lstRevPost = container.GetReversePostOrderList();
// sort order crucial!
Dictionary <int, int> mapSortOrder = new Dictionary <int, int>();
for (int i = 0; i < lstRevPost.Count; i++)
{
Sharpen.Collections.Put(mapSortOrder, lstRevPost[i].id, i);
}
foreach (Statement st in lstStats)
{
List <int> lstPosts = new List <int>();
foreach (Statement stt in lists.GetOrNull(st))
{
lstPosts.Add(stt.id);
}
lstPosts = lstPosts.OrderBy(c => mapSortOrder[c]).ToList();
if (lstPosts.Count > 1 && lstPosts[0] == st.id)
{
lstPosts.Add(lstPosts.RemoveAtReturningValue(0));
}
ret.AddWithKey(lstPosts, st.id);
}
return(ret);
}
private static Statement FindGeneralStatement(Statement stat, bool forceall, Dictionary
<int, HashSet <int> > mapExtPost)
{
VBStyleCollection <Statement, int> stats = stat.GetStats();
VBStyleCollection <List <int>, int> vbPost;
if ((mapExtPost.Count == 0))
{
FastExtendedPostdominanceHelper extpost = new FastExtendedPostdominanceHelper();
Sharpen.Collections.PutAll(mapExtPost, extpost.GetExtendedPostdominators(stat));
}
if (forceall)
{
vbPost = new VBStyleCollection <List <int>, int>();
List <Statement> lstAll = stat.GetPostReversePostOrderList();
foreach (Statement st in lstAll)
{
HashSet <int> set = mapExtPost.GetOrNull(st.id);
if (set != null)
{
vbPost.AddWithKey(new List <int>(set), st.id);
}
}
// FIXME: sort order!!
// tail statements
HashSet <int> setFirst = mapExtPost.GetOrNull(stat.GetFirst().id);
if (setFirst != null)
{
foreach (int id in setFirst)
{
List <int> lst = vbPost.GetWithKey(id);
if (lst == null)
{
vbPost.AddWithKey(lst = new List <int>(), id);
}
lst.Add(id);
}
}
}
else
{
vbPost = CalcPostDominators(stat);
}
for (int k = 0; k < vbPost.Count; k++)
{
int headid = vbPost.GetKey(k);
List <int> posts = vbPost[k];
if (!mapExtPost.ContainsKey(headid) && !(posts.Count == 1 && posts[0].Equals(headid
)))
{
continue;
}
Statement head = stats.GetWithKey(headid);
HashSet <int> setExtPosts = mapExtPost.GetOrNull(headid);
foreach (int postId in posts)
{
if (!postId.Equals(headid) && !setExtPosts.Contains(postId))
{
continue;
}
Statement post = stats.GetWithKey(postId);
if (post == null)
{
// possible in case of an inherited postdominance set
continue;
}
bool same = (post == head);
HashSet <Statement> setNodes = new HashSet <Statement>();
HashSet <Statement> setPreds = new HashSet <Statement>();
// collect statement nodes
HashSet <Statement> setHandlers = new HashSet <Statement>();
setHandlers.Add(head);
while (true)
{
bool hdfound = false;
foreach (Statement handler in setHandlers)
{
if (setNodes.Contains(handler))
{
continue;
}
bool addhd = (setNodes.Count == 0);
// first handler == head
if (!addhd)
{
List <Statement> hdsupp = handler.GetNeighbours(StatEdge.Type_Exception, Statement
.Direction_Backward);
addhd = (setNodes.ContainsAll(hdsupp) && (setNodes.Count > hdsupp.Count || setNodes
.Count == 1));
}
// strict subset
if (addhd)
{
LinkedList <Statement> lstStack = new LinkedList <Statement>();
lstStack.AddLast(handler);
while (!(lstStack.Count == 0))
{
Statement st = lstStack.RemoveAtReturningValue(0);
if (!(setNodes.Contains(st) || (!same && st == post)))
{
setNodes.Add(st);
if (st != head)
{
// record predeccessors except for the head
Sharpen.Collections.AddAll(setPreds, st.GetNeighbours(StatEdge.Type_Regular, Statement
.Direction_Backward));
}
// put successors on the stack
Sharpen.Collections.AddAll(lstStack, st.GetNeighbours(StatEdge.Type_Regular, Statement
.Direction_Forward));
// exception edges
Sharpen.Collections.AddAll(setHandlers, st.GetNeighbours(StatEdge.Type_Exception,
Statement.Direction_Forward));
}
}
hdfound = true;
setHandlers.Remove(handler);
break;
}
}
if (!hdfound)
{
break;
}
}
// check exception handlers
setHandlers.Clear();
foreach (Statement st in setNodes)
{
Sharpen.Collections.AddAll(setHandlers, st.GetNeighbours(StatEdge.Type_Exception,
Statement.Direction_Forward));
}
setHandlers.RemoveAll(setNodes);
bool excok = true;
foreach (Statement handler in setHandlers)
{
if (!handler.GetNeighbours(StatEdge.Type_Exception, Statement.Direction_Backward)
.ContainsAll(setNodes))
{
excok = false;
break;
}
}
// build statement and return
if (excok)
{
Statement res;
setPreds.RemoveAll(setNodes);
if (setPreds.Count == 0)
{
if ((setNodes.Count > 1 || head.GetNeighbours(StatEdge.Type_Regular, Statement.Direction_Backward
).Contains(head)) && setNodes.Count < stats.Count)
{
if (CheckSynchronizedCompleteness(setNodes))
{
res = new GeneralStatement(head, setNodes, same ? null : post);
stat.CollapseNodesToStatement(res);
return(res);
}
}
}
}
}
}
return(null);
}
private static RootStatement GraphToStatement(ControlFlowGraph graph)
{
VBStyleCollection <Statement, int> stats = new VBStyleCollection <Statement, int>();
VBStyleCollection <BasicBlock, int> blocks = graph.GetBlocks();
foreach (BasicBlock block in blocks)
{
stats.AddWithKey(new BasicBlockStatement(block), block.id);
}
BasicBlock firstblock = graph.GetFirst();
// head statement
Statement firstst = stats.GetWithKey(firstblock.id);
// dummy exit statement
DummyExitStatement dummyexit = new DummyExitStatement();
Statement general;
if (stats.Count > 1 || firstblock.IsSuccessor(firstblock))
{
// multiple basic blocks or an infinite loop of one block
general = new GeneralStatement(firstst, stats, null);
}
else
{
// one straightforward basic block
RootStatement root = new RootStatement(firstst, dummyexit);
firstst.AddSuccessor(new StatEdge(StatEdge.Type_Break, firstst, dummyexit, root));
return(root);
}
foreach (BasicBlock block in blocks)
{
Statement stat = stats.GetWithKey(block.id);
foreach (BasicBlock succ in block.GetSuccs())
{
Statement stsucc = stats.GetWithKey(succ.id);
int type;
if (stsucc == firstst)
{
type = StatEdge.Type_Continue;
}
else if (graph.GetFinallyExits().Contains(block))
{
type = StatEdge.Type_Finallyexit;
stsucc = dummyexit;
}
else if (succ.id == graph.GetLast().id)
{
type = StatEdge.Type_Break;
stsucc = dummyexit;
}
else
{
type = StatEdge.Type_Regular;
}
stat.AddSuccessor(new StatEdge(type, stat, (type == StatEdge.Type_Continue) ? general
: stsucc, (type == StatEdge.Type_Regular) ? null : general));
}
// exceptions edges
foreach (BasicBlock succex in block.GetSuccExceptions())
{
Statement stsuccex = stats.GetWithKey(succex.id);
ExceptionRangeCFG range = graph.GetExceptionRange(succex, block);
if (!range.IsCircular())
{
stat.AddSuccessor(new StatEdge(stat, stsuccex, range.GetExceptionTypes()));
}
}
}
general.BuildContinueSet();
general.BuildMonitorFlags();
return(new RootStatement(general, dummyexit));
}
/// <exception cref="System.IO.IOException"/>
public StructClass(DataInputFullStream @in, bool own, LazyLoader loader)
{
/*
* class_file {
* u4 magic;
* u2 minor_version;
* u2 major_version;
* u2 constant_pool_count;
* cp_info constant_pool[constant_pool_count-1];
* u2 access_flags;
* u2 this_class;
* u2 super_class;
* u2 interfaces_count;
* u2 interfaces[interfaces_count];
* u2 fields_count;
* field_info fields[fields_count];
* u2 methods_count;
* method_info methods[methods_count];
* u2 attributes_count;
* attribute_info attributes[attributes_count];
* }
*/
this.own = own;
this.loader = loader;
@in.Discard(4);
minorVersion = @in.ReadUnsignedShort();
majorVersion = @in.ReadUnsignedShort();
pool = new ConstantPool(@in);
accessFlags = @in.ReadUnsignedShort();
int thisClassIdx = @in.ReadUnsignedShort();
int superClassIdx = @in.ReadUnsignedShort();
qualifiedName = pool.GetPrimitiveConstant(thisClassIdx).GetString();
superClass = pool.GetPrimitiveConstant(superClassIdx);
// interfaces
int length = @in.ReadUnsignedShort();
interfaces = new int[length];
interfaceNames = new string[length];
for (int i = 0; i < length; i++)
{
interfaces[i] = @in.ReadUnsignedShort();
interfaceNames[i] = pool.GetPrimitiveConstant(interfaces[i]).GetString();
}
// fields
length = @in.ReadUnsignedShort();
fields = new VBStyleCollection <StructField, string>(length);
for (int i = 0; i < length; i++)
{
StructField field = new StructField(@in, this);
fields.AddWithKey(field, InterpreterUtil.MakeUniqueKey(field.GetName(), field.GetDescriptor
()));
}
// methods
length = @in.ReadUnsignedShort();
methods = new VBStyleCollection <StructMethod, string>(length);
for (int i = 0; i < length; i++)
{
StructMethod method = new StructMethod(@in, this);
methods.AddWithKey(method, InterpreterUtil.MakeUniqueKey(method.GetName(), method
.GetDescriptor()));
}
// attributes
attributes = ReadAttributes(@in, pool);
ReleaseResources();
}
private void RenameClassIdentifiers(StructClass cl, Dictionary <string, string> names
)
{
// all classes are already renamed
string classOldFullName = cl.qualifiedName;
string classNewFullName = interceptor.GetName(classOldFullName);
if (classNewFullName == null)
{
classNewFullName = classOldFullName;
}
// methods
HashSet <string> setMethodNames = new HashSet <string>();
foreach (StructMethod md in cl.GetMethods())
{
setMethodNames.Add(md.GetName());
}
VBStyleCollection <StructMethod, string> methods = cl.GetMethods();
for (int i = 0; i < methods.Count; i++)
{
StructMethod mt = methods[i];
string key = methods.GetKey(i);
bool isPrivate = mt.HasModifier(ICodeConstants.Acc_Private);
string name = mt.GetName();
if (!cl.IsOwn() || mt.HasModifier(ICodeConstants.Acc_Native))
{
// external and native methods must not be renamed
if (!isPrivate)
{
Sharpen.Collections.Put(names, key, name);
}
}
else if (helper.ToBeRenamed(IIdentifierRenamer.Type.Element_Method, classOldFullName
, name, mt.GetDescriptor()))
{
if (isPrivate || !names.ContainsKey(key))
{
do
{
name = helper.GetNextMethodName(classOldFullName, name, mt.GetDescriptor());
}while (setMethodNames.Contains(name));
if (!isPrivate)
{
Sharpen.Collections.Put(names, key, name);
}
}
else
{
name = names.GetOrNull(key);
}
interceptor.AddName(classOldFullName + " " + mt.GetName() + " " + mt.GetDescriptor
(), classNewFullName + " " + name + " " + BuildNewDescriptor(false, mt.GetDescriptor
()));
}
}
// external fields are not being renamed
if (!cl.IsOwn())
{
return;
}
// fields
// FIXME: should overloaded fields become the same name?
HashSet <string> setFieldNames = new HashSet <string>();
foreach (StructField fd in cl.GetFields())
{
setFieldNames.Add(fd.GetName());
}
foreach (StructField fd in cl.GetFields())
{
if (helper.ToBeRenamed(IIdentifierRenamer.Type.Element_Field, classOldFullName, fd
.GetName(), fd.GetDescriptor()))
{
string newName;
do
{
newName = helper.GetNextFieldName(classOldFullName, fd.GetName(), fd.GetDescriptor
());
}while (setFieldNames.Contains(newName));
interceptor.AddName(classOldFullName + " " + fd.GetName() + " " + fd.GetDescriptor
(), classNewFullName + " " + newName + " " + BuildNewDescriptor(true, fd.GetDescriptor
()));
}
}
}
public SimpleInstructionSequence(VBStyleCollection<Instruction, int> collinstr)
: base(collinstr)
{
}
