pearcolator-devel Mailing List for PearColator (Page 4)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 99
          http://svn.sourceforge.net/pearcolator/?rev=99&view=rev
Author:   michael_baer
Date:     2007-04-30 10:59:37 -0700 (Mon, 30 Apr 2007)

Log Message:
-----------
- Fixed bugs
- Removed support of using the PC as an argument where the ARM Ref. manual specifies that using the PC with this opcode yields an undefined result
- Added support for long multiplication instructions

Modified Paths:
--------------
    src/org/binarytranslator/arch/arm/decoder/ARM_Interpreter.java

Modified: src/org/binarytranslator/arch/arm/decoder/ARM_Interpreter.java
===================================================================

--- src/org/binarytranslator/arch/arm/decoder/ARM_Interpreter.java	2007-04-30 13:24:05 UTC (rev 98)
+++ src/org/binarytranslator/arch/arm/decoder/ARM_Interpreter.java	2007-04-30 17:59:37 UTC (rev 99)
@@ -441,9 +441,7 @@
       super(instr);
     }
 
-    /** Returns the value of operand 1 of the data processing instruction. This is always a register value.
-     * However, deriving classes may alter this behavior, for example to return a negative register
-     * value for a RSB instruction. */
+    /** Returns the value of operand 1 of the data processing instruction. This is always a register value. */
     protected int resolveOperand1() {
 
       if (Rn == ARM_Registers.PC) {
@@ -635,6 +633,9 @@
           operand2++;
         } else {
           regs.setFlags(operand1 > 0, operand1 != 0, true, true);
+          
+          //set the result to any of the operands
+          regs.set(Rd, operand1);
           return;
         }
       }
@@ -666,6 +667,7 @@
           //TODO: Remove this exception, when the correct behavior has been verified.
           throw new RuntimeException("I'm interested in finding a case where this occurs, so this exception is sooner or later going to 'notify' me..");
           //regs.setFlags(operand1 > 0, operand1 != 0, true, true);
+          //regs.set(Rd, operand1);
           //return;
         }
       }
@@ -843,7 +845,7 @@
       int memAddr = regs.get(Rn);
       
       //swap exchanges the value of a memory address with the value in a register
-      if (swapByte) {
+      if (!swapByte) {
         int tmp = ps.memory.load32(memAddr);
         ps.memory.store32(memAddr, regs.get(Rm));
         
@@ -853,8 +855,8 @@
       }
       else {
         int tmp = ps.memory.loadUnsigned8(memAddr);
-        ps.memory.store8(memAddr, regs.get(Rm) & 0xFF);
-        regs.set(Rm, tmp);
+        ps.memory.store8(memAddr, regs.get(Rm));
+        regs.set(Rd, tmp);
       }
     }
 
@@ -942,7 +944,6 @@
         if (transferPC) {
           nextAddress += 4;
           int newpc = ps.memory.load32(nextAddress);
-          regs.set(ARM_Registers.PC, newpc & 0xFFFFFFFE);
 
           if (forceUser) {
             //when we are transferring the PC with a forced-user transfer, then we also want to
@@ -953,11 +954,18 @@
             regs.setOperatingModeWithoutRegisterLayout(OperatingMode.USR);
             regs.restoreSPSR2CPSR();
             
+            if (regs.getThumbMode())
+              newpc = newpc & 0xFFFFFFFE;
+            else
+              newpc = newpc & 0xFFFFFFFC;
+            
+            regs.set(ARM_Registers.PC, newpc);
             //there is no write-back for this instruction.
             return;
           }
           else {
             //shall we switch to thumb mode
+            regs.set(ARM_Registers.PC, newpc & 0xFFFFFFFE);
             regs.setThumbMode((newpc & 0x1) != 0);
           }
         }
