202108102036

hdl4secell/include/hdl4secell.h

@@ -97,7 +97,7 @@ typedef struct _sGeneralModule {
     int canruninthread;
 }sGeneralModule;
 
-#define USEBIGINT 1
+#define USEBIGINT 0
 
 typedef struct sModuleVariable {
     struct sModuleVariable * pNext, *pLast;
@@ -116,8 +116,25 @@ typedef struct sModuleVariable {
     IBigNumber** data;
     IBigNumber** data_reg;
 #else
-	unsigned long long data;
-	unsigned long long data_reg;
+	union {
+		short				int16;
+		unsigned short		uint16;
+		int					int32;
+		unsigned int		uint32;
+		long long			int64;
+		unsigned long long	uint64;
+		unsigned long long  data;
+	};
+	union {
+		short				int16_reg;
+		unsigned short		uint16_reg;
+		int					int32_reg;
+		unsigned int		uint32_reg;
+		long long			int64_reg;
+		unsigned long long	uint64_reg;
+		unsigned long long  data_reg;
+	};
+
 #endif
 	THREADLOCK lock;
 	int updatefunc;
@@ -258,7 +275,7 @@ void hdl4se_module_DeInit(sGeneralModule* pobj);
 int hdl4se_module_Valid(sGeneralModule* pobj);
 int hdl4se_module_GetName(sGeneralModule* pobj, const char** pname);
 int hdl4se_module_ConnectInput(sGeneralModule* pobj, int index, HOBJECT from, int fromindex);
-int hdl4se_module_GetValue(sGeneralModule* pobj, int index, int width, IBigNumber** value);
+int hdl4se_module_GetValue(sGeneralModule* pobj, int index, int width, ModuleVariable* value);
 int hdl4se_module_ClkTick(sGeneralModule* pobj);
 int hdl4se_module_Setup(sGeneralModule* pobj);
 int hdl4se_module_AddPort(sGeneralModule* pobj, const char* name, int width, int isunsigned, int portdirect);

hdl4secell/src/hdl4se_function.c

@@ -48,7 +48,7 @@
 
 static int gen_get_value(void* p, ModuleVariable* var)
 {
-	return hdl4se_module_GetValue(&var->module->data, var->moduleportindex, var->width, (var->type == VTYPE_REG) ? var->data_reg : var->data);
+	return hdl4se_module_GetValue(&var->module->data, var->moduleportindex, var->width, var);
 }
 
 ModuleFunction* functionCreateFunc(MODULE_FUNC func, void* pobj)

hdl4secell/src/hdl4se_module.c

@@ -82,7 +82,7 @@ inline static void hdl4seUpdateVariableGetValue(ModuleVariable* var)
 	//	var->func_UpdateVariable = hdl4seUpdateVariableNone;
 		//functionCallAndSetNone(var->moduledata->funcs.array[var->genfuncindex]);
 	var->updatefunc = 0;
-	hdl4se_module_GetValue(&var->module->data, var->moduleportindex, var->width, (var->type == VTYPE_REG) ? var->data_reg : var->data);
+	hdl4se_module_GetValue(&var->module->data, var->moduleportindex, var->width, var);// (var->type == VTYPE_REG) ? var->data_reg : var->data);
 }
 
 
@@ -135,6 +135,8 @@ ModuleVariable* hdl4se_module_Var(sGeneralModule* pobj, int ind)
 	return var;
 }
 
+#if USEBIGINT
+
 int hdl4se_module_Assign(sGeneralModule* pobj, int dstind, int srcind)
 {
 	ModuleVariable* vardst, * varsrc;
@@ -247,7 +249,122 @@ void hdl4se_module_SetVarInt64(sGeneralModule* pobj, int varindex, long long v)
 	else
 		objectCall1(var->data, AssignInt64, v);
 }
