Пример #1
0
 /**
  * Insert an instruction before instruction (handle) ih contained in this list.
  *
  * @param ih where to insert to the instruction list
  * @param i Instruction to insert
  * @return instruction handle of the first inserted instruction
  */
 public BranchHandle insert(InstructionHandle ih, BranchInstruction i) {
   BranchHandle bh = BranchHandle.getBranchHandle(i);
   InstructionList il = new InstructionList();
   il.append(bh);
   insert(ih, il);
   return bh;
 }
Пример #2
0
 /**
  * Append another list to this one. Consumes argument list, i.e., it becomes empty.
  *
  * @param il list to append to end of this list
  * @return instruction handle of the <B>first</B> appended instruction
  */
 public InstructionHandle append(InstructionList il) {
   if (il == null) {
     throw new ClassGenException("Appending null InstructionList");
   }
   if (il.isEmpty()) {
     return null;
   }
   if (isEmpty()) {
     start = il.start;
     end = il.end;
     length = il.length;
     il.clear();
     return start;
   } else {
     return append(end, il); // was end.instruction
   }
 }
Пример #3
0
 /** @return complete, i.e., deep copy of this list */
 public InstructionList copy() {
   Map<InstructionHandle, InstructionHandle> map =
       new HashMap<InstructionHandle, InstructionHandle>();
   InstructionList il = new InstructionList();
   /* Pass 1: Make copies of all instructions, append them to the new list
    * and associate old instruction references with the new ones, i.e.,
    * a 1:1 mapping.
    */
   for (InstructionHandle ih = start; ih != null; ih = ih.next) {
     Instruction i = ih.instruction;
     Instruction c = i.copy(); // Use clone for shallow copy
     if (c instanceof BranchInstruction) {
       map.put(ih, il.append((BranchInstruction) c));
     } else {
       map.put(ih, il.append(c));
     }
   }
   /* Pass 2: Update branch targets.
    */
   InstructionHandle ih = start;
   InstructionHandle ch = il.start;
   while (ih != null) {
     Instruction i = ih.instruction;
     Instruction c = ch.instruction;
     if (i instanceof BranchInstruction) {
       BranchInstruction bi = (BranchInstruction) i;
       BranchInstruction bc = (BranchInstruction) c;
       InstructionHandle itarget = bi.getTarget(); // old target
       // New target is in hash map
       bc.setTarget(map.get(itarget));
       if (bi instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
         InstructionHandle[] itargets = ((Select) bi).getTargets();
         InstructionHandle[] ctargets = ((Select) bc).getTargets();
         for (int j = 0; j < itargets.length; j++) { // Update all targets
           ctargets[j] = map.get(itargets[j]);
         }
       }
     }
     ih = ih.next;
     ch = ch.next;
   }
   return il;
 }
Пример #4
0
 /**
  * Insert another list before Instruction handle ih contained in this list. Consumes argument
  * list, i.e., it becomes empty.
  *
  * @param ih where to append the instruction list
  * @param il Instruction list to insert
  * @return instruction handle of the first inserted instruction
  */
 public InstructionHandle insert(InstructionHandle ih, InstructionList il) {
   if (il == null) {
     throw new ClassGenException("Inserting null InstructionList");
   }
   if (il.isEmpty()) {
     return ih;
   }
   InstructionHandle prev = ih.prev, ret = il.start;
   ih.prev = il.end;
   il.end.next = ih;
   il.start.prev = prev;
   if (prev != null) {
     prev.next = il.start;
   } else {
     start = il.start; // Update start ...
   }
   length += il.length; // Update length
   il.clear();
   return ret;
 }
Пример #5
0
 /**
  * Append another list after instruction (handle) ih contained in this list. Consumes argument
  * list, i.e., it becomes empty.
  *
  * @param ih where to append the instruction list
  * @param il Instruction list to append to this one
  * @return instruction handle pointing to the <B>first</B> appended instruction
  */
 public InstructionHandle append(InstructionHandle ih, InstructionList il) {
   if (il == null) {
     throw new ClassGenException("Appending null InstructionList");
   }
   if (il.isEmpty()) {
     return ih;
   }
   InstructionHandle next = ih.next, ret = il.start;
   ih.next = il.start;
   il.start.prev = ih;
   il.end.next = next;
   if (next != null) {
     next.prev = il.end;
   } else {
     end = il.end; // Update end ...
   }
   length += il.length; // Update length
   il.clear();
   return ret;
 }