void FPGA_device::load_devices(const target_deviceRef device)
{
///map between the default device string and the corresponding configuration stream
std::map<std::string, std::string> default_device_data;
/// Load default device options
default_device_data["xc4vlx100-10ff1513"] =
#include "xc4vlx100-10ff1513.data"
;
default_device_data["xc5vlx50-3ff1153"] =
#include "xc5vlx50-3ff1153.data"
;
default_device_data["xc5vlx110t-1ff1136"] =
#include "xc5vlx110t-1ff1136.data"
;
default_device_data["xc5vlx330t-2ff1738"] =
#include "xc5vlx330t-2ff1738.data"
;
default_device_data["xc6vlx240t-1ff1156"] =
#include "xc6vlx240t-1ff1156.data"
;
default_device_data["xc7z020-1clg484"] =
#include "xc7z020-1clg484.data"
;
default_device_data["xc7z020-1clg484-VVD"] =
#include "xc7z020-1clg484-VVD.data"
;
default_device_data["xc7z020-1clg484-YOSYS-VVD"] =
#include "xc7z020-1clg484-YOSYS-VVD.data"
;
default_device_data["xc7vx485t-2ffg1761-VVD"] =
#include "xc7vx485t-2ffg1761-VVD.data"
;
default_device_data["xc7vx690t-3ffg1930-VVD"] =
#include "xc7vx690t-3ffg1930-VVD.data"
;
default_device_data["xc7vx330t-1ffg1157"] =
#include "xc7vx330t-1ffg1157.data"
;
default_device_data["xc7a100t-1csg324-VVD"] =
#include "xc7a100t-1csg324-VVD.data"
;
#if (0 && HAVE_EXPERIMENTAL)
default_device_data["xc3s1500l-4fg676"] =
#include "Spartan-3-xc3s1500l-4fg676.data"
;
#endif
default_device_data["EP2C70F896C6"] =
#include "EP2C70F896C6.data"
;
default_device_data["EP2C70F896C6-R"] =
#include "EP2C70F896C6-R.data"
;
default_device_data["5CSEMA5F31C6"] =
#include "5CSEMA5F31C6.data"
;
default_device_data["EP4SGX530KH40C2"] =
#include "EP4SGX530KH40C2.data"
;
default_device_data["5SGXEA7N2F45C1"] =
#include "5SGXEA7N2F45C1.data"
;
default_device_data["LFE335EA8FN484C"] =
#include "LFE335EA8FN484C.data"
;
unsigned int output_level = Param->getOption<unsigned int>(OPT_output_level);
try
{
PRINT_OUT_MEX(OUTPUT_LEVEL_VERBOSE, output_level, "Available devices:");
for (std::map<std::string, std::string>::const_iterator d = default_device_data.begin(); d != default_device_data.end(); d++)
{
PRINT_OUT_MEX(OUTPUT_LEVEL_VERBOSE, output_level, " - " + d->first);
}
const CustomSet<XMLDomParserRef> parsers = [&] () -> CustomSet<XMLDomParserRef>
{
CustomSet<XMLDomParserRef> ret;
if (Param->isOption(OPT_target_device_file))
{
const auto file_devices = Param->getOption<const std::list<std::string> >(OPT_target_device_file);
for(const auto file_device : file_devices)
{
PRINT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "Imported user data from file " + file_device);
ret.insert(XMLDomParserRef(new XMLDomParser(file_device)));
}
}
else
{
std::string device_string = Param->getOption<std::string>(OPT_device_string);
if (default_device_data.find(device_string) != default_device_data.end())
{
INDENT_DBG_MEX(DEBUG_LEVEL_VERY_PEDANTIC, debug_level, "---Loading " + device_string);
ret.insert(XMLDomParserRef(new XMLDomParser(device_string, default_device_data[device_string])));
}
else
THROW_ERROR("Target device not supported: " + device_string);
}
return ret;
}();
for(const auto parser : parsers)
{
parser->Exec();
if (parser and *parser)
{
const xml_element* node = parser->get_document()->get_root_node(); //deleted by DomParser.
xload(device, node);
}
}
return;
}
catch (const char * msg)
{
std::cerr << msg << std::endl;
}
catch (const std::string & msg)
{
std::cerr << msg << std::endl;
}
catch (const std::exception& ex)
{
std::cout << "Exception caught: " << ex.what() << std::endl;
}
catch ( ... )
{
std::cerr << "unknown exception" << std::endl;
}
THROW_ERROR("Error during XML parsing of device files");
}
void BytecodeAssembler::aload(u4 index) {
xload(index, Bytecodes::_aload_0, Bytecodes::_aload);
}
void IC_device::load_devices(const target_deviceRef device)
{
/// Load default resources
const char * builtin_technology = {
#include "Nangate.data"
};
int output_level = Param->getOption<int>(OPT_output_level);
///creating the datastructure representing the target technology
target = target_technology::create_technology(target_technology::CMOS, Param);
try
{
XMLDomParser parser("builtin_technology", builtin_technology);
parser.Exec();
if (parser)
{
//Walk the tree:
const xml_element* node = parser.get_document()->get_root_node(); //deleted by DomParser.
xload(device, node);
}
///update with specified device information
if (Param->isOption(OPT_target_device_file))
{
const auto file_name = Param->getOption<std::string>(OPT_target_device_file);
if (!boost::filesystem::exists(file_name))
{
THROW_ERROR("Device information file " + file_name + " does not exist!");
}
PRINT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "(target device) Loading information about the target device from file \"" + file_name + "\"");
XMLDomParser parser1(file_name);
parser1.Exec();
if (parser1)
{
//Walk the tree:
const xml_element* node = parser1.get_document()->get_root_node(); //deleted by DomParser.
xload(device, node);
}
}
}
catch (const char * msg)
{
std::cerr << msg << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
catch (const std::string & msg)
{
std::cerr << msg << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
catch (const std::exception& ex)
{
std::cout << "Exception caught: " << ex.what() << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
catch ( ... )
{
std::cerr << "unknown exception" << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
}
