Commit: 78b1fdcbe04515975798731d8526e966e0a89b50 - chncpu (git)

Commit MetaInfo

• Revision: 78b1fdcbe04515975798731d8526e966e0a89b50 (tree)
• Time: 2014-07-08 02:04:59
• Author: hikarupsp <hikarupsp@user...>
• Commiter: hikarupsp

Log Message

MALLOCを実装中。DATA命令の処理のリファクタリングを行った。

Change Summary

• modified: chncpu/args.c
• modified: chncpu/chncpu.h
• modified: chncpu/opcache.h
• modified: chncpu/opcode.c

Incremental Difference

--- a/chncpu/args.c
+++ b/chncpu/args.c
@@ -87,11 +87,7 @@ int CHNCPU_VMArgs_BindDataToRuntimeEnv(CHNCPU_RuntimeEnvironment *env, CHNCPU_VM
 		env->iReg[bdTag->iReg] = CHNCPU_Op_DATA_GetDataCount(bdTag->dataOPTag);
 		env->iRegBits[bdTag->iReg] = CHNCPU_BITS_MAX;
 		// データタグを指定されたPRegに格納
-		env->pReg[bdTag->pReg].mindex = CHNCPU_MemoryIndex_INVALID;
-		env->pReg[bdTag->pReg].opTag = bdTag->dataOPTag;
-		env->pReg[bdTag->pReg].pindex = 0;
-		env->pReg[bdTag->pReg].type = CHNCPU_Op_DATA_GetDataType(bdTag->dataOPTag);
-
+		CHNCPU_Op_DATA_AssignDataTagToPReg(env, bdTag->pReg, bdTag->dataOPTag);
 	}
 	
 	return 0;

--- a/chncpu/chncpu.h
+++ b/chncpu/chncpu.h
@@ -223,9 +223,13 @@ int CHNCPU_Op_CompareIReg_PrintCode(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag
 int CHNCPU_Op_DATA_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, unsigned int prefix);
 int CHNCPU_Op_DATA_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op);
 int CHNCPU_Op_DATA_PrintCode(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, FILE *file);
+CHNCPU_OpTag *CHNCPU_Op_DATA_CreateEmptyData(void);
+int CHNCPU_Op_DATA_AllocateRawDataMemory(CHNCPU_OpTag *op, ch4_sint dataType, ch4_uint dataCount);
 CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch4_sint pType);
+int CHNCPU_Op_DATA_AssignDataTagToPReg(CHNCPU_RuntimeEnvironment *env, ch4_uint p, CHNCPU_OpTag *op);
 int CHNCPU_Op_DATA_WriteRawDataToFile(CHNCPU_OpTag *op, const char dataPath[], int dataCount, int dataType);
 int CHNCPU_Op_DATA_ReadAtIndex(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, int index);
+int CHNCPU_Op_DATA_CalculateByteSizeOfRawData(ch4_sint dataType, ch4_uint dataCount);
 int CHNCPU_Op_DATA_GetDataCount(CHNCPU_OpTag *op);
 int CHNCPU_Op_DATA_GetDataType(CHNCPU_OpTag *op);
 const char *CHNCPU_Op_DATA_GetFilePath(CHNCPU_OpTag *op);

