Commit: 7e5a6010f234caa8d9ba8aa2af10e4cfc4ae224b - chncpu (git)

Commit MetaInfo

• Revisión: 7e5a6010f234caa8d9ba8aa2af10e4cfc4ae224b (tree)
• Tiempo: 2014-06-06 23:09:56
• Autor: hikarupsp <hikarupsp@user...>
• Commiter: hikarupsp

Log Message

LIMMが動くようになった

Cambiar Resumen

• modified: chncpu/chncpu.c
• modified: chncpu/chncpu.h
• modified: chncpu/opcode.c
• modified: chncpu/test.hex

Diferencia incremental

--- a/chncpu/chncpu.c
+++ b/chncpu/chncpu.c
@@ -18,6 +18,7 @@ int main(int argc, const char * argv[])
     }
     env = CHNCPU_CreateRuntimeEnvironment();
     CHNCPU_LoadBinaryFromHexStringFilePath(env, argv[1]);
+    CHNCPU_Execute(env);
     return 0;
 }
 
@@ -119,6 +120,20 @@ CHNCPU_RuntimeEnvironment *CHNCPU_CreateRuntimeEnvironment(void)
     
     env->appbinReader = malloc(sizeof(CH4Reader));
     
+    // bindOpFuncTable
+    for(i = 0; i <= CHNCPU_OPECODE_MAX; i++){
+        env->bindOpFuncTable[i] = NULL;
+    }
+    env->bindOpFuncTable[0x02] = CHNCPU_Op_LIMM_BindOperand;
+    
+    // execOpFuncTable
+    for(i = 0; i <= CHNCPU_OPECODE_MAX; i++){
+        env->execOpFuncTable[i] = NULL;
+    }
+    env->execOpFuncTable[0x02] = CHNCPU_Op_LIMM_Execute;
+    
+    env->errFlags = 0;
+    
     return env;
 }
 
@@ -159,6 +174,7 @@ int CHNCPU_PrepareBinaryForExecution(CHNCPU_RuntimeEnvironment *env)
     int index, page;
     CHNCPU_OpTag *op;
     int breakFlag = 0;
+    int retv;
     
     // env->appbinReaderから読み込んで、実行可能な状態にする。
     // これはコンパイラ版におけるコンパイルに相当する。
@@ -169,7 +185,7 @@ int CHNCPU_PrepareBinaryForExecution(CHNCPU_RuntimeEnvironment *env)
         for(index = 0; index < CHNCPU_NUMBER_OF_OP_TAG; index++){
             opcode = CH4Reader_ReadNextAsUINT(env->appbinReader);
             if(CH4Reader_IsEndOfBinary(env->appbinReader)){
-                puts("< End of binary > \n");
+                puts("< End of binary >");
                 breakFlag = 1;
                 break;
             }
@@ -180,32 +196,106 @@ int CHNCPU_PrepareBinaryForExecution(CHNCPU_RuntimeEnvironment *env)
             switch(opcode){
                 case 0x00:
                     // NOP
-                    puts("NOP();");
-                    break;
-                case 0x02:
-                    // LIMM
-                    CHNCPU_Op_LIMM_BindOperand(env, op);
+                    puts("NOP();\n");
+                    index--;
                     break;
                 default:
-                    // Undefined
-                    op->opCode = CHNCPU_OPCODE_INVALID;
-                    puts("Undefined Opcode. \n");
-                    breakFlag = 1;
+                    // ごく一部の特殊な命令以外は、命令テーブルを参照する
+                    if(opcode <= CHNCPU_OPECODE_MAX && env->bindOpFuncTable[opcode]){
+                        retv = env->bindOpFuncTable[opcode](env, op);
+                        if(retv){
+                            opcode = CHNCPU_OPCODE_INVALID;
+                        }
+                    } else{
+                        opcode = CHNCPU_OPCODE_INVALID;
+                    }
+                    if(opcode == CHNCPU_OPCODE_INVALID){
+                        op->opCode = CHNCPU_OPCODE_INVALID;
+                        env->errFlags |= CHNCPU_ERR_C_OPCODE;
+                        breakFlag = 1;
+                    }
                     break;
             }
             if(breakFlag == 1){
                 break;
             }
-            putchar('\n');
         }
         if(breakFlag){
             break;
         }
     }
