int FliVariableObjHdl::initialise(std::string &name) { /* Pre allocte buffers on signal type basis */ m_fli_type = mti_GetTypeKind(mti_GetVarType(m_fli_hdl)); switch (m_fli_type) { case MTI_TYPE_ENUM: m_val_len = 1; break; case MTI_TYPE_SCALAR: case MTI_TYPE_PHYSICAL: m_val_len = 32; break; case MTI_TYPE_ARRAY: m_val_len = mti_TickLength(mti_GetVarType(m_fli_hdl)); m_mti_buff = (mtiInt32T*)malloc(sizeof(*m_mti_buff) * m_val_len); if (!m_mti_buff) { LOG_CRITICAL("Unable to alloc mem for signal mti read buffer: ABORTING"); } break; default: LOG_ERROR("Unable to handle object type for %s (%d)", name.c_str(), m_fli_type); } m_val_buff = (char*)malloc(m_val_len+1); if (!m_val_buff) { LOG_CRITICAL("Unable to alloc mem for signal read buffer: ABORTING"); } m_val_buff[m_val_len] = '\0'; GpiObjHdl::initialise(name); return 0; }
/* This function is called by the simulator to initialize the * tester module. It makes a data structure of the tester's ports * (taken from the entity's port list) and creates a process which * will handle all the signal changes. */ void tester_init( mtiRegionIdT region, char *param, mtiInterfaceListT *generics, mtiInterfaceListT *ports ) { inst_rec_ptr ip; mtiInterfaceListT *p; int is_array_type; ip = (inst_rec_ptr)mti_Malloc(sizeof(inst_rec)); mti_AddRestartCB( mti_Free, ip ); /* Traverse the list of ports and get port names and widths. */ num_ports = 0; for ( p = ports; p; p = p->nxt ) { tester_ports[num_ports].name = p->name; is_array_type = (mti_GetTypeKind(p->type) == MTI_TYPE_ARRAY); tester_ports[num_ports].is_array_type = is_array_type; if ( is_array_type ) { tester_ports[num_ports].width = mti_TickLength(p->type); } else { tester_ports[num_ports].width = 1; } ip->ports[ num_ports] = p->u.port; ip->drivers[ num_ports] = mti_CreateDriver(p->u.port); tester_ports[num_ports].number = num_ports; num_ports++; } ip->test_values = mti_CreateProcess("test", test_value_proc, ip); /* Check for an optional parameter on the FOREIGN attribute that * indicates whether or not to display debug messages. */ if ( param && (strcmp(param, "verbose") == 0) ) { ip->verbose = 1; } else { ip->verbose = 0; } /* Open the vector file and process the first test/drive statement. */ if ( open_vector_file(ip) ) { read_next_statement(ip); } }
GpiObjHdl *FliImpl::create_gpi_obj_from_handle(void *hdl, std::string &name, std::string &fq_name, int accType, int accFullType) { GpiObjHdl *new_obj = NULL; LOG_DEBUG("Attepmting to create GPI object from handle (Type=%d, FullType=%d).", accType, accFullType); if (!VS_TYPE_IS_VHDL(accFullType)) { LOG_DEBUG("Handle is not a VHDL type."); return NULL; } if (!isTypeValue(accType)) { /* Need a Pseudo-region to handle generate loops in a consistent manner across interfaces * and across the different methods of accessing data. */ std::string rgn_name = mti_GetRegionName(static_cast<mtiRegionIdT>(hdl)); if (name != rgn_name) { LOG_DEBUG("Found pseudo-region %s -> %p", fq_name.c_str(), hdl); new_obj = new FliObjHdl(this, hdl, GPI_GENARRAY, accType, accFullType); } else { LOG_DEBUG("Found region %s -> %p", fq_name.c_str(), hdl); new_obj = new FliObjHdl(this, hdl, GPI_MODULE, accType, accFullType); } } else { bool is_var; bool is_const; mtiTypeIdT valType; mtiTypeKindT typeKind; if (isTypeSignal(accType, accFullType)) { LOG_DEBUG("Found a signal %s -> %p", fq_name.c_str(), hdl); is_var = false; is_const = false; valType = mti_GetSignalType(static_cast<mtiSignalIdT>(hdl)); } else { LOG_DEBUG("Found a variable %s -> %p", fq_name.c_str(), hdl); is_var = true; is_const = isValueConst(accFullType); valType = mti_GetVarType(static_cast<mtiVariableIdT>(hdl)); } typeKind = mti_GetTypeKind(valType); switch (typeKind) { case MTI_TYPE_ENUM: if (isValueLogic(valType)) { new_obj = new FliLogicObjHdl(this, hdl, GPI_REGISTER, is_const, accType, accFullType, is_var, valType, typeKind); } else if (isValueBoolean(valType) || isValueChar(valType)) { new_obj = new FliIntObjHdl(this, hdl, GPI_INTEGER, is_const, accType, accFullType, is_var, valType, typeKind); } else { new_obj = new FliEnumObjHdl(this, hdl, GPI_ENUM, is_const, accType, accFullType, is_var, valType, typeKind); } break; case MTI_TYPE_SCALAR: case MTI_TYPE_PHYSICAL: new_obj = new FliIntObjHdl(this, hdl, GPI_INTEGER, is_const, accType, accFullType, is_var, valType, typeKind); break; case MTI_TYPE_REAL: new_obj = new FliRealObjHdl(this, hdl, GPI_REAL, is_const, accType, accFullType, is_var, valType, typeKind); break; case MTI_TYPE_ARRAY: { mtiTypeIdT elemType = mti_GetArrayElementType(valType); mtiTypeKindT elemTypeKind = mti_GetTypeKind(elemType); switch (elemTypeKind) { case MTI_TYPE_ENUM: if (isValueLogic(elemType)) { new_obj = new FliLogicObjHdl(this, hdl, GPI_REGISTER, is_const, accType, accFullType, is_var, valType, typeKind); // std_logic_vector } else if (isValueChar(elemType)) { new_obj = new FliStringObjHdl(this, hdl, GPI_STRING, is_const, accType, accFullType, is_var, valType, typeKind); } else { new_obj = new FliValueObjHdl(this, hdl, GPI_ARRAY, false, accType, accFullType, is_var, valType, typeKind); // array of enums } break; default: new_obj = new FliValueObjHdl(this, hdl, GPI_ARRAY, false, accType, accFullType, is_var, valType, typeKind);// array of (array, Integer, Real, Record, etc.) } } break; case MTI_TYPE_RECORD: new_obj = new FliValueObjHdl(this, hdl, GPI_STRUCTURE, false, accType, accFullType, is_var, valType, typeKind); break; default: LOG_ERROR("Unable to handle object type for %s (%d)", name.c_str(), typeKind); return NULL; } } if (NULL == new_obj) { LOG_DEBUG("Didn't find anything named %s", fq_name.c_str()); return NULL; } if (new_obj->initialise(name,fq_name) < 0) { LOG_ERROR("Failed to initialise the handle %s", name.c_str()); delete new_obj; return NULL; } return new_obj; }