void EMips::reset() { #ifdef DEBUG_EXEC setTrace(true); #endif unsigned int t; pc=0; npc=pc+4; ir=0; for(t=0;t<32;t++) { G[t]=0; } for(t=0;t<32;t++) { F[t]=0.0; } tookBranch=false; branch_address=0; op=0; opName=(char *)NULL; top=0; bop=0; opFormat=EMIPS_FORMAT_UNKNOWN; opSubFormat=0; opFlags=0; hasFPU=true; hasMMU=true; // TODO: where does a MIPS normally go on reset? //writeReg(25,resetEntry&0xffff0000); // TODO: kludge!!! ULONG globPtr=0; if(map) { EModule *mod=map->getFirstModule(); if(mod) { EMapSymbol *dataNode=mod->lookupNodeByName(".data"); if(dataNode) globPtr=dataNode->addr; else DEBUG_OUT<<"Couldn't set gp, no .data node!\n"; } else DEBUG_OUT<<"Couldn't set gp, no module!\n"; } else DEBUG_OUT<<"Couldn't set gp, no map!\n"; writeReg(0x1c,globPtr); clearStackTrace(); ECPUAbstract::reset(); }
/** * Creates the different Modules * @param cmdLineArgs */ void createModules(Rose_STL_Container<string> &cmdLineArgs, vector<ModuleBase *> *moduleList) { setTrace(cmdLineArgs); // Parse the Meta File string filename = ""; if (CommandlineProcessing::isOptionWithParameter(cmdLineArgs, "--meta", "*",filename, true)) { trace << "Filename set" << filename << std::endl; } Parser *parser = new Parser(filename); meta = parser->parseFile(); trace << " Printing Meta " << endl; meta->print(); trace << " Meta Processing done." << endl; // Array of Struct Module Check AOSModuleCheck *aosModuleCheck = new AOSModuleCheck(cmdLineArgs, meta); moduleList->push_back(aosModuleCheck); // Array of Struct Module AOSModule *aosModule = new AOSModule(cmdLineArgs, meta); moduleList->push_back(aosModule); // Hardware Optimization Module HaOptModule *haoptModule = new HaOptModule(cmdLineArgs, meta); moduleList->push_back(haoptModule); }
Atm_led& Atm_led::trace( Stream& stream ) { setTrace( &stream, atm_serial_debug::trace, "LED\0EVT_ON_TIMER\0EVT_OFF_TIMER\0EVT_WT_TIMER\0EVT_COUNTER\0EVT_ON\0EVT_OFF\0EVT_" "BLINK\0EVT_TOGGLE\0EVT_TOGGLE_BLINK\0ELSE\0" "IDLE\0ON\0START\0BLINK_OFF\0LOOP\0DONE\0OFF\0WT_ON\0WT_START" ); return *this; }
void TimelineZoomControl::clear() { m_timer.stop(); setWindowLocked(false); setRange(-1, -1); setTrace(-1, -1); }
Node<FunctionNode>::Link FunctionParser::function(bool isForeign) { if (isForeign) skip(); // Skip "foreign" Trace trace = current().trace; skip(); // Skip "function" or "method" std::string ident = ""; FunctionSignature::Arguments args {}; std::unique_ptr<TypeInfo> returnType; // Is not anon func if (accept(TT::IDENTIFIER)) { ident = current().data; skip(); } if (isForeign && ident.empty()) throw Error("SyntaxError", "Foreign functions can't be anonymous", trace); // Has arguments if (accept(TT::SQPAREN_LEFT)) { skip(); args = getSigArgs(); } // Has return type if (accept(TT::FAT_ARROW)) { skip(); returnType = std::make_unique<TypeInfo>(getTypeList()); } auto func = Node<FunctionNode>::make(ident, FunctionSignature(returnType == nullptr ? nullptr : *returnType, args), isForeign); func->setTrace(trace); // Only non-foreign functions have code bodies if (!isForeign) func->setCode(block(FUNCTION_BLOCK)); // Foreign declarations end in semicolon if (isForeign) expectSemi(); return func; }
Node<MemberNode>::Link TypeParser::member(Visibility vis, bool isStatic) { Trace mbTrace = current().trace; auto parsedAsDecl = declaration(); auto mbNode = Node<MemberNode>::make(parsedAsDecl->getIdentifier(), parsedAsDecl->getTypeInfo().getEvalTypeList(), isStatic, vis == INVALID ? PRIVATE : vis); mbNode->setTrace(mbTrace); if (parsedAsDecl->getChildren().size() > 0) mbNode->setInit(Node<ExpressionNode>::staticPtrCast(parsedAsDecl->removeChild(0))); return mbNode; }
TR_LoadExtensions::TR_LoadExtensions(TR::OptimizationManager *manager) : TR::Optimization(manager), excludedNodes(NULL), loadExtensionPreference(NULL) { setTrace(comp()->getOptions()->getOptsToTrace() != NULL && TR::SimpleRegex::match(comp()->getOptions()->getOptsToTrace(), "traceLoadExtensions")); cg()->getExtendedToInt64GlobalRegisters().Clear(); }
Atm_fade& Atm_fade::trace( Stream& stream ) { #ifndef TINYMachine setTrace( &stream, atm_serial_debug::trace, "FADE\0EVT_CNT_FADE\0EVT_TM_FADE\0EVT_TM_ON\0EVT_TM_OFF\0EVT_CNT_RPT\0EVT_ON\0EVT_OFF\0EVT_" "BLINK\0ELSE\0IDLE\0ON\0START\0STARTU\0UP\0STARTD\0DOWN\0REPEAT" ); #endif return *this; }
Node<MethodNode>::Link TypeParser::method(Visibility vis, bool isStatic, bool isForeign) { Trace methTrace = current().trace; auto parsedAsFunc = function(isForeign); auto methNode = Node<MethodNode>::make(parsedAsFunc->getIdentifier(), parsedAsFunc->getSignature(), vis, isStatic); methNode->setTrace(methTrace); if (isForeign) { expectSemi(); } else { methNode->setCode(Node<BlockNode>::staticPtrCast(parsedAsFunc->removeChild(0))); } return methNode; }
Node<DeclarationNode>::Link DeclarationParser::declarationFromTypes(TypeList typeList) { Token identToken = current(); skip(); auto decl = Node<DeclarationNode>::make(identToken.data, typeList); decl->setTrace(identToken.trace); // Do initialization only if it exists if (accept("=")) { skip(); decl->setInit(expression()); } return decl; }
void EArm::reset() { #ifdef DEBUG_EXEC setTrace(true); #endif breakpoint=0xffffffff; // since we start at 0, breakpoint's default intLock=false; pc=0; // Jump to zero cpsr=0; clearStackTrace(); ECPUAbstract::reset(); }
AdvancedOptionsWidget::AdvancedOptionsWidget( QWidget *parent ) : OptionsDialogPage( parent ), ui( new Ui::AdvancedOptionsWidget ) { ui->setupUi( this ); connect( ui->labelTrace, SIGNAL( clicked() ), this, SLOT( setTrace() ) ); connect( ui->labelDebug, SIGNAL( clicked() ), this, SLOT( setDebug() ) ); connect( ui->labelInfo, SIGNAL( clicked() ), this, SLOT( setInfo() ) ); connect( ui->labelWarn, SIGNAL( clicked() ), this, SLOT( setWarn() ) ); connect( ui->labelError, SIGNAL( clicked() ), this, SLOT( setError() ) ); connect( ui->labelFatal, SIGNAL( clicked() ), this, SLOT( setFatal() ) ); ui->loggingLevel->setValue( QsLogging::Logger::instance().loggingLevel() ); }
void EHitachi::reset() { #ifdef DEBUG_EXEC setTrace(true); #endif breakpoint=0xffff; // since we start at 0, breakpoint's default intLock=false; for(unsigned int t=0; t<8; t++) { R[t]=0; } sp=0; // NOTE: R7 is sp! pc=0; // Jump to zero ccr=0; clearStackTrace(); ECPUAbstract::reset(); }
void Ez80::reset() { #ifdef DEBUG_EXEC setTrace(true); #endif breakpoint=0xffff; // since we start at 0, breakpoint's default ix=0; iy=0; sp=0; a=0; f=0; b=0; c=0; d=0; e=0; h=0; l=0; a1=0; f1=0; b1=0; c1=0; d1=0; e1=0; h1=0; l1=0; i=0; intLock=false; pc=0; // Jump to zero clearStackTrace(); ECPUAbstract::reset(); }
bool CasmReader::hasBinaryHeader(std::shared_ptr<Queue> Binary, std::shared_ptr<SymbolTable> AlgSymtab) { // Note: This is inefficent, but at least works. auto Inflator = std::make_shared<InflateAst>(); InterpreterFlags Flags; Interpreter MyReader(std::make_shared<ByteReader>(Binary), Inflator, Flags, AlgSymtab); if (TraceRead || TraceTree) { auto Trace = std::make_shared<TraceClass>("CasmInterpreter"); Trace->setTraceProgress(true); MyReader.setTrace(Trace); if (TraceTree) Inflator->setTrace(Trace); } MyReader.algorithmStartHasFileHeader(); MyReader.algorithmReadBackFilled(); return !MyReader.errorsFound(); }
Node<ConstructorNode>::Link TypeParser::constructor(Visibility vis, bool isForeign) { Trace constrTrace = current().trace; skip(); // Skip "constructor" FunctionSignature::Arguments args {}; // Has arguments if (accept(TT::SQPAREN_LEFT)) { skip(); args = getSigArgs(); } auto constr = Node<ConstructorNode>::make(args, vis == INVALID ? PUBLIC : vis, isForeign); constr->setTrace(constrTrace); if (isForeign) { expectSemi(); } else { constr->setCode(block(FUNCTION_BLOCK)); } return constr; }
Node<BranchNode>::Link IfStatementParser::ifStatement() { auto branch = Node<BranchNode>::make(); branch->setTrace(current().trace); branch->setCondition(expression()); branch->setSuccessBlock(block(IF_BLOCK)); skip(-1); // Go back to the block termination token if (accept(TT::ELSE)) { skip(); // Else-if structure if (accept(TT::IF)) { skip(); branch->setFailiureBlock(ifStatement()); // Simple else block } else if (accept(TT::DO)) { branch->setFailiureBlock(block(CODE_BLOCK)); } else { throw Error("SyntaxError", "Else must be followed by a block or an if statement", current().trace); } } return branch; }
ASTNode::Link StatementParser::statement() { if (accept(TT::TYPE)) { return type(); } else if (accept(TT::IF)) { skip(); return ifStatement(); } else if (accept(TT::FOR)) { auto loop = Node<LoopNode>::make(); loop->setTrace(current().trace); skip(); // Skip "for" loop->setInit(declaration(false)); expectSemi(); loop->setCondition(expression(false)); expectSemi(); loop->setUpdate(expression(false)); loop->setCode(block(CODE_BLOCK)); return loop; } if (accept(TT::WHILE)) { skip(); // Skip "while" auto loop = Node<LoopNode>::make(); loop->setTrace(current().trace); loop->setCondition(expression()); loop->setCode(block(CODE_BLOCK)); return loop; } else if (accept(TT::DO)) { return block(CODE_BLOCK); } else if (accept(TT::DEFINE)) { auto decl = declaration(); expectSemi(); return decl; } else if (accept(TT::IDENTIFIER)) { skip(); if (accept(TT::IDENTIFIER) || accept(",")) { skip(-1); // Go back to the prev identifier auto decl = declaration(); expectSemi(); return decl; } else { skip(-1); // Get the entire expression auto e = expression(); expectSemi(); return e; } } else if (accept(TT::BREAK)) { skip(); return Node<BreakLoopNode>::make(); } else if (accept(TT::CONTINUE)) { throw InternalError("Unimplemented", {METADATA_PAIRS, {"token", "loop continue"}}); } else if (accept(TT::RETURN)) { auto trace = current().trace; skip(); // Skip "return" auto retValue = expression(false); expectSemi(); auto retNode = Node<ReturnNode>::make(); retNode->setTrace(trace); if (retValue != nullptr) retNode->setValue(retValue); return retNode; } else if (accept(TT::FUNCTION)) { return function(); } else if (accept(TT::FOREIGN)) { return function(true); } else { auto e = expression(); expectSemi(); return e; } }
Node<ExpressionNode>::Link ExpressionParser::expressionImpl(Node<ExpressionNode>::Link lhs, int minPrecedence) { Node<ExpressionNode>::Link base = nullptr; Node<ExpressionNode>::Link lastExpr = nullptr; Token tok = current(); if (acceptEndOfExpression()) return lhs; if (lhs != nullptr) { skip(-1); auto tt = current().type; skip(1); // If we have any of: // IDENTIFIER, C_PAREN_RIGHT, postfix ops // before a paren, it's a function call auto isCallable = tt == TT::IDENTIFIER || tt == TT::PAREN_RIGHT || (tt == TT::OPERATOR && lhs->getToken().op().hasFixity(POSTFIX)); if (accept(TT::PAREN_LEFT) && isCallable) { auto fCall = parseExpressionPrimary(true); auto args = fCall->removeChild(0); fCall->addChild(lhs); fCall->addChild(args); lhs = fCall; // If the expression finishes here, return if (acceptEndOfExpression()) return lhs; // Otherwise, update tok tok = current(); } } while (tok.op().hasArity(BINARY) && tok.op().getPrec() >= minPrecedence) { auto tokExpr = Node<ExpressionNode>::make(tok); tokExpr->setTrace(tok.trace); tokExpr->addChild(lhs); skip(); auto rhs = parseExpressionPrimary(); tok = current(); while (tok.isOp() && tok.op().hasArity(BINARY) && ( tok.op().getPrec() <= tokExpr->getToken().op().getPrec() || (tok.op().getPrec() == tokExpr->getToken().op().getPrec() && tok.op().hasAsoc(ASSOCIATE_FROM_RIGHT)) ) ) { tokExpr->addChild(rhs); tokExpr = expressionImpl(tokExpr, tok.op().getPrec()); rhs = nullptr; tok = current(); } lhs = rhs; if (base == nullptr) { base = lastExpr = tokExpr; } else { lastExpr->addChild(tokExpr); lastExpr = tokExpr; } if (acceptEndOfExpression()) break; } if (base == nullptr) { base = lhs; } else if (lhs != nullptr) { lastExpr->addChild(lhs); } return base; }
Node<ExpressionNode>::Link ExpressionParser::exprFromCurrent() { auto e = Node<ExpressionNode>::make(current()); e->setTrace(current().trace); return e; }