static void printBinaryOp(int location, Vector<Instruction>::const_iterator& it, const char* op)
{
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int r2 = (++it)->u.operand;
printf("[%4d] %s\t\t %s, %s, %s\n", location, op, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
}
int ExternalEdge::setRecvCoords(char* subgraph, char* vert, char* exchange)
{
registerName(subgraph, &recv_subgraph_id);
registerName(vert, &recv_vertex_id);
registerName(exchange, &recv_exchange_block_id);
return 0;
}
void CodeWriter::writePop(string segment, int index)
{
string indexStr = to_string(index);
string registerStr = registerName(segment, index);
// pop static, temp or pointer
if (segment == "static" || segment == "temp" || segment == "pointer") {
write("@SP // pop " + segment + " " + indexStr);
write("AM=M-1");
write("D=M");
write("@" + registerStr);
write("M=D");
} else { // all other segments
write("@" + registerStr + " // pop " + segment + " " + indexStr);
write("D=M");
write("@" + indexStr);
write("D=D+A");
write("@R13");
write("M=D");
write("@SP");
write("AM=M-1");
write("D=M");
write("@R13");
write("A=M");
write("M=D");
}
}
void
TR::RegDepCopyRemoval::selectNodesToReuse(TR::NodeChecklist &usedNodes)
{
for (TR_GlobalRegisterNumber reg = _regBegin; reg < _regEnd; reg++)
{
RegDepInfo &dep = getRegDepInfo(reg);
if (dep.state != REGDEP_UNDECIDED)
continue;
NodeChoice &prevChoice = getNodeChoice(reg);
if (dep.value != prevChoice.original)
continue; // can't reuse
// Reuse our previous choice!
if (trace())
traceMsg(comp(), "\t%s: prefer to reuse previous choice n%un\n", registerName(reg), prevChoice.selected->getGlobalIndex());
TR_ASSERT(!usedNodes.contains(prevChoice.selected), "attempted to reuse the same node more than once\n");
if (prevChoice.selected == dep.value)
{
dep.state = REGDEP_NODE_ORIGINAL;
usedNodes.add(dep.value);
}
else
{
dep.state = REGDEP_NODE_REUSE_COPY;
}
}
}
void NameManager::registerLuaKeywords()
{
for (unsigned int i = 0; luaKeywords[i]; i++)
{
registerName(luaKeywords[i]);
}
}
void GameState::serverLoop(bool generateMap, size_t player, std::string username) {
readyClients = 1;
totalClients = stillConnected = player;
if (generateMap)
map = generator->generate(32, 25, 2);
else
readMapFromFile();
mapData = map->printTiles();
auto pos = findFreePosition();
compressedMap = "";
for (int i = 0; i < map->getHeight(); i++)
{
std::string line = "";
for (int j = 0; j < map->getWidth(); j++)
{
line += std::to_string( (unsigned int)mapData[i][j] );
}
compressedMap += line;
}
nameList = new std::set<std::string>();
endpoint = new ip::tcp::endpoint(ip::tcp::v4(), GameState::tcpPort);
acceptor = new ip::tcp::acceptor(service, *endpoint);
socket = new ip::tcp::socket(service);
sessions = new std::vector<std::shared_ptr<ServerSession>>();
entities = new std::vector<std::shared_ptr<Entity>>();
entities->resize(player*3);
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
character = std::make_shared<Entity>(position.x, position.y, this, true, 0);
(*entities)[0] = character;
}
for (auto i = player; i < player * 3; i++)
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
(*entities)[i] = std::make_shared<Entity>(position.x, position.y, this, false, i);
}
sessions->push_back(nullptr);
registerName(username);
vacantPlayers = player - 1;
if (vacantPlayers == 0)
inGame = true;
accept();
service.run();
std::cout << "Finished server thread" << std::endl;
}
void
TR::RegDepCopyRemoval::makeFreshCopy(TR_GlobalRegisterNumber reg)
{
RegDepInfo &dep = getRegDepInfo(reg);
if (!performTransformation(comp(),
"%schange %s in GlRegDeps n%un to an explicit copy of n%un\n",
optDetailString(),
registerName(reg),
_regDeps->getGlobalIndex(),
dep.value->getGlobalIndex()))
return;
// Split the block at fallthrough if necessary to avoid putting copies
// between branches and BBEnd.
TR::Node *curNode = _treetop->getNode();
if (curNode->getOpCodeValue() == TR::BBEnd)
{
TR::Block *curBlock = curNode->getBlock();
if (curBlock->getLastRealTreeTop() != curBlock->getLastNonControlFlowTreeTop())
{
TR::Block *fallthrough = curBlock->getNextBlock();
fallthrough = curBlock->splitEdge(curBlock, fallthrough, comp());
TR_ASSERT(curBlock->getNextBlock() == fallthrough, "bad block placement from splitEdge\n");
fallthrough->setIsExtensionOfPreviousBlock();
_treetop = fallthrough->getExit();
TR::Node *newNode = _treetop->getNode();
newNode->setChild(0, _regDeps);
newNode->setNumChildren(1);
curNode->setNumChildren(0);
if (trace())
traceMsg(comp(), "\tsplit fallthrough edge to insert copy, created block_%d\n", fallthrough->getNumber());
}
}
// Make and insert the copy
TR::Node *copyNode = NULL;
if (dep.value->getOpCode().isLoadConst())
{
// No need to depend on the other register.
// TODO heuristic for whether this is really better than a reg-reg move?
generateRegcopyDebugCounter("const-remat");
copyNode = TR::Node::create(dep.value->getOpCodeValue(), 0);
copyNode->setConstValue(dep.value->getConstValue());
}
else
{
generateRegcopyDebugCounter("fresh-copy");
copyNode = TR::Node::create(TR::PassThrough, 1, dep.value);
copyNode->setCopyToNewVirtualRegister();
}
TR::Node *copyTreetopNode = TR::Node::create(TR::treetop, 1, copyNode);
_treetop->insertBefore(TR::TreeTop::create(comp(), copyTreetopNode));
if (trace())
traceMsg(comp(), "\tcopy is n%un\n", copyNode->getGlobalIndex());
updateSingleRegDep(reg, copyNode);
}
void
AssemblyFactoryImpl::initialize()
{
try
{
CORBA::Object_var root_poa_obj = orb_->resolve_initial_references ("RootPOA");
root_poa_ = PortableServer::POA::_narrow (root_poa_obj);
}
catch (CORBA::ORB::InvalidName&)
{
NORMAL_ERR( "AssemblyFactoryImpl: no root POA available" );
throw CannotInitialize();
}
catch (CORBA::SystemException&)
{
NORMAL_ERR( "AssemblyFactoryImpl: cannot narrow root POA" );
throw CannotInitialize();
}
root_poa_manager_ = root_poa_->the_POAManager();
root_poa_manager_->activate();
// get NameService
if (! initNameService(orb_))
{
throw CannotInitialize();
}
// bind AssemblyFactory
CORBA::Object_var assemblyFactory_ref = this->_this();
std::string name = "Qedo/AssemblyFactory/";
char hostname[256];
gethostname(hostname, 256);
name.append(hostname);
if ( ! registerName(name, assemblyFactory_ref, true))
{
throw CannotInitialize();
}
DEBUG_OUT2( "AssemblyFactoryImpl: bound under ", name );;
//
// directory to put the packages
//
if (makeDir(packageDirectory_))
{
NORMAL_ERR3( "AssemblyFactoryImpl: directory ", packageDirectory_, " can not be created");
throw CannotInitialize();
}
}
void GameState::serverLoop(bool generateMap, size_t player, std::string username) {
yourID = 0;
readyClients = 1;
totalClients = stillConnected = player;
if (generateMap)
map = generator->generate(32, 25, 2);
else
readMapFromFile();
mapData = map->printTiles();
auto pos = findFreePosition();
compressMap();
nameList = new std::set<std::string>();
endpoint = new ip::tcp::endpoint(ip::tcp::v4(), GameState::tcpPort);
acceptor = new ip::tcp::acceptor(service, *endpoint);
socket = new ip::tcp::socket(service);
sessions = new std::vector<std::shared_ptr<ServerSession>>();
entities = new std::vector<std::shared_ptr<Entity>>();
entities->resize( Universal::ENTITY_COUNT );
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
character = std::make_shared<Entity>(position.x, position.y, this, true, 0);
(*entities)[0] = character;
}
for (auto i = player; i < Universal::ENTITY_COUNT; i++)
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
(*entities)[i] = std::make_shared<Entity>(position.x, position.y, this, false, i);
}
sessions->push_back(nullptr);
registerName(username);
vacantPlayers = player - 1;
if (vacantPlayers == 0)
inGame = true;
accept();
service.run();
}
void
TR::RegDepCopyRemoval::selectNodesToCopy(TR::NodeChecklist &usedNodes)
{
for (TR_GlobalRegisterNumber reg = _regBegin; reg < _regEnd; reg++)
{
RegDepInfo &dep = getRegDepInfo(reg);
if (dep.state != REGDEP_UNDECIDED)
continue;
if (!usedNodes.contains(dep.value))
{
dep.state = REGDEP_NODE_ORIGINAL;
usedNodes.add(dep.value);
if (trace())
traceMsg(comp(), "\t%s: prefer to keep the original node n%un\n", registerName(reg), dep.value->getGlobalIndex());
}
else
{
dep.state = REGDEP_NODE_FRESH_COPY;
if (trace())
traceMsg(comp(), "\t%s: prefer to make a new copy of n%un\n", registerName(reg), dep.value->getGlobalIndex());
}
}
}
void
TR::RegDepCopyRemoval::readRegDeps()
{
for (int i = 0; i < _regDeps->getNumChildren(); i++)
{
TR::Node *depNode = _regDeps->getChild(i);
TR::Node *depValue = depNode;
if (depValue->getOpCodeValue() == TR::PassThrough)
{
do
depValue = depValue->getFirstChild();
while (depValue->getOpCodeValue() == TR::PassThrough);
}
else
{
TR_ASSERT(depNode->getOpCode().isLoadReg(), "invalid GlRegDeps child opcode n%un %s\n", depNode->getGlobalIndex(), depNode->getOpCode().getName());
}
// Avoid register pairs for simplicity, at least for now
bool isRegPairDep = depNode->getHighGlobalRegisterNumber() != (TR_GlobalRegisterNumber)-1;
bool valueNeedsRegPair = comp()->nodeNeeds2Regs(depValue);
TR_ASSERT(isRegPairDep == valueNeedsRegPair, "mismatch on number of registers required for n%un\n", depNode->getGlobalIndex());
if (isRegPairDep)
{
ignoreRegister(depNode->getLowGlobalRegisterNumber());
ignoreRegister(depNode->getHighGlobalRegisterNumber());
continue;
}
// Only process integral and address-type nodes; they'll go into GPRs
TR_GlobalRegisterNumber reg = depNode->getGlobalRegisterNumber();
TR::DataType depType = depValue->getType();
if (!depType.isIntegral() && !depType.isAddress())
{
ignoreRegister(reg);
continue;
}
RegDepInfo &dep = getRegDepInfo(reg);
TR_ASSERT(dep.state == REGDEP_ABSENT, "register %s is multiply-specified\n", registerName(reg));
dep.node = depNode;
dep.value = depValue;
dep.state = REGDEP_UNDECIDED;
dep.childIndex = i;
}
}
std::string ElementNameHelper::resolveName(const std::string& type, const std::string& name)
{
std::string resolvedName;
if(name.empty())
{
std::string radix = core::ObjectFactory::ShortName(type);
registerName(radix);
std::ostringstream oss;
oss << radix << instanceCounter[radix];
resolvedName = oss.str();
}
else
{
resolvedName = name;
}
return resolvedName;
}
void
TR::RegDepCopyRemoval::reuseCopy(TR_GlobalRegisterNumber reg)
{
RegDepInfo &dep = getRegDepInfo(reg);
NodeChoice &prevChoice = getNodeChoice(reg);
TR_ASSERT(prevChoice.original == dep.value, "previous copy for %s doesn't match original\n", registerName(reg));
TR_ASSERT(prevChoice.selected != dep.value, "previous copy is the same as original for %s\n", registerName(reg));
if (performTransformation(comp(),
"%schange %s in GlRegDeps n%un to use previous copy n%un of n%un\n",
optDetailString(),
registerName(reg),
_regDeps->getGlobalIndex(),
prevChoice.selected->getGlobalIndex(),
prevChoice.original->getGlobalIndex()))
{
generateRegcopyDebugCounter("reuse-copy");
updateSingleRegDep(reg, prevChoice.selected);
}
}
UInt MetaInfoRegistry::getIndex(const String & name) const
{
UInt rv;
bool found = false;
#pragma omp critical (MetaInfoRegistry)
{
map<String, UInt>::const_iterator it = name_to_index_.find(name);
if (it != name_to_index_.end())
{
rv = it->second;
found = true;
}
}
if (!found)
{
registerName(name, String::EMPTY, String::EMPTY);
rv = getIndex(name);
}
return rv;
}
void CodeWriter::writePush(string segment, int index)
{
string indexStr = to_string(index);
string registerStr = registerName(segment, index);
if (segment == "constant") { // push constant
write("@" + indexStr + " // push " + segment + " " + indexStr);
write("D=A");
write("@SP");
write("A=M");
write("M=D");
write("@SP");
write("M=M+1");
} else if (segment == "static" || segment == "temp" || segment == "pointer") { // push static or temp
write("@" + registerStr + " // push " + segment + " " + indexStr);
write("D=M");
write("@SP");
write("A=M");
write("M=D");
write("@SP");
write("M=M+1");
} else { // all other segments
write("@" + registerStr + " // push " + segment + " " + indexStr);
write("D=M");
write("@" + indexStr);
write("A=D+A");
write("D=M");
write("@SP");
write("A=M");
write("M=D");
write("@SP");
write("M=M+1");
}
}
void
TR::RegDepCopyRemoval::updateRegDeps(TR::NodeChecklist &usedNodes)
{
for (TR_GlobalRegisterNumber reg = _regBegin; reg < _regEnd; reg++)
{
RegDepInfo &dep = getRegDepInfo(reg);
switch (dep.state)
{
case REGDEP_NODE_ORIGINAL:
rememberNodeChoice(reg, dep.value);
break;
case REGDEP_NODE_REUSE_COPY:
reuseCopy(reg);
break;
case REGDEP_NODE_FRESH_COPY:
makeFreshCopy(reg);
break;
case REGDEP_IGNORED:
discardNodeChoice(reg);
break;
case REGDEP_ABSENT:
{
TR::Node *prevSel = getNodeChoice(reg).selected;
if (prevSel != NULL && usedNodes.contains(prevSel))
discardNodeChoice(reg);
break;
}
case REGDEP_UNDECIDED:
TR_ASSERT(false, "undecided preference for %s survived to updateRegDeps()\n", registerName(reg));
break;
default:
TR_ASSERT(false, "%s has bad RegDepInfo state %d\n", registerName(reg), (int)dep.state);
break;
}
}
}
void
ComponentInstallationImpl::initialize()
{
try
{
CORBA::Object_var root_poa_obj = orb_->resolve_initial_references ("RootPOA");
root_poa_ = PortableServer::POA::_narrow (root_poa_obj);
}
catch (CORBA::ORB::InvalidName&)
{
std::cerr << "ComponentInstallationImpl: Fatal error - no root POA available." << std::endl;
throw CannotInitialize();
}
catch (CORBA::SystemException&)
{
std::cerr << "ComponentInstallationImpl: Fatal error - cannot narrow root POA." << std::endl;
throw CannotInitialize();
}
root_poa_manager_ = root_poa_->the_POAManager();
root_poa_manager_->activate();
// get NameService
if ( !initNameService(orb_))
{
throw CannotInitialize();
}
// bind in NameService
CORBA::Object_var my_ref = this->_this();
std::string name = "Qedo/ComponentInstallation/";
char hostname[256];
if (gethostname (hostname, 256))
{
std::cerr << "ComponentInstallationImpl: Cannot determine my hostname" << std::endl;
throw CannotInitialize();
}
name.append(hostname);
if ( !registerName(name, my_ref, true))
{
throw CannotInitialize();
}
std::cout << "..... bound under " << name << std::endl;
//
// deployment directory
//
if (makeDir(g_qedo_dir + "/deployment"))
{
std::cerr << "deployment directory can not be created" << std::endl;
throw CannotInitialize();
}
//
// directory to put the component packages
//
packageDirectory_ = g_qedo_dir + "/deployment/packages";
if (makeDir(packageDirectory_))
{
std::cerr << "componentPackages directory can not be created" << std::endl;
throw CannotInitialize();
}
//
// directory to put the component implementations
//
installationDirectory_ = g_qedo_dir + "/deployment/components";
if (makeDir(installationDirectory_))
{
std::cerr << "componentImplementations directory can not be created" << std::endl;
throw CannotInitialize();
}
//
// read information about deployed components
//
if ( !readInstalledComponents())
{
throw CannotInitialize();
}
std::cout << "..... number of already installed components: " << installed_components_.size() << std::endl;
std::cout << std::endl;
}
void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it) const
{
int location = it - begin;
switch (exec->machine()->getOpcodeID(it->u.opcode)) {
case op_load: {
int r0 = (++it)->u.operand;
int k0 = (++it)->u.operand;
printf("[%4d] load\t\t %s, %s\t\t\n", location, registerName(r0).c_str(), constantName(exec, k0, jsValues[k0]).c_str());
break;
}
case op_new_object: {
int r0 = (++it)->u.operand;
printf("[%4d] new_object\t %s\n", location, registerName(r0).c_str());
break;
}
case op_new_array: {
int dst = (++it)->u.operand;
int argv = (++it)->u.operand;
int argc = (++it)->u.operand;
printf("[%4d] new_array\t %s, %s, %d\n", location, registerName(dst).c_str(), registerName(argv).c_str(), argc);
break;
}
case op_new_regexp: {
int r0 = (++it)->u.operand;
int re0 = (++it)->u.operand;
printf("[%4d] new_regexp\t %s, %s\n", location, registerName(r0).c_str(), regexpName(re0, regexps[re0].get()).c_str());
break;
}
case op_mov: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
printf("[%4d] mov\t\t %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str());
break;
}
case op_not: {
printUnaryOp(location, it, "not");
break;
}
case op_eq: {
printBinaryOp(location, it, "eq");
break;
}
case op_neq: {
printBinaryOp(location, it, "neq");
break;
}
case op_stricteq: {
printBinaryOp(location, it, "stricteq");
break;
}
case op_nstricteq: {
printBinaryOp(location, it, "nstricteq");
break;
}
case op_less: {
printBinaryOp(location, it, "less");
break;
}
case op_lesseq: {
printBinaryOp(location, it, "lesseq");
break;
}
case op_pre_inc: {
int r0 = (++it)->u.operand;
printf("[%4d] pre_inc\t\t %s\n", location, registerName(r0).c_str());
break;
}
case op_pre_dec: {
int r0 = (++it)->u.operand;
printf("[%4d] pre_dec\t\t %s\n", location, registerName(r0).c_str());
break;
}
case op_post_inc: {
printUnaryOp(location, it, "post_inc");
break;
}
case op_post_dec: {
printUnaryOp(location, it, "post_dec");
break;
}
case op_to_jsnumber: {
printUnaryOp(location, it, "to_jsnumber");
break;
}
case op_negate: {
printUnaryOp(location, it, "negate");
break;
}
case op_add: {
printBinaryOp(location, it, "add");
break;
}
case op_mul: {
printBinaryOp(location, it, "mul");
break;
}
case op_div: {
printBinaryOp(location, it, "div");
break;
}
case op_mod: {
printBinaryOp(location, it, "mod");
break;
}
case op_sub: {
printBinaryOp(location, it, "sub");
break;
}
case op_lshift: {
printBinaryOp(location, it, "lshift");
break;
}
case op_rshift: {
printBinaryOp(location, it, "rshift");
break;
}
case op_urshift: {
printBinaryOp(location, it, "urshift");
break;
}
case op_bitand: {
printBinaryOp(location, it, "bitand");
break;
}
case op_bitxor: {
printBinaryOp(location, it, "bitxor");
break;
}
case op_bitor: {
printBinaryOp(location, it, "bitor");
break;
}
case op_bitnot: {
printUnaryOp(location, it, "bitnot");
break;
}
case op_instanceof: {
printBinaryOp(location, it, "instanceof");
break;
}
case op_typeof: {
printUnaryOp(location, it, "typeof");
break;
}
case op_in: {
printBinaryOp(location, it, "in");
break;
}
case op_resolve: {
int r0 = (++it)->u.operand;
int id0 = (++it)->u.operand;
printf("[%4d] resolve\t\t %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str());
break;
}
case op_resolve_skip: {
int r0 = (++it)->u.operand;
int id0 = (++it)->u.operand;
int skipLevels = (++it)->u.operand;
printf("[%4d] resolve_skip\t %s, %s, %d\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), skipLevels);
break;
}
case op_get_scoped_var: {
int r0 = (++it)->u.operand;
int index = (++it)->u.operand;
int skipLevels = (++it)->u.operand;
printf("[%4d] get_scoped_var\t\t %s, %d, %d\n", location, registerName(r0).c_str(), index, skipLevels);
break;
}
case op_put_scoped_var: {
int index = (++it)->u.operand;
int skipLevels = (++it)->u.operand;
int r0 = (++it)->u.operand;
printf("[%4d] put_scoped_var\t\t %d, %d, %s\n", location, index, skipLevels, registerName(r0).c_str());
break;
}
case op_resolve_base: {
int r0 = (++it)->u.operand;
int id0 = (++it)->u.operand;
printf("[%4d] resolve_base\t %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str());
break;
}
case op_resolve_with_base: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int id0 = (++it)->u.operand;
printf("[%4d] resolve_with_base %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
break;
}
case op_resolve_func: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int id0 = (++it)->u.operand;
printf("[%4d] resolve_func\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
break;
}
case op_get_by_id: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int id0 = (++it)->u.operand;
printf("[%4d] get_by_id\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
break;
}
case op_put_by_id: {
int r0 = (++it)->u.operand;
int id0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
printf("[%4d] put_by_id\t %s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
break;
}
case op_put_getter: {
int r0 = (++it)->u.operand;
int id0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
printf("[%4d] put_getter\t %s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
break;
}
case op_put_setter: {
int r0 = (++it)->u.operand;
int id0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
printf("[%4d] put_setter\t %s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
break;
}
case op_del_by_id: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int id0 = (++it)->u.operand;
printf("[%4d] del_by_id\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
break;
}
case op_get_by_val: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int r2 = (++it)->u.operand;
printf("[%4d] get_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
break;
}
case op_put_by_val: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int r2 = (++it)->u.operand;
printf("[%4d] put_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
break;
}
case op_del_by_val: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int r2 = (++it)->u.operand;
printf("[%4d] del_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
break;
}
case op_put_by_index: {
int r0 = (++it)->u.operand;
unsigned n0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
printf("[%4d] put_by_index\t %s, %u, %s\n", location, registerName(r0).c_str(), n0, registerName(r1).c_str());
break;
}
case op_jmp: {
int offset = (++it)->u.operand;
printf("[%4d] jmp\t\t %d(->%d)\n", location, offset, jumpTarget(begin, it, offset));
break;
}
case op_loop: {
int offset = (++it)->u.operand;
printf("[%4d] loop\t\t %d(->%d)\n", location, offset, jumpTarget(begin, it, offset));
break;
}
case op_jtrue: {
printConditionalJump(begin, it, location, "jtrue");
break;
}
case op_loop_if_true: {
printConditionalJump(begin, it, location, "loop_if_true");
break;
}
case op_jfalse: {
printConditionalJump(begin, it, location, "jfalse");
break;
}
case op_jless: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int offset = (++it)->u.operand;
printf("[%4d] jless\t\t %s, %s, %d(->%d)\n", location, registerName(r0).c_str(), registerName(r1).c_str(), offset, jumpTarget(begin, it, offset));
break;
}
case op_jnless: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int offset = (++it)->u.operand;
printf("[%4d] jnless\t\t %s, %s, %d(->%d)\n", location, registerName(r0).c_str(), registerName(r1).c_str(), offset, jumpTarget(begin, it, offset));
break;
}
case op_loop_if_less: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int offset = (++it)->u.operand;
printf("[%4d] loop_if_less %s, %s, %d(->%d)\n", location, registerName(r0).c_str(), registerName(r1).c_str(), offset, jumpTarget(begin, it, offset));
break;
}
case op_new_func: {
int r0 = (++it)->u.operand;
int f0 = (++it)->u.operand;
printf("[%4d] new_func\t\t %s, f%d\n", location, registerName(r0).c_str(), f0);
break;
}
case op_new_func_exp: {
int r0 = (++it)->u.operand;
int f0 = (++it)->u.operand;
printf("[%4d] new_func_exp\t %s, f%d\n", location, registerName(r0).c_str(), f0);
break;
}
case op_call: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int r2 = (++it)->u.operand;
int tempCount = (++it)->u.operand;
int argCount = (++it)->u.operand;
printf("[%4d] call\t\t %s, %s, %s, %d, %d\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str(), tempCount, argCount);
break;
}
case op_call_eval: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int r2 = (++it)->u.operand;
int tempCount = (++it)->u.operand;
int argCount = (++it)->u.operand;
printf("[%4d] call_eval\t\t %s, %s, %s, %d, %d\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str(), tempCount, argCount);
break;
}
case op_ret: {
int r0 = (++it)->u.operand;
printf("[%4d] ret\t\t %s\n", location, registerName(r0).c_str());
break;
}
case op_construct: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
int tempCount = (++it)->u.operand;
int argCount = (++it)->u.operand;
printf("[%4d] construct\t %s, %s, %d, %d\n", location, registerName(r0).c_str(), registerName(r1).c_str(), tempCount, argCount);
break;
}
case op_get_pnames: {
int r0 = (++it)->u.operand;
int r1 = (++it)->u.operand;
printf("[%4d] get_pnames\t %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str());
break;
}
case op_next_pname: {
int dest = (++it)->u.operand;
int iter = (++it)->u.operand;
int offset = (++it)->u.operand;
printf("[%4d] next_pname\t %s, %s, %d(->%d)\n", location, registerName(dest).c_str(), registerName(iter).c_str(), offset, jumpTarget(begin, it, offset));
break;
}
case op_push_scope: {
int r0 = (++it)->u.operand;
printf("[%4d] push_scope\t %s\n", location, registerName(r0).c_str());
break;
}
case op_pop_scope: {
printf("[%4d] pop_scope\n", location);
break;
}
case op_jmp_scopes: {
int scopeDelta = (++it)->u.operand;
int offset = (++it)->u.operand;
printf("[%4d] jmp_scopes\t^%d, %d(->%d)\n", location, scopeDelta, offset, jumpTarget(begin, it, offset));
break;
}
case op_catch: {
int r0 = (++it)->u.operand;
printf("[%4d] catch\t\t %s\n", location, registerName(r0).c_str());
break;
}
case op_throw: {
int r0 = (++it)->u.operand;
printf("[%4d] throw\t\t %s\n", location, registerName(r0).c_str());
break;
}
case op_new_error: {
int r0 = (++it)->u.operand;
int errorType = (++it)->u.operand;
int k0 = (++it)->u.operand;
printf("[%4d] new_error\t %s, %d, %s\n", location, registerName(r0).c_str(), errorType, constantName(exec, k0, jsValues[k0]).c_str());
break;
}
case op_jsr: {
int retAddrDst = (++it)->u.operand;
int offset = (++it)->u.operand;
printf("[%4d] jsr\t\t %s, %d(->%d)\n", location, registerName(retAddrDst).c_str(), offset, jumpTarget(begin, it, offset));
break;
}
case op_sret: {
int retAddrSrc = (++it)->u.operand;
printf("[%4d] sret\t\t %s\n", location, registerName(retAddrSrc).c_str());
break;
}
case op_debug: {
int debugHookID = (++it)->u.operand;
int firstLine = (++it)->u.operand;
int lastLine = (++it)->u.operand;
printf("[%4d] debug\t\t %s, %d, %d\n", location, debugHookName(debugHookID), firstLine, lastLine);
break;
}
case op_end: {
int r0 = (++it)->u.operand;
printf("[%4d] end\t\t %s\n", location, registerName(r0).c_str());
break;
}
default: {
ASSERT_NOT_REACHED();
break;
}
}
}
static void printConditionalJump(const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it, int location, const char* op)
{
int r0 = (++it)->u.operand;
int offset = (++it)->u.operand;
printf("[%4d] %s\t\t %s, %d(->%d)\n", location, op, registerName(r0).c_str(), offset, jumpTarget(begin, it, offset));
}
Components::CCMHome_ptr
AssemblyImpl::instantiateHome
(Components::Deployment::Container_ptr container, HomeInstanceData data)
throw(Components::CreateFailure)
{
Components::CCMHome_var home;
// extension, existing home can be referenced
if(data.file.length())
{
//
// create home
//
DEBUG_OUT2( "AssemblyImpl: create new home ", data.id );
try
{
Components::ConfigValues_var config = new Components::ConfigValues();
home = container->install_home(data.impl_id.c_str(), "", config);
}
catch (Components::Deployment::UnknownImplId&)
{
NORMAL_ERR2( "AssemblyImpl: unknown impl id during install_home() for ", data.id );
throw Components::CreateFailure();
}
catch (Components::Deployment::ImplEntryPointNotFound&)
{
NORMAL_ERR2( "AssemblyImpl: entry point not found during install_home() for ", data.id );
throw Components::CreateFailure();
}
catch (Components::Deployment::InstallationFailure&)
{
NORMAL_ERR2( "AssemblyImpl: installation failure during install_home() for ", data.id );
throw Components::CreateFailure();
}
catch (Components::Deployment::InvalidConfiguration&)
{
NORMAL_ERR2( "AssemblyImpl: invalid configuration during install_home() for ", data.id );
throw Components::CreateFailure();
}
catch (CORBA::SystemException&)
{
NORMAL_ERR2( "AssemblyImpl: CORBA system exception during install_home() for ", data.id );
throw Components::CreateFailure();
}
if (CORBA::is_nil(home))
{
NORMAL_ERR2( "AssemblyImpl: Component Home is NIL for ", data.id );
throw Components::CreateFailure();
}
//
// register created home
//
homeMap_[data.id] = Components::CCMHome::_duplicate(home);
}
else
{
//
// extension, use referenced home
//
DEBUG_OUT2( "AssemblyImpl: resolve home ", data.impl_id );
home = Components::CCMHome::_narrow( resolveName(data.impl_id) );
}
//
// registerwithhomefinder
//
// todo
//
// registerwithnaming
//
if (data.naming.length())
{
DEBUG_OUT2( "AssemblyImpl: register home with naming ", data.naming );
registerName( data.naming, home, true );
}
//
// registerwithtrader
//
// todo
return home._retn();
}
void
TR::RegDepCopyRemoval::updateSingleRegDep(TR_GlobalRegisterNumber reg, TR::Node *newValueNode)
{
RegDepInfo &dep = getRegDepInfo(reg);
TR_ASSERT(_treetop->getNode()->getOpCodeValue() != TR::BBStart, "attempted to change %s in incoming GlRegDeps on BBStart n%un\n", registerName(reg), _treetop->getNode()->getGlobalIndex());
TR::Node *prevChild = _regDeps->getChild(dep.childIndex);
TR_ASSERT(prevChild == dep.node, "childIndex and node inconsistent in RegDepInfo for %s\n", registerName(reg));
TR_ASSERT(prevChild->getGlobalRegisterNumber() == reg, "childIndex and reg inconsistent in RegDepInfo for %s\n", registerName(reg));
if (newValueNode->getOpCode().isLoadReg()
&& newValueNode->getGlobalRegisterNumber() == reg)
{
_regDeps->setAndIncChild(dep.childIndex, newValueNode);
}
else
{
TR::Node *newOutgoingPassThroughNode = TR::Node::create(TR::PassThrough, 1, newValueNode);
newOutgoingPassThroughNode->setGlobalRegisterNumber(reg);
_regDeps->setAndIncChild(dep.childIndex, newOutgoingPassThroughNode);
}
prevChild->recursivelyDecReferenceCount();
rememberNodeChoice(reg, newValueNode);
}
int InternalEdge::setRecvCoords(char* vert, char* exchange)
{
registerName(vert, &recv_vertex_id);
registerName(exchange, &recv_vertex_exchange_id);
return 0;
}
void topoMapper::storeGradients
(
GradientTable& gradTable,
PtrList<gradType>& gradList
) const
{
// Define a few typedefs for convenience
typedef GeometricField<Type, fvPatchField, volMesh> volType;
typedef const GeometricField<Type, fvPatchField, volMesh> constVolType;
typedef HashTable<constVolType*> volTypeTable;
// Fetch all fields from registry
volTypeTable fields(mesh_.objectRegistry::lookupClass<volType>());
// Track field count
label nFields = 0;
// Store old-times before gradient computation
for
(
typename volTypeTable::iterator fIter = fields.begin();
fIter != fields.end();
++fIter
)
{
fIter()->storeOldTimes();
nFields++;
}
// Size up the list
gradList.setSize(nFields);
label fieldIndex = 0;
for
(
typename volTypeTable::const_iterator fIter = fields.begin();
fIter != fields.end();
++fIter
)
{
const volType& field = *fIter();
// Compute the gradient.
// If the fvSolution dictionary contains an entry,
// use that, otherwise, default to leastSquares
word gradName("grad(" + field.name() + ')');
// Register field under a name that's unique
word registerName("remapGradient(" + field.name() + ')');
// Make a new entry
if (mesh_.schemesDict().subDict("gradSchemes").found(gradName))
{
gradList.set
(
fieldIndex,
new gradType
(
IOobject
(
registerName,
mesh_.time().timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
true
),
fvc::grad(field, gradName)()
)
);
}
else
{
gradList.set
(
fieldIndex,
new gradType
(
IOobject
(
registerName,
mesh_.time().timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
true
),
fv::leastSquaresGrad<Type>(mesh_).grad(field)()
)
);
}
// Add a map entry
gradTable.insert
(
field.name(),
GradientMap(registerName, fieldIndex++)
);
}
}
int ControlEdge::setSendCoords(char* vert, char* exchange)
{
registerName(vert, &send_vertex_id);
registerName(exchange, &send_vertex_exchange_id);
return 0;
}
void
TR::RegDepCopyRemoval::ignoreRegister(TR_GlobalRegisterNumber reg)
{
if (reg < _regBegin || reg >= _regEnd)
return; // don't even have corresponding array elements
RegDepInfo &dep = getRegDepInfo(reg);
TR_ASSERT(dep.state == REGDEP_ABSENT, "attempted to ignore previously specified register %s\n", registerName(reg));
dep.state = REGDEP_IGNORED;
}