+    if(env->errFlags){
+        putchar('\n');
+        if(env->errFlags & CHNCPU_ERR_C_REGNUM){
+            puts("INVALID-C: Invalid register number.");
+        }
+        if(env->errFlags & CHNCPU_ERR_C_BITS){
+            puts("INVALID-C: Not supported bit width.");
+        }
+        if(env->errFlags & CHNCPU_ERR_C_OPCODE){
+            puts("INVALID-C: Unknown opCode.");
+        }
+    }
 
     return 0;
 }
 
+int CHNCPU_Execute(CHNCPU_RuntimeEnvironment *env)
+{
+    int breakFlag = 0;
+    int count = 0;
+    int retv;
+    CHNCPU_OpTag *op;
+    
+    puts("< Beginning of execution >");
+    for(; env->currentPage < CHNCPU_NUMBER_OF_MEMORY_PAGE; env->currentPage++){
+        op = &env->mainmemory[env->currentPage].data[0];
+        if(op->opCode == CHNCPU_OPCODE_INVALID){
+            // 空白のメモリページ:バイナリの末端
+            puts(">>> Control reached end of binary.");
+            breakFlag = 1;
+            break;
+        }
+        for(; env->currentIndex < CHNCPU_NUMBER_OF_OP_TAG; env->currentIndex++){
+            op = &env->mainmemory[env->currentPage].data[env->currentIndex];
+            if(op->opCode == CHNCPU_OPCODE_INVALID){
+                // このページはここでおしまい
+                break;
+            }
+            if(op->opCode <= CHNCPU_OPECODE_MAX && env->bindOpFuncTable[op->opCode]){
+                retv = env->execOpFuncTable[op->opCode](env, op);
+            } else{
+                // すでにチェックしたはずなのに不明な命令が来た
+                env->errFlags |= CHNCPU_ERR_X_INTERNAL;
+                breakFlag = 1;
+                break;
+            }
+            if(retv){
+                breakFlag = 1;
+                break;
+            }
+
+        }
+        if(breakFlag){
+            break;
+        }
+        count++;
+        env->currentIndex = 0;
+    }
+    if(env->errFlags){
+        putchar('\n');
+        if(env->errFlags & CHNCPU_ERR_X_INTERNAL){
+            puts("INVALID-X: Internal error.");
+        }
+    }
+    
+    CHNCPU_DumpIReg(env);
+    
+    puts("< End of execution >");
+    
+    return count;
+}
+
 void CHNCPU_DumpAppBin(CHNCPU_RuntimeEnvironment *env)
 {
     int i;
@@ -221,4 +311,24 @@ void CHNCPU_DumpAppBin(CHNCPU_RuntimeEnvironment *env)
     }
 }
 
+void CHNCPU_DumpIReg(CHNCPU_RuntimeEnvironment *env)
+{
+    int i, regs = 0;
+    
+    puts(">>> Integer registers");
+    
+    for(i = 0; i < CHNCPU_NUMBER_OF_IREG; i++){
+        if(env->iRegBits[i]){
+            printf("R%02X:0x%08X(%2d) ", i, env->iReg[i], env->iRegBits[i]);
+            if((regs & 0xF) == 0xF){
+                putchar('\n');
+            }
+            regs++;
+        }
+    }
+    if(((regs - 1) & 0xF) != 0xF){
+        putchar('\n');
+    }
+}
+
 

--- a/chncpu/chncpu.h
+++ b/chncpu/chncpu.h
@@ -15,6 +15,7 @@
 
 #define SIZE_TMPDATA    (1024 * 1024 * 1)
 
+#define CHNCPU_OPECODE_MAX              0xFF
 #define CHNCPU_BITS_MAX                 32
 #define CHNCPU_BITS_DEFAULT             32
 #define CHNCPU_NUMBER_OF_IREG           64
@@ -25,6 +26,9 @@
 
 #define CHNCPU_ERR_C_REGNUM         1
 #define CHNCPU_ERR_C_BITS           2