@@ -1024,12 +1032,9 @@
     }
 
     public void execute() {
-      //remember the previous address, taking ARM's register offset into account
-      int previousAddress = regs.get(ARM_Registers.PC);
-
       //if we're supposed to link, then write the previous address into the link register
       if (link)
-        regs.set(ARM_Registers.LR, previousAddress + 4);
+        regs.set(ARM_Registers.LR, regs.get(ARM_Registers.PC) + 4);
     }
 
     public int getSuccessor(int pc) {
@@ -1102,25 +1107,16 @@
 
     public void execute() {
       //get the two operands
+      //we don't need to consider that any operand might be the PC, because the ARM
+      //Ref. manual specifies the usage of the PC has undefined results in this operation
       int operand1 = regs.get(Rm);
       int operand2 = regs.get(Rs);
       
-      //if any of the operands is the PC, consider ARM's PC offset
-      if (Rm == ARM_Registers.PC)
-        operand1 += 8;
-      
-      if (Rs == ARM_Registers.PC)
-        operand2 += 8;
-      
       //calculate the result
-      int result = regs.get(Rm) * regs.get(Rs);
+      int result = operand1 * operand2;
 
       if (accumulate) {
         result += regs.get(Rn);
-        
-        //also consider ARM's PC offset when adding the accumulate register
-        if (Rn == ARM_Registers.PC)
-          result += 8;
       }
 
       //and finally, update the register map
@@ -1132,13 +1128,59 @@
     }
 
     public int getSuccessor(int pc) {
-      if (Rd != ARM_Registers.PC)
-        return pc + 4;
-      else
-        return -1;
+      return pc + 4;
     }
   }
+  
+  /** Multiply two longs into a register, possibly adding the value of a third register on the way. */
+  private final class LongMultiply extends ARM_Instructions.LongMultiply implements
+  ARM_Instruction {
 
+    protected LongMultiply(int instr) {
+      super(instr);
+    }
+
+    public void execute() {
+
+      // get the two operands
+      // We don't need to consider that any operand might be the PC, because the
+      // ARM Ref. manual specifies the usage of the PC has undefined results in this
+      // operation
+      long operand1 = regs.get(Rm);
+      long operand2 = regs.get(Rs);
+      
+      //get rid of the signs, if we're supposed to do unsigned multiplication
+      if (unsigned) {
+        operand1 = operand1 & 0xFFFFFFFF;
+        operand2 = operand2 & 0xFFFFFFFF;
+      }
+
+      // calculate the result
+      long result = operand1 * operand2;
+
+      if (accumulate) {
+        //treat the register as an unsigned value
+        long operand = regs.get(getRdLow());
+        operand &= 0xFFFFFFFF;
+        result += operand; 
+
+        result += regs.get(getRdHigh()) << 32;
+      }
+
+      // and finally, update the register map
+      regs.set(getRdLow(), (int) result);
+      regs.set(getRdHigh(), (int) (result >>> 32));
+
+      if (updateConditionCodes) {
+        regs.setFlags(result < 0, result == 0);
+      }
+    }
+
+    public int getSuccessor(int pc) {
+      return pc + 4;
+    }
+  }
+
   /** Move the value of the program status register into a register. */
   private final class MoveFromStatusRegister extends
       ARM_Instructions.MoveFromStatusRegister implements
@@ -1338,11 +1380,11 @@
           break;
           
         case HalfWord:
-          ps.memory.store16(address, value & 0xFFFF);
+          ps.memory.store16(address, value);
           break;
           
         case Byte:
-          ps.memory.store8(address, value & 0xFF);
+          ps.memory.store8(address, value);
           break;
 
         default:
@@ -1500,8 +1542,7 @@
     }
 
     public ARM_Instruction createLongMultiply(int instr) {
-      //TODO: Implement multiplications with longs
-      throw new RuntimeException("Long Multiplications are not yet supported.");
+      return new LongMultiply(instr);
     }
 
     public ARM_Instruction createMoveFromStatusRegister(int instr) {


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2006	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec (2)
2007	Jan	Feb	Mar (16)	Apr (83)	May (27)	Jun (14)	Jul (11)	Aug (22)	Sep	Oct	Nov	Dec

pearcolator-devel Mailing List for PearColator (Page 4)

pearcolator-devel — List for PearColator developers