--- a/chncpu/opcache.h
+++ b/chncpu/opcache.h
@@ -124,7 +124,6 @@ struct _CHNCPU_OP_CACHE_TERNARY_REG {
 //		26 TSTZ		((r1 & r2) == 0) ? -1 : 0;
 //		27 TSTNZ	((r1 & r2) != 0) ? -1 : 0;
 //
-
 typedef struct _CHNCPU_OP_CACHE_COMPARE_IREG CHNCPU_OpCache_CompareIReg;
 struct _CHNCPU_OP_CACHE_COMPARE_IREG {
     ch4_uint rSrc1;
@@ -159,6 +158,20 @@ struct _CHNCPU_OP_CACHE_DATA {
 // 2F n
 //
 
+//
+// 32 MALLOC
+//
+// 32 rType bitType rCount bitCount p
+//
+typedef struct _CHNCPU_OP_CACHE_MALLOC CHNCPU_OpCache_MALLOC;
+struct _CHNCPU_OP_CACHE_MALLOC {
+    ch4_uint rType;
+    ch4_uint bitType;
+	ch4_uint rCount;
+	ch4_uint bitCount;
+	ch4_uint p;
+};
+
 
 
 #endif

--- a/chncpu/opcode.c
+++ b/chncpu/opcode.c
@@ -725,15 +725,15 @@ int CHNCPU_Op_DATA_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
 	opCache->filePath = NULL;
 	
 	// Check ptype & Calculate rawDataByteSize
-	if(opCache->dataType == CHNCPU_PType_UINT8){
-		opCache->rawDataByteSize = opCache->dataCount;
-	} else{
-		env->errFlags |= CHNCPU_ERR_C_UNAVAILABLE_PTYPE;
+	if(CHNCPU_Op_DATA_AllocateRawDataMemory(op, opCache->dataType, opCache->dataCount)){
+		if(CHNCPU_Op_DATA_CalculateByteSizeOfRawData(opCache->dataType, opCache->dataCount) <= 0){
+			env->errFlags |= CHNCPU_ERR_C_UNAVAILABLE_PTYPE;
+		} else{
+			env->errFlags |= CHNCPU_ERR_C_INTERNAL;
+		}
 		return -1;
 	}
 	
-	opCache->rawData = malloc(opCache->rawDataByteSize);
-	
 	// Bind rawData
 	if(opCache->dataType == CHNCPU_PType_UINT8){
 		for(i = 0; i < opCache->dataCount; i++){
@@ -783,12 +783,10 @@ int CHNCPU_Op_DATA_PrintCode(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, F
 	
     return 0;
 }
-CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch4_sint pType)
+CHNCPU_OpTag *CHNCPU_Op_DATA_CreateEmptyData(void)
 {
-	FILE *fp;
 	CHNCPU_OpTag *op;
 	CHNCPU_OpCache_DATA *opCache;
-	int i;
 	
 	op = malloc(sizeof(CHNCPU_OpTag));
 	if(!op){
@@ -805,8 +803,56 @@ CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch
 	
 	opCache->labelID = 0;
 	opCache->labelOpt = 0;
-	opCache->dataType = pType;
-	opCache->filePath = dataPath;
+	opCache->dataType = CHNCPU_PType_Undefined;
+	opCache->dataCount = 0;
+	opCache->rawData = NULL;
+	opCache->rawDataByteSize = 0;
+	opCache->filePath = NULL;
+	
+	return op;
+}
+int CHNCPU_Op_DATA_AllocateRawDataMemory(CHNCPU_OpTag *op, ch4_sint dataType, ch4_uint dataCount)
+{
+	// 生データのメモリを割り当てる。
+	CHNCPU_OpCache_DATA *opCache;
+	
+	if(!op || op->opCode != CHNCPU_OP_DATA || !op->opCache){
+        return -1;
+	}
+	opCache = op->opCache;
+	
+	opCache->rawDataByteSize = CHNCPU_Op_DATA_CalculateByteSizeOfRawData(dataType, dataCount);
+	if(opCache->rawDataByteSize <= 0){
+		return -1;
+	}
+	if(opCache->rawData){
+		puts("CHNCPU_Op_DATA_AllocateRawDataMemory: Double allocation. abort.");
+		exit(EXIT_FAILURE);
+	}
+	opCache->rawData = malloc(opCache->rawDataByteSize);
+	if(!opCache->rawData){
+		opCache->rawDataByteSize = 0;
+		return -1;
+	}
+	
+	opCache->dataType = dataType;
+	opCache->dataCount = dataCount;
+	
+	return 0;
+}
+CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch4_sint pType)
+{
+	// 現状ではUINT8のみ
+	FILE *fp;
+	CHNCPU_OpTag *op;
+	CHNCPU_OpCache_DATA *opCache;
+	int i;
+	
+	op = CHNCPU_Op_DATA_CreateEmptyData();
+	if(!op){
+		return NULL;
+	}
+	opCache = op->opCache;
 	
 	fp = fopen(dataPath, "rb");
 	if(!fp){
@@ -815,21 +861,19 @@ CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch
 		return NULL;
 	}
 	fseek(fp, 0, SEEK_END);
-	
 	opCache->rawDataByteSize = (int)ftell(fp);
-	
 	fseek(fp, 0, SEEK_SET);
 	
-	opCache->rawData = malloc(opCache->rawDataByteSize);
-	if(!opCache->rawData){
+	// 現状はUINT8前提なのでopCache->rawDataByteSize==dataCount
+	if(CHNCPU_Op_DATA_AllocateRawDataMemory(op, pType, opCache->rawDataByteSize)){
 		fclose(fp);
 		free(opCache);
 		free(op);
 		return NULL;
 	}
 	
+	// データの中身をファイルからコピー
 	if(opCache->dataType == CHNCPU_PType_UINT8){
-		opCache->dataCount = opCache->rawDataByteSize;
 	 	for(i = 0; i < opCache->dataCount; i++){
 			((unsigned char *)opCache->rawData)[i] = (unsigned char)fgetc(fp);
 		}
@@ -845,6 +889,24 @@ CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch
 	return op;
 }
 
+int CHNCPU_Op_DATA_AssignDataTagToPReg(CHNCPU_RuntimeEnvironment *env, ch4_uint p, CHNCPU_OpTag *op)
+{
+	CHNCPU_OpCache_DATA *opCache;
+	
+	if(!op || op->opCode != CHNCPU_OP_DATA || !op->opCache || p >= CHNCPU_NUMBER_OF_PREG){
+        return -1;
+	}
+	opCache = op->opCache;
+	
+	// データタグを指定されたPRegに格納
+	env->pReg[p].mindex = CHNCPU_MemoryIndex_INVALID;
+	env->pReg[p].opTag = op;
+	env->pReg[p].pindex = 0;
+	env->pReg[p].type = opCache->dataType;
+	
+	return 0;
+}
+
 int CHNCPU_Op_DATA_WriteRawDataToFile(CHNCPU_OpTag *op, const char dataPath[], int dataCount, int dataType)
 {
 	// retv: written bytes
@@ -902,6 +964,13 @@ int CHNCPU_Op_DATA_ReadAtIndex(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
 	
 	return retv;
 }
+int CHNCPU_Op_DATA_CalculateByteSizeOfRawData(ch4_sint dataType, ch4_uint dataCount)
+{
+	if(dataType == CHNCPU_PType_UINT8){
+		return dataCount;
+	}
+	return 0;
+}
 int CHNCPU_Op_DATA_GetDataCount(CHNCPU_OpTag *op)
 {
 	if(!op || op->opCode != CHNCPU_OP_DATA || !op->opCache){
@@ -927,3 +996,83 @@ const char *CHNCPU_Op_DATA_GetFilePath(CHNCPU_OpTag *op)
 	return ((CHNCPU_OpCache_DATA *)op->opCache)->filePath;
 }
 
+//
+// 32 MALLOC
+//
+/*
+int CHNCPU_Op_MALLOC_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, unsigned int prefix)
+{
+    CHNCPU_OpCache_MALLOC *opCache;
+    
+    opCache = malloc(sizeof(CHNCPU_OpCache_MALLOC));
+    op->opCache = opCache;
+    
+    opCache->rType = CH4Reader_ReadNextAsUINT(env->appbinReader);
+    opCache->bitType = CH4Reader_ReadNextAsUINT(env->appbinReader);
+    opCache->rCount = CH4Reader_ReadNextAsUINT(env->appbinReader);
+	opCache->bitCount = CH4Reader_ReadNextAsUINT(env->appbinReader);
+	opCache->p = CH4Reader_ReadNextAsUINT(env->appbinReader);
+    
+    if(opCache->rType >= CHNCPU_NUMBER_OF_IREG ||
+	   opCache->rCount >= CHNCPU_NUMBER_OF_IREG ||
+	   opCache->p >= CHNCPU_NUMBER_OF_PREG){
+        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        return -1;
+    }
+    if(!CHNCPU_CHK_IsAvailableBits(env, opCache->bitType) ||
+	   !CHNCPU_CHK_IsAvailableBits(env, opCache->bitCount)){
+        return -1;
+    }
+	if(prefix != 0){
+		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+        return -1;
+	}
+    return 0;
+}
+
+int CHNCPU_Op_MALLOC_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
+{
+	CHNCPU_OpTag *dataOpTag;
+    CHNCPU_OpCache_MALLOC *opCache;
+	int value;
+	ch4_sint type;
+	ch4_uint count;
+    
+    opCache = op->opCache;
+    
+    type = env->iReg[opCache->rType];
+	count = env->iReg[opCache->rCount];
+	
+	dataOpTag = CHNCPU_Op_DATA_CreateEmptyData();
+	if(CHNCPU_Op_DATA_AllocateRawDataMemory(dataOpTag, type, count)){
+		
+	}
+	
+	
+	value = CHNCPU_Op_DATA_ReadAtIndex(env, p->opTag, p->pindex);
+	if(env->errFlags){
+		return -1;
+	}
+	
+	CHNCPU_AdjustValueForBit(env, &value, opCache->bitDst, CHNCPU_PREFIX_ALLOW_TRUNCATE);
+	if(env->errFlags){
+		return -1;
+	}
+	env->iReg[opCache->r] = value;
+	env->iRegBits[opCache->r] = opCache->bitDst;
+	
+	p->pindex += opCache->pDiff;
+    
+    return 0;
+}
+int CHNCPU_Op_MALLOC_PrintCode(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, FILE *file)
+{
+    CHNCPU_OpCache_LMEM *opCache;
+    
+    opCache = op->opCache;
+    fprintf(file, "LMEM(p:0x%02X, pType:0x%X, pDiff:%d, r:%02X, bitDst:%d);\n", opCache->p, opCache->pType, opCache->pDiff, opCache->r, opCache->bitDst);
+	
+    return 0;
+}
+
+*/
\ No newline at end of file