+#define CHNCPU_ERR_C_OPCODE         4
+
+#define CHNCPU_ERR_X_INTERNAL       1
 
 typedef struct CHNCPU_OP_TAG CHNCPU_OpTag;
 struct CHNCPU_OP_TAG {
@@ -40,12 +44,16 @@ struct CHNCPU_MEMORY_PAGE {
 
 typedef struct CHNCPU_RUN_TIME_ENVIRONMENT CHNCPU_RuntimeEnvironment;
 struct CHNCPU_RUN_TIME_ENVIRONMENT {
+	int (*bindOpFuncTable[CHNCPU_OPECODE_MAX])(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op);
+    int (*execOpFuncTable[CHNCPU_OPECODE_MAX])(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op);
     int iReg[CHNCPU_NUMBER_OF_IREG];
     int iRegBits[CHNCPU_NUMBER_OF_IREG];
     CHNCPU_MemoryPage mainmemory[CHNCPU_NUMBER_OF_MEMORY_PAGE];
     unsigned char *appbin0;
     int appbinsize;
 	CH4Reader *appbinReader;
+    unsigned int errFlags;
+    int currentPage, currentIndex;
 };
 
 typedef struct CHNCPU_OP_CACHE_LIMM CHNCPU_OpCache_LIMM;
@@ -60,9 +68,12 @@ int decodeHexString(char *src0, char *src1, unsigned char *dst0, unsigned char *
 CHNCPU_RuntimeEnvironment *CHNCPU_CreateRuntimeEnvironment(void);
 int CHNCPU_LoadBinaryFromHexStringFilePath(CHNCPU_RuntimeEnvironment *env, const char *path);
 int CHNCPU_PrepareBinaryForExecution(CHNCPU_RuntimeEnvironment *env);
+int CHNCPU_Execute(CHNCPU_RuntimeEnvironment *env);
 void CHNCPU_DumpAppBin(CHNCPU_RuntimeEnvironment *env);
+void CHNCPU_DumpIReg(CHNCPU_RuntimeEnvironment *env);
 
 // @opcode.c
 int CHNCPU_Op_LIMM_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op);
+int CHNCPU_Op_LIMM_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op);
 
 #endif

--- a/chncpu/opcode.c
+++ b/chncpu/opcode.c
@@ -19,16 +19,35 @@ int CHNCPU_Op_LIMM_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
     opCache->r = CH4Reader_ReadNextAsUINT(env->appbinReader);
     opCache->bit = CH4Reader_ReadNextAsUINT(env->appbinReader);
     
-    printf("LIMM(imm:0x%X r:%d bit:%d);", opCache->imm, opCache->r, opCache->bit);
+    printf("LIMM(imm:0x%X r:%d bit:%d);\n", opCache->imm, opCache->r, opCache->bit);
     
     if(opCache->r >= CHNCPU_NUMBER_OF_IREG){
-        puts("INVALID-C: register number.");
-        return CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        return -1;
     }
     if(opCache->bit > CHNCPU_BITS_MAX){
-        puts("INVALID-C: bits.");
-        return CHNCPU_ERR_C_BITS;
+        env->errFlags |= CHNCPU_ERR_C_BITS;
+        return -1;
     }
     return 0;
 }
 
+int CHNCPU_Op_LIMM_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
+{
+    CHNCPU_OpCache_LIMM *opCache;
+    
+    opCache = op->opCache;
+    
+    printf("LIMM(imm:0x%X r:%d bit:%d);\n", opCache->imm, opCache->r, opCache->bit);
+    
+    env->iReg[opCache->r] = opCache->imm;
+    if(opCache->bit){
+        env->iRegBits[opCache->r] = opCache->bit;
+    } else{
+        env->iRegBits[opCache->r] = CHNCPU_BITS_DEFAULT;
+    }
+    
+    return 0;
+}
+
+

--- a/chncpu/test.hex
+++ b/chncpu/test.hex
@@ -1 +1 @@
-2 E123 0 0
\ No newline at end of file
+2 E123 0 0 2 E365 1 0
\ No newline at end of file