+#else
+int hdl4se_module_Assign(sGeneralModule* pobj, int dstind, int srcind)
+{
+	ModuleVariable* vardst, * varsrc;
+	if (dstind < 0 || dstind >= pobj->variables.itemcount)
+		return -1;
+	if (srcind < 0 || srcind >= pobj->variables.itemcount)
+		return -1;
+	vardst = (ModuleVariable*)pobj->variables.array[dstind];
+	varsrc = (ModuleVariable*)pobj->variables.array[srcind];
+	UpdateVariable(varsrc);
+	if (vardst->type == VTYPE_REG)
+		vardst->data_reg = varsrc->data;
+	else
+		vardst->data = varsrc->data;
+	return 0;
+}
+
+int hdl4se_module_AssignVar(sGeneralModule* pobj, int dstind, ModuleVariable* varsrc)
+{
+	ModuleVariable* vardst;
+	if (dstind < 0 || dstind >= pobj->variables.itemcount)
+		return -1;
+	vardst = (ModuleVariable*)pobj->variables.array[dstind];
+	if (vardst->type == VTYPE_REG)
+		vardst->data_reg = varsrc->data;
+	else
+		vardst->data = varsrc->data;
+	return 0;
+}
+
+int hdl4se_module_AssignStr(sGeneralModule* pobj, int dstind, const char* src)
+{
+	ModuleVariable* vardst;
+	if (dstind < 0 || dstind >= pobj->variables.itemcount)
+		return -1;
+	vardst = (ModuleVariable*)pobj->variables.array[dstind];
+	/*
+	if (vardst->type == VTYPE_REG)
+		objectCall3(vardst->data_reg, AssignStr, src, NULL, 0);
+	else
+		objectCall3(vardst->data, AssignStr, src, NULL, 0);
+    */
+	return 0;
+}
+
+unsigned int hdl4se_module_GetVarUint32(sGeneralModule* pobj, int varindex)
+{
+	unsigned int v;
+	ModuleVariable* var;
+	var = (ModuleVariable*)pobj->variables.array[varindex];
+	UpdateVariable(var);
+	v = var->uint32;
+	return v;
+}
+
+int hdl4se_module_GetVarInt32(sGeneralModule* pobj, int varindex)
+{
+	ModuleVariable* var;
+	var = (ModuleVariable*)pobj->variables.array[varindex];
+	UpdateVariable(var);
+	return var->int32;
+}
+
+unsigned long long hdl4se_module_GetVarUint64(sGeneralModule* pobj, int varindex)
+{
+	ModuleVariable* var;
+	var = (ModuleVariable*)pobj->variables.array[varindex];
+	UpdateVariable(var);
+	return var->uint64;
+}
 
+long long hdl4se_module_GetVarInt64(sGeneralModule* pobj, int varindex)
+{
+	ModuleVariable* var;
+	var = (ModuleVariable*)pobj->variables.array[varindex];
+	UpdateVariable(var);
+	return var->int64;
+}
+
+void hdl4se_module_SetVarUint32(sGeneralModule* pobj, int varindex, unsigned int v)
+{
+	ModuleVariable* var = (ModuleVariable*)pobj->variables.array[varindex];
+	if (var->type == VTYPE_REG)
+		var->data_reg = v;
+	else
+		var->data = v;
+}
+
+void hdl4se_module_SetVarInt32(sGeneralModule* pobj, int varindex, int v)
+{
+	ModuleVariable* var = (ModuleVariable*)pobj->variables.array[varindex];
+	if (var->type == VTYPE_REG)
+		var->int64_reg = v;
+	else
+		var->int64 = v;
+}
+
+void hdl4se_module_SetVarUint64(sGeneralModule* pobj, int varindex, unsigned long long v)
+{
+	ModuleVariable* var = (ModuleVariable*)pobj->variables.array[varindex];
+	if (var->type == VTYPE_REG)
+		var->data_reg = v;
+	else
+		var->data = v;
+}
+
+void hdl4se_module_SetVarInt64(sGeneralModule* pobj, int varindex, long long v)
+{
+	ModuleVariable* var = (ModuleVariable*)pobj->variables.array[varindex];
+	if (var->type == VTYPE_REG)
+		var->int64_reg = v;
+	else
+		var->int64 = v;
+}
+#endif
 int hdl4se_module_AddVariable(sGeneralModule* pobj, int type, int width, int portdirect, int isunsigned, const char* name)
 {
 	ModuleVariable* var;
@@ -480,18 +597,31 @@ int hdl4se_module_ConnectInput(sGeneralModule* pobj, int index, HOBJECT from, in
 	return 0;
 }
 
-inline int hdl4se_module_GetValue(sGeneralModule* pobj, int index, int width, IBigNumber** value)
+inline int hdl4se_module_GetValue(sGeneralModule* pobj, int index, int width, ModuleVariable * value)
 {
 	ModuleVariable* var;
 	if (index < 0 || index >= pobj->variables.itemcount)
 		return -1;
 	var = (ModuleVariable*)pobj->variables.array[index];
 	UpdateVariable(var);
+#if USEBIGINT
 	if (width <= 0) {
 		objectCall1(value, SetUnsigned, var->isunsigned);
 		objectCall1(value, SetWidth, var->width);
 	}
 	objectCall1(value, Assign, var->data);
+#else
+	if (width <= 0) {
+		value->isunsigned = var->isunsigned;
+		value->width = var->width;
+	}
+	if (value->type == VTYPE_REG) {
+		value->data_reg = var->data;
+	}
+	else {
+		value->data = var->data;
+	}
+#endif
 	return 0;
 }
 
@@ -526,7 +656,11 @@ int hdl4se_module_Setup(sGeneralModule* pobj)
 		if (var == NULL)
 			continue;
 		if (var->type == VTYPE_REG) {
+#if USEBIGINT
 			objectCall1(var->data, Clone, var->data_reg);
+#else
+			var->data = var->data_reg;
+#endif
 			//var->func_UpdateVariable = hdl4seUpdateVariableNone;
 			var->updatefunc = 0;
 

hdl4secell/src/hdl4se_variable.c

@@ -69,15 +69,16 @@ ModuleVariable* variableCreate(int type, int width, int portdirect, int isunsign
 	var->genfuncindex = -1;
 	var->module = NULL;
 	var->moduleportindex = 0;
-	var->data = NULL;
+	var->data = 0;
 	pointerarrayInit(&var->functions);
-	var->data_reg = NULL;
+	var->data_reg = 0;
+#if USEBIGINT
 	{
 		var->data = bigintegerCreate2(width, isunsigned);
 		if (type == VTYPE_REG)
 			var->data_reg = bigintegerCreate2(width, isunsigned);
 	}
-	//var->func_UpdateVariable = hdl4seUpdateVariableNone;
+#endif
 	var->updatefunc = 0;
 	var->lock = threadlockCreate();
 	return var;
@@ -91,9 +92,11 @@ int variableDestroy(ModuleVariable* var)
 		mt_free(var->name);
 	threadlockRelease(var->lock);
 	objectRelease(var->module);
+#if USEBIGINT
 	objectRelease(var->data);
 	objectRelease(var->data_reg);
-	var->data = NULL;
+#endif
+	var->data = 0;
 	mt_free(var);
 	return 0;
 }
@@ -168,6 +171,7 @@ ModuleVariable* varTemp(int width, int isunsigned)
 	return temp;
 }
 
+#if USEBIGINT
 ModuleVariable* varConstStr(const char* str)
 {
 	ModuleVariable* temp = varTemp(0, 0);
@@ -309,3 +313,160 @@ unsigned int varGet_U32(ModuleVariable* a);
 long long varGet_S64(ModuleVariable* a);
 unsigned long long varGet_U64(ModuleVariable* a);
 
+#else
+ModuleVariable* varConstStr(const char* str)
+{
+	ModuleVariable* temp = varTemp(0, 0);
+	/*
+	objectCall3(temp->data, AssignStr, str, NULL, 1);
+	temp->width = objectCall0(temp->data, GetWidth);
+	temp->isunsigned = objectCall0(temp->data, IsUnsigned);
+	*/
+	return temp;
+}
+
+ModuleVariable* varConst(int width, unsigned long long v)
+{
+	ModuleVariable* temp = varTemp(width, 1);
+	temp->uint64 = v;
+	return temp;
+}
+
+ModuleVariable* varConstSigned(int width, long long v)
+{
+	ModuleVariable* temp = varTemp(width, 0);
+	temp->int64 = v;
+	return temp;
+}
+
+ModuleVariable* varConcat(int multicount, ...)
+{
+	va_list argptr;
+	int i;
+	int width = 0;
+	ModuleVariable* temp = varTemp(64, 1);
+	va_start(argptr, multicount);
+	do {
+		int itemwidth;
+		ModuleVariable* item = va_arg(argptr, ModuleVariable*);
+		if (item == NULL)
+			break;
+		width += itemwidth = item->width;
+		temp->data <<= itemwidth;
+		temp->data |= item->data & (0xffffffffffffffffllu >> (64 - itemwidth));
+	} while (1);
+	va_end(argptr);
+	temp->width = width;
+	temp->isunsigned = 1;
+	if (multicount > 1) {
+		ModuleVariable* temp1 = temp;
+		temp = varTemp(multicount * width, 1);
+		for (i = 0; i < multicount; i++) {
+			temp->data <<= width;
+			temp->data |= temp1->data;
+		}
+	}
+	return temp;
+}
+
+ModuleVariable* varAdd(ModuleVariable* a, ModuleVariable* b)
+{
+	ModuleVariable* temp;
+	temp = varTemp(max(a->width, b->width), a->isunsigned || b->isunsigned);
+	temp->data = a->data + b->data;
+	return temp;
+}
+
+ModuleVariable* varSub(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varMul(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varDiv(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varMod(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varPow(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varSHL(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varSHR(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varSAL(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varSAR(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varOr(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varXor(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varAnd(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varGT(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varGE(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varLT(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varLE(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varEQ(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varNE(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varAndL(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varOrL(ModuleVariable* a, ModuleVariable* b);
+ModuleVariable* varNeg(ModuleVariable* a);
+ModuleVariable* varNot(ModuleVariable* a);
+ModuleVariable* varNotL(ModuleVariable* a);
+ModuleVariable* varUAnd(ModuleVariable* a);
+ModuleVariable* varUNAnd(ModuleVariable* a);
+ModuleVariable* varUOr(ModuleVariable* a);
+ModuleVariable* varUNOr(ModuleVariable* a);
+ModuleVariable* varUXor(ModuleVariable* a);
+ModuleVariable* varUNXor(ModuleVariable* a);
+
+ModuleVariable* varBit(ModuleVariable* a, int bit)
+{
+	ModuleVariable* temp;
+	temp = varTemp(1, 1);
+	temp->data = (a->data & (1llu << bit)) ? 1 : 0;
+	return temp;
+}
+
+ModuleVariable* varBits(ModuleVariable* a, int from, int width)
+{
+	ModuleVariable* temp;
+	temp = varTemp(width, 1);
+	temp->data = (a->data >> from) & (0xffffffffffffffffllu >> (64 - width));
+	return temp;
+}
+
+ModuleVariable* varSelect(ModuleVariable* a, ModuleVariable* b, ModuleVariable* c)
+{
+	if (a->data)
+		return b;
+	else
+		return c;
+}
+
+int varAssign(ModuleVariable* a, ModuleVariable* b);
+int varIsZero(ModuleVariable* a);
+int varIsNotZero(ModuleVariable* a);
+
+int varSetBits32(ModuleVariable* a, int index, unsigned int v)
+{
+	if (a->type == VTYPE_REG) {
+		if (index == 0)
+			a->uint32_reg = v;
+		else
+			a->data_reg = (a->data_reg & 0xffffffff) | (((unsigned long long)v) << 32);
+	}
+	else {
+		if (index == 0)
+			a->uint32 = v;
+		else
+			a->data = (a->data & 0xffffffff) | (((unsigned long long)v) << 32);
+	}
+	return 0;
+}
+unsigned int varGetBits32(ModuleVariable* a, int index)
+{
+	unsigned int v;
+	if (index == 0)
+		v = a->uint32;
+	else
+		v = (unsigned int)(a->data >> 32);
+	return v;
+}
+
+int varAssign_S32(ModuleVariable* a, int v);
+int varAssign_U32(ModuleVariable* a, unsigned int v);
+int varAssign_S64(ModuleVariable* a, long long v);
+int varAssign_U64(ModuleVariable* a, unsigned long long v);
+int varGet_S32(ModuleVariable* a);
+unsigned int varGet_U32(ModuleVariable* a);
+long long varGet_S64(ModuleVariable* a);
+unsigned long long varGet_U64(ModuleVariable* a);
+#endif
\ No newline at end of file

hdl4sesim/src/hdl4sesim.c

@@ -231,7 +231,7 @@ static int hdl4sesim_hdl4se_simulator_SetReset(HOBJECT object, int reset)
 	return 0;
 }
 
-#define THREADCOUNT 9
+#define THREADCOUNT 10
 
 static int hdl4sesim_hdl4se_simulator_ClkTick(HOBJECT object)
 {