Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "MOSCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "GISelCSEAnalysisWrapper", "&", "Wrapper", "=", "getAnalysis", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ".", "getCSEWrapper", "(", ")", ";", "auto", "*", "CSEInfo", "=", "&", "Wrapper", ".", "get", "(", "TPC", "->", "getCSEConfig", "(", ")", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MOSCombinerInfo", "PCInfo", "(", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "KB", ",", "MDT", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "CSEInfo", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "MOS", "MOS", "MOS" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "constrainOperandRegClass", "(", "const", "MCInstrDesc", "&", "II", ",", "unsigned", "Op", ",", "unsigned", "OpNum", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Op", ")", ")", "{", "const", "TargetRegisterClass", "*", "RegClass", "=", "TII", ".", "getRegClass", "(", "II", ",", "OpNum", ",", "&", "TRI", ",", "*", "FuncInfo", ".", "MF", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "Op", ",", "RegClass", ")", ")", "{", "unsigned", "NewOp", "=", "createResultReg", "(", "RegClass", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewOp", ")", ".", "addReg", "(", "Op", ")", ")", ";", "return", "NewOp", ";", "}", "}", "return", "Op", ";", "}", "</s>" ]

[ "Try", "to", "constrain", "Op", "so", "that", "it", "is", "usable", "by", "argument", "OpNum", "of", "the", "provided", "MCInstrDesc", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "BitVector", "XtensaRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "TargetPassConfig", "*", "PatmosTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "PatmosPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "WebAssemblyStoreResults", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Store Results **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "const", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "MRI", ".", "isSSA", "(", ")", "&&", "\"StoreResults depends on SSA form\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Basic Block: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "Changed", "|=", "optimizeStore", "(", "MBB", ",", "MI", ",", "MRI", ",", "MDT", ")", ";", "break", ";", "case", "WebAssembly", "::", "CALL_I32", ":", "case", "WebAssembly", "::", "CALL_I64", ":", "Changed", "|=", "optimizeCall", "(", "MBB", ",", "MI", ",", "MRI", ",", "MDT", ",", "TLI", ",", "LibInfo", ")", ";", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Store Results **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "\"StoreResults depends on SSA form\"", "\"Basic Block: \"", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "WebAssembly::CALL_I32", "WebAssembly::CALL_I64" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyStoreResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "materialize", "(", "NodeToValueMap", "&", "Loc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Nodes before materialization:\\n\"", "<<", "Nodes", "<<", "'\\n'", ")", ";", "NodeChildrenMap", "NCM", ";", "NodeVect", "Roots", ";", "invert_find_roots", "(", "Nodes", ",", "NCM", ",", "Roots", ")", ";", "while", "(", "!", "Roots", ".", "empty", "(", ")", ")", "{", "NodeVect", "::", "iterator", "First", "=", "Roots", ".", "begin", "(", ")", ";", "GepNode", "*", "Root", "=", "*", "First", ",", "*", "Last", "=", "*", "First", ";", "Roots", ".", "erase", "(", "First", ")", ";", "NodeVect", "NA", ";", "bool", "LastUsed", "=", "false", ";", "unsigned", "LastCN", "=", "0", ";", "Value", "*", "LocV", "=", "Loc", "[", "Last", "]", ";", "if", "(", "!", "LocV", ")", "continue", ";", "BasicBlock", "*", "LastB", "=", "cast", "<", "BasicBlock", ">", "(", "LocV", ")", ";", "do", "{", "NA", ".", "push_back", "(", "Last", ")", ";", "LastUsed", "=", "(", "Last", "->", "Flags", "&", "GepNode", "::", "Used", ")", ";", "if", "(", "LastUsed", ")", "break", ";", "NodeChildrenMap", "::", "iterator", "CF", "=", "NCM", ".", "find", "(", "Last", ")", ";", "LastCN", "=", "(", "CF", "!=", "NCM", ".", "end", "(", ")", ")", "?", "CF", "->", "second", ".", "size", "(", ")", ":", "0", ";", "if", "(", "LastCN", "!=", "1", ")", "break", ";", "GepNode", "*", "Child", "=", "CF", "->", "second", ".", "front", "(", ")", ";", "BasicBlock", "*", "ChildB", "=", "cast_or_null", "<", "BasicBlock", ">", "(", "Loc", "[", "Child", "]", ")", ";", "if", "(", "ChildB", "!=", "nullptr", "&&", "LastB", "!=", "ChildB", ")", "break", ";", "Last", "=", "Child", ";", "}", "while", "(", "true", ")", ";", "BasicBlock", "::", "iterator", "InsertAt", "=", "LastB", "->", "getTerminator", "(", ")", "->", "getIterator", "(", ")", ";", "if", "(", "LastUsed", "||", "LastCN", ">", "0", ")", "{", "ValueVect", "Urs", ";", "getAllUsersForNode", "(", "Root", ",", "Urs", ",", "NCM", ")", ";", "BasicBlock", "::", "iterator", "FirstUse", "=", "first_use_of_in_block", "(", "Urs", ",", "LastB", ")", ";", "if", "(", "FirstUse", "!=", "LastB", "->", "end", "(", ")", ")", "InsertAt", "=", "FirstUse", ";", "}", "Value", "*", "NewInst", "=", "fabricateGEP", "(", "NA", ",", "InsertAt", ",", "LastB", ")", ";", "if", "(", "LastCN", ">", "0", ")", "{", "NodeVect", "&", "Cs", "=", "NCM", "[", "Last", "]", ";", "for", "(", "NodeVect", "::", "iterator", "I", "=", "Cs", ".", "begin", "(", ")", ",", "E", "=", "Cs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "GepNode", "*", "CN", "=", "*", "I", ";", "CN", "->", "Flags", "&=", "~", "GepNode", "::", "Internal", ";", "CN", "->", "Flags", "|=", "GepNode", "::", "Root", ";", "CN", "->", "BaseVal", "=", "NewInst", ";", "Roots", ".", "push_back", "(", "CN", ")", ";", "}", "}", "if", "(", "LastUsed", ")", "{", "NodeToUsesMap", "::", "iterator", "UF", "=", "Uses", ".", "find", "(", "Last", ")", ";", "assert", "(", "UF", "!=", "Uses", ".", "end", "(", ")", "&&", "\"No use information found\"", ")", ";", "UseSet", "&", "Us", "=", "UF", "->", "second", ";", "for", "(", "UseSet", "::", "iterator", "I", "=", "Us", ".", "begin", "(", ")", ",", "E", "=", "Us", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Use", "*", "U", "=", "*", "I", ";", "U", "->", "set", "(", "NewInst", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "This", "method", "can", "be", "implemented", "to", "generate", "a", "mapped", "Value", "on", "demand", "." ]

[ "Hexagon", "Hexagon", "\"Nodes before materialization:\\n\"", "0", "0", "1", "0", "0", "\"No use information found\"" ]

[]

[ "<s>", "BaseType", "::", "const_iterator", "begin", "(", ")", "const", "{", "return", "List", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "MBlazeTargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "MBlazeTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

[ "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "if", "(", "!", "MI", "->", "mayLoadOrStore", "(", ")", ")", "return", "false", ";", "int64_t", "FullOffset", "=", "Offset", "+", "getMUBUFInstrOffset", "(", "MI", ")", ";", "return", "!", "SIInstrInfo", "::", "isLegalMUBUFImmOffset", "(", "FullOffset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "AMDGPU", "SI", "SI" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "UpperBound", "=", "true", ";", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "if", "(", "getBooleanLoopAttribute", "(", "L", ",", "\"llvm.loop.isvectorized\"", ")", ")", "return", ";", "InstructionCost", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "operand_values", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ",", "TargetTransformInfo", "::", "TCK_SizeAndLatency", ")", ";", "}", "}", "unsigned", "UnrollCount", "=", "4", ";", "if", "(", "ST", "->", "isThumb1Only", "(", ")", ")", "{", "unsigned", "ExitingValues", "=", "0", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitBlocks", ";", "L", "->", "getExitBlocks", "(", "ExitBlocks", ")", ";", "for", "(", "auto", "*", "Exit", ":", "ExitBlocks", ")", "{", "unsigned", "LiveOuts", "=", "count_if", "(", "Exit", "->", "phis", "(", ")", ",", "[", "]", "(", "auto", "&", "PH", ")", "{", "return", "PH", ".", "getNumOperands", "(", ")", "!=", "1", "||", "!", "isa", "<", "GetElementPtrInst", ">", "(", "PH", ".", "getOperand", "(", "0", ")", ")", ";", "}", ")", ";", "ExitingValues", "=", "ExitingValues", "<", "LiveOuts", "?", "LiveOuts", ":", "ExitingValues", ";", "}", "if", "(", "ExitingValues", ")", "UnrollCount", "/=", "ExitingValues", ";", "if", "(", "UnrollCount", "<=", "1", ")", "return", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Default Runtime Unroll Count: \"", "<<", "UnrollCount", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "UnrollCount", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "\"llvm.loop.isvectorized\"", "0", "4", "4", "0", "4", "1", "0", "1", "\"Cost of loop: \"", "\"\\n\"", "\"Default Runtime Unroll Count: \"", "\"\\n\"", "60", "12" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_sse_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ",", "true", ")", ")", "{", "ix86_emit_save_reg_using_mov", "(", "V4SFmode", ",", "regno", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "GET_MODE_SIZE", "(", "V4SFmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "SSE", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "stored", "at", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386", "0" ]

[]

[ "<s>", "Register", "MCS51TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", ";", "if", "(", "VT", "==", "LLT", "::", "scalar", "(", "8", ")", ")", "{", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"r0\"", ",", "MCS51", "::", "R0", ")", ".", "Case", "(", "\"r1\"", ",", "MCS51", "::", "R1", ")", ".", "Default", "(", "0", ")", ";", "}", "else", "{", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"r0\"", ",", "MCS51", "::", "R1R0", ")", ".", "Case", "(", "\"sp\"", ",", "MCS51", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "}", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "MCS51", "MCS51", "8", "\"r0\"", "MCS51::R0", "\"r1\"", "MCS51::R1", "0", "\"r0\"", "MCS51::R1R0", "\"sp\"", "MCS51::SP", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "TMS320C64XInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "const", "TargetInstrInfo", "*", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "assert", "(", "TII", "&&", "\"No InstrInfo? Can not create a hazard recognizer!\"", ")", ";", "return", "TargetInstrInfoImpl", "::", "CreateTargetHazardRecognizer", "(", "TM", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "TMS320C64X", "TMS320C64X", "\"No InstrInfo? Can not create a hazard recognizer!\"" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "MBB", "->", "pred_begin", "(", ")", ";", "if", "(", "const", "BasicBlock", "*", "bb", "=", "Pred", "->", "getBasicBlock", "(", ")", ")", "if", "(", "isa", "<", "SwitchInst", ">", "(", "bb", "->", "getTerminator", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MBB", "->", "isLandingPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", ";", "return", "!", "I", "->", "getDesc", "(", ")", ".", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "SlotAlign", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "unsigned", "KillFlag", "=", "getKillRegState", "(", "isKill", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "SlotAlign", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "S2_storeri_io", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "S2_storerd_io", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "STriw_pred", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "ModRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "STriw_ctr", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxQRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vstorerq_ai", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxVRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vstorerv_ai", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxWRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vstorerw_ai", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::S2_storeri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::S2_storerd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::STriw_pred", "0", "Hexagon::ModRegsRegClass", "Hexagon::STriw_ctr", "0", "Hexagon::HvxQRRegClass", "Hexagon::PS_vstorerq_ai", "0", "Hexagon::HvxVRRegClass", "Hexagon::PS_vstorerv_ai", "0", "Hexagon::HvxWRRegClass", "Hexagon::PS_vstorerw_ai", "0", "\"Unimplemented\"" ]

[]

[ "<s>", "int", "num_insns_constant_wide", "(", "HOST_WIDE_INT", "value", ")", "{", "if", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "value", "+", "0x8000", ")", "<", "0x10000", ")", "return", "1", ";", "else", "if", "(", "(", "value", "&", "0xffff", ")", "==", "0", "&&", "(", "value", ">>", "31", "==", "-", "1", "||", "value", ">>", "31", "==", "0", ")", ")", "return", "1", ";", "else", "if", "(", "TARGET_POWERPC64", ")", "{", "HOST_WIDE_INT", "low", "=", "(", "(", "value", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "HOST_WIDE_INT", "high", "=", "value", ">>", "31", ";", "if", "(", "high", "==", "0", "||", "high", "==", "-", "1", ")", "return", "2", ";", "high", ">>=", "1", ";", "if", "(", "low", "==", "0", ")", "return", "num_insns_constant_wide", "(", "high", ")", "+", "1", ";", "else", "if", "(", "high", "==", "0", ")", "return", "num_insns_constant_wide", "(", "low", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_wide", "(", "high", ")", "+", "num_insns_constant_wide", "(", "low", ")", "+", "1", ")", ";", "}", "else", "return", "2", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "it", "takes", "to", "form", "a", "constant", "in", "an", "integer", "register", "." ]

[ "rs6000", "0x8000", "0x10000", "1", "0xffff", "0", "31", "1", "31", "0", "1", "0xffffffff", "0x80000000", "0x80000000", "31", "0", "1", "2", "1", "0", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "static", "rtx", "wprop_gen", "(", "rtx", "reg", ",", "propagate_mask", "pm", ",", "unsigned", "rep", ",", "void", "*", "data_", ")", "{", "wcast_data_t", "*", "data", "=", "(", "wcast_data_t", "*", ")", "data_", ";", "if", "(", "pm", "&", "PM_loop_begin", ")", "{", "unsigned", "align", "=", "GET_MODE_ALIGNMENT", "(", "GET_MODE", "(", "reg", ")", ")", "/", "BITS_PER_UNIT", ";", "if", "(", "align", ">", "worker_bcast_align", ")", "worker_bcast_align", "=", "align", ";", "data", "->", "offset", "=", "(", "data", "->", "offset", "+", "align", "-", "1", ")", "&", "~", "(", "align", "-", "1", ")", ";", "data", "->", "ptr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "return", "gen_adddi3", "(", "data", "->", "ptr", ",", "data", "->", "base", ",", "GEN_INT", "(", "data", "->", "offset", ")", ")", ";", "}", "else", "if", "(", "pm", "&", "PM_loop_end", ")", "{", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "GET_MODE", "(", "data", "->", "ptr", ")", ",", "data", "->", "ptr", ")", ";", "data", "->", "ptr", "=", "NULL_RTX", ";", "return", "clobber", ";", "}", "else", "return", "nvptx_gen_wcast", "(", "reg", ",", "pm", ",", "rep", ",", "data", ")", ";", "}", "</s>" ]

[ "Worker", "for", "nvptx_wpropagate", "." ]

[ "nvptx", "1", "1" ]

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "Val", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "false", ";", "EVT", "VT1", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "!", "VT1", ".", "isSimple", "(", ")", "||", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isSimple", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "switch", "(", "VT1", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "i8", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "XCore", "XCore", "ISD::LOAD", "MVT::i8" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "LanaiOperand", ">", "LanaiAsmParser", "::", "parseIdentifier", "(", ")", "{", "SMLoc", "Start", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "SMLoc", "End", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "1", ")", ";", "const", "MCExpr", "*", "Res", ",", "*", "RHS", "=", "nullptr", ";", "LanaiMCExpr", "::", "VariantKind", "Kind", "=", "LanaiMCExpr", "::", "VK_Lanai_None", ";", "if", "(", "Lexer", ".", "getKind", "(", ")", "!=", "AsmToken", "::", "Identifier", ")", "return", "nullptr", ";", "StringRef", "Identifier", ";", "if", "(", "Parser", ".", "parseIdentifier", "(", "Identifier", ")", ")", "return", "nullptr", ";", "if", "(", "Identifier", ".", "equals_insensitive", "(", "\"hi\"", ")", ")", "Kind", "=", "LanaiMCExpr", "::", "VK_Lanai_ABS_HI", ";", "else", "if", "(", "Identifier", ".", "equals_insensitive", "(", "\"lo\"", ")", ")", "Kind", "=", "LanaiMCExpr", "::", "VK_Lanai_ABS_LO", ";", "if", "(", "Kind", "!=", "LanaiMCExpr", "::", "VK_Lanai_None", ")", "{", "if", "(", "Lexer", ".", "getKind", "(", ")", "!=", "AsmToken", "::", "LParen", ")", "{", "Error", "(", "Lexer", ".", "getLoc", "(", ")", ",", "\"Expected '('\"", ")", ";", "return", "nullptr", ";", "}", "Lexer", ".", "Lex", "(", ")", ";", "if", "(", "Parser", ".", "parseIdentifier", "(", "Identifier", ")", ")", "return", "nullptr", ";", "}", "if", "(", "Lexer", ".", "getKind", "(", ")", "==", "AsmToken", "::", "Plus", "&&", "Parser", ".", "parseExpression", "(", "RHS", ")", ")", "return", "nullptr", ";", "if", "(", "Kind", "!=", "LanaiMCExpr", "::", "VK_Lanai_None", ")", "{", "if", "(", "Lexer", ".", "getKind", "(", ")", "!=", "AsmToken", "::", "RParen", ")", "{", "Error", "(", "Lexer", ".", "getLoc", "(", ")", ",", "\"Expected ')'\"", ")", ";", "return", "nullptr", ";", "}", "Lexer", ".", "Lex", "(", ")", ";", "}", "End", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "1", ")", ";", "MCSymbol", "*", "Sym", "=", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Identifier", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "getContext", "(", ")", ")", ";", "Res", "=", "LanaiMCExpr", "::", "create", "(", "Kind", ",", "Expr", ",", "getContext", "(", ")", ")", ";", "if", "(", "RHS", ")", "Res", "=", "MCBinaryExpr", "::", "createAdd", "(", "Res", ",", "RHS", ",", "getContext", "(", ")", ")", ";", "return", "LanaiOperand", "::", "createImm", "(", "Res", ",", "Start", ",", "End", ")", ";", "}", "</s>" ]

[ "Parse", "an", "identifier", "or", "string", "(", "as", "a", "quoted", "identifier", ")", "and", "set", "Res", "to", "the", "identifier", "contents", "." ]

[ "Lanai", "Lanai", "Lanai", "1", "Lanai", "Lanai", "Lanai", "\"hi\"", "Lanai", "Lanai", "\"lo\"", "Lanai", "Lanai", "Lanai", "Lanai", "\"Expected '('\"", "Lanai", "Lanai", "\"Expected ')'\"", "1", "Lanai", "LanaiOperand::createImm" ]

[]

[ "<s>", "bool", "alpha_expand_mov", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "rtx", "tmp", ";", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "mode", "==", "Pmode", "&&", "symbolic_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "{", "tmp", "=", "alpha_legitimize_address_1", "(", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ",", "mode", ")", ";", "if", "(", "tmp", ")", "{", "if", "(", "tmp", "==", "operands", "[", "0", "]", ")", "return", "true", ";", "operands", "[", "1", "]", "=", "tmp", ";", "return", "false", ";", "}", "}", "if", "(", "!", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", "||", "input_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "CONST_INT_P", "(", "operands", "[", "1", "]", ")", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "alpha_split_const_mov", "(", "mode", ",", "operands", ")", ")", "return", "true", ";", "}", "tmp", "=", "force_const_mem", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "reload_in_progress", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "XEXP", "(", "tmp", ",", "0", ")", ")", ";", "operands", "[", "1", "]", "=", "replace_equiv_address", "(", "tmp", ",", "operands", "[", "0", "]", ")", ";", "}", "else", "operands", "[", "1", "]", "=", "validize_mem", "(", "tmp", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Expand", "a", "move", "instruction", ";", "return", "true", "if", "all", "work", "is", "done", ".", "We", "do", "n't", "handle", "non-bwx", "subword", "loads", "here", "." ]

[ "alpha", "0", "1", "1", "1", "1", "1", "0", "0", "1", "1", "1", "1", "1", "1", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "short", "high_pressure", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "(", "REG_N_SETS", "(", "0", ")", "-", "REG_N_DEATHS", "(", "0", ")", ")", ">=", "R0_MAX_LIFE_REGIONS", "&&", "REG_LIVE_LENGTH", "(", "0", ")", ">=", "R0_MAX_LIVE_LENGTH", ")", "return", "1", ";", "if", "(", "mode", "==", "SFmode", ")", "return", "(", "CURR_REGMODE_PRESSURE", "(", "SFmode", ")", ">", "SFMODE_MAX_WEIGHT", ")", ";", "else", "return", "(", "CURR_REGMODE_PRESSURE", "(", "SImode", ")", ">", "SIMODE_MAX_WEIGHT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "pressure", "is", "high", "for", "MODE", "." ]

[ "sh", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "msp430_is_interrupt_func", "(", "void", ")", "{", "return", "is_interrupt_func", "(", "current_function_decl", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "function", "has", "the", "``", "interrupt", "''", "attribute", "." ]

[ "msp430" ]

[]

[ "<s>", "int", "system_reg_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "REGNO", "(", "op", ")", ")", "{", "case", "PR_REG", ":", "case", "MACL_REG", ":", "case", "MACH_REG", ":", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Returns", "1", "if", "OP", "is", "MACL", ",", "MACH", "or", "PR", ".", "The", "input", "must", "be", "a", "REG", "rtx", ".", "Used", "only", "in", "general_movsrc_operand", "." ]

[ "sh", "1", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasUnwantedEffectsWhenEXECEmpty", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "MI", ".", "mayStore", "(", ")", "&&", "isSMRD", "(", "MI", ")", ")", "return", "true", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SENDMSG", "||", "Opcode", "==", "AMDGPU", "::", "S_SENDMSGHALT", "||", "Opcode", "==", "AMDGPU", "::", "EXP", "||", "Opcode", "==", "AMDGPU", "::", "EXP_DONE", "||", "Opcode", "==", "AMDGPU", "::", "DS_ORDERED_COUNT", "||", "Opcode", "==", "AMDGPU", "::", "S_TRAP", ")", "return", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", "||", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "V_READFIRSTLANE_B32", "||", "Opcode", "==", "AMDGPU", "::", "V_READLANE_B32", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "we", "must", "prevent", "this", "instruction", "from", "executing", "with", "EXEC", "=", "0", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_SENDMSG", "AMDGPU::S_SENDMSGHALT", "AMDGPU::EXP", "AMDGPU::EXP_DONE", "AMDGPU::DS_ORDERED_COUNT", "AMDGPU::S_TRAP", "AMDGPU::V_READFIRSTLANE_B32", "AMDGPU::V_READLANE_B32" ]

[]

[ "<s>", "void", "output_addr_const_pdp11", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "char", "buf", "[", "256", "]", ";", "restart", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "PC", ":", "gcc_assert", "(", "flag_pic", ")", ";", "putc", "(", "'.'", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "assemble_name", "(", "file", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "LABEL_REF", ":", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "x", ")", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "break", ";", "case", "CONST_INT", ":", "fprintf", "(", "file", ",", "\"%#ho\"", ",", "(", "unsigned", "short", ")", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "CONST", ":", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "{", "gcc_assert", "(", "!", "CONST_DOUBLE_HIGH", "(", "x", ")", ")", ";", "fprintf", "(", "file", ",", "\"%#ho\"", ",", "(", "unsigned", "short", ")", "CONST_DOUBLE_LOW", "(", "x", ")", ")", ";", "}", "else", "output_operand_lossage", "(", "\"floating constant misused\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "CONST_INT", ")", "{", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "0", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "}", "else", "{", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "break", ";", "case", "MINUS", ":", "x", "=", "simplify_subtraction", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MINUS", ")", "goto", "restart", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"-\"", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "0", ")", "{", "fprintf", "(", "file", ",", "targetm", ".", "asm_out", ".", "open_paren", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "targetm", ".", "asm_out", ".", "close_paren", ")", ";", "}", "else", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "break", ";", "case", "ZERO_EXTEND", ":", "case", "SIGN_EXTEND", ":", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"invalid expression as operand\"", ")", ";", "}", "}", "</s>" ]

[ "A", "copy", "of", "output_addr_const", "modified", "for", "pdp11", "expression", "syntax", ".", "output_addr_const", "also", "gets", "called", "for", "%", "cDIGIT", "and", "%", "nDIGIT", ",", "which", "we", "do", "n't", "use", ",", "and", "for", "debugging", "output", ",", "which", "we", "do", "n't", "support", "with", "this", "port", "either", ".", "So", "this", "copy", "should", "get", "called", "whenever", "needed", "." ]

[ "pdp11", "256", "0", "\"L\"", "0", "\"L\"", "\"%#ho\"", "0", "\"%#ho\"", "\"floating constant misused\"", "0", "1", "0", "0", "\"+\"", "0", "0", "1", "0", "\"+\"", "1", "0", "\"-\"", "1", "1", "0", "1", "1", "0", "\"invalid expression as operand\"" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_store_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "tree", "arg1", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ";", "rtx", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "rtx", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "enum", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "enum", "machine_mode", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "op0", "=", "gen_rtx_MEM", "(", "mode0", ",", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Subroutine", "of", "ix86_expand_builtin", "to", "take", "care", "of", "stores", "." ]

[ "i386", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MBlazeTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "MBlaze", "::", "CPURegsRegisterClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "MBlaze", "::", "FGR32RegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "MBlaze", "MBlaze", "1", "0", "0U", "MBlaze::CPURegsRegisterClass", "MVT::f32", "0U", "MBlaze::FGR32RegisterClass" ]

[]

[ "<s>", "static", "int", "mcore_and_cost", "(", "rtx", "x", ")", "{", "HOST_WIDE_INT", "val", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "2", ";", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "CONST_OK_FOR_K", "(", "val", ")", "||", "CONST_OK_FOR_M", "(", "~", "val", ")", ")", "return", "2", ";", "else", "if", "(", "const_ok_for_mcore", "(", "val", ")", ")", "return", "3", ";", "else", "if", "(", "TARGET_HARDLIT", "&&", "mcore_const_ok_for_inline", "(", "val", ")", ")", "return", "4", ";", "return", "5", ";", "}", "</s>" ]

[ "What", "does", "an", "and", "instruction", "cost", "-", "we", "do", "this", "b/c", "immediates", "may", "have", "been", "relaxed", ".", "We", "want", "to", "ensure", "that", "cse", "will", "cse", "relaxed", "immeds", "out", ".", "Otherwise", "we", "'ll", "get", "bad", "code", "(", "multiple", "reloads", "of", "the", "same", "const", ")", "." ]

[ "mcore", "1", "2", "1", "2", "3", "4", "5" ]

[]

[ "<s>", "bool", "VLIWResourceModel", "::", "isResourceAvailable", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "!", "SU", "||", "!", "SU", "->", "getInstr", "(", ")", ")", "return", "false", ";", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "!", "ResourcesModel", "->", "canReserveResources", "(", "SU", "->", "getInstr", "(", ")", ")", ")", "return", "false", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "Packet", "[", "i", "]", "->", "Succs", ".", "size", "(", ")", "==", "0", ")", "continue", ";", "for", "(", "SUnit", "::", "const_succ_iterator", "I", "=", "Packet", "[", "i", "]", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "Packet", "[", "i", "]", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCtrl", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getSUnit", "(", ")", "==", "SU", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "scheduling", "of", "this", "SU", "is", "possible", "in", "the", "current", "packet", "." ]

[ "Hexagon", "0", "0" ]

[]

[ "<s>", "bool", "arc_check_mov_const", "(", "HOST_WIDE_INT", "ival", ")", "{", "ival", "=", "ival", "&", "0xffffffff", ";", "if", "(", "SIGNED_INT12", "(", "ival", ")", ")", "return", "false", ";", "if", "(", "(", "ival", "&", "~", "0x8000001f", ")", "==", "0", ")", "return", "true", ";", "if", "(", "IS_POWEROF2_P", "(", "ival", "+", "1", ")", ")", "return", "true", ";", "if", "(", "!", "TARGET_BARREL_SHIFTER", ")", "return", "false", ";", "if", "(", "(", "(", "ival", ">>", "(", "__builtin_ffs", "(", "ival", ")", "-", "1", ")", ")", "&", "0xffffff00", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "ival", "&", "~", "0x3f00", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "ival", "&", "~", "0x3f0000", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "ival", "&", "~", "0x3f000000", ")", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "to", "check", "Cax", "constraint", "." ]

[ "arc", "0xffffffff", "0x8000001f", "0", "1", "1", "0xffffff00", "0", "0x3f00", "0", "0x3f0000", "0", "0x3f000000", "0" ]

[]

[ "<s>", "void", "aarch64_declare_function_name", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "tree", "fndecl", ")", "{", "tree", "target_parts", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "struct", "cl_target_option", "*", "targ_options", ";", "if", "(", "target_parts", ")", "targ_options", "=", "TREE_TARGET_OPTION", "(", "target_parts", ")", ";", "else", "targ_options", "=", "TREE_TARGET_OPTION", "(", "target_option_current_node", ")", ";", "gcc_assert", "(", "targ_options", ")", ";", "const", "struct", "processor", "*", "this_arch", "=", "aarch64_get_arch", "(", "targ_options", "->", "x_explicit_arch", ")", ";", "uint64_t", "isa_flags", "=", "targ_options", "->", "x_aarch64_isa_flags", ";", "std", "::", "string", "extension", "=", "aarch64_get_extension_string_for_isa_flags", "(", "isa_flags", ",", "this_arch", "->", "flags", ")", ";", "std", "::", "string", "to_print", "=", "this_arch", "->", "name", "+", "extension", ";", "if", "(", "to_print", "!=", "aarch64_last_printed_arch_string", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arch %s\\n\"", ",", "to_print", ".", "c_str", "(", ")", ")", ";", "aarch64_last_printed_arch_string", "=", "to_print", ";", "}", "const", "struct", "processor", "*", "this_tune", "=", "aarch64_get_tune_cpu", "(", "targ_options", "->", "x_explicit_tune_core", ")", ";", "if", "(", "flag_debug_asm", "&&", "aarch64_last_printed_tune_string", "!=", "this_tune", "->", "name", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\"", "ASM_COMMENT_START", "\".tune %s\\n\"", ",", "this_tune", "->", "name", ")", ";", "aarch64_last_printed_tune_string", "=", "this_tune", "->", "name", ";", "}", "aarch64_asm_output_variant_pcs", "(", "stream", ",", "fndecl", ",", "name", ")", ";", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "stream", ",", "name", ",", "\"function\"", ")", ";", "ASM_OUTPUT_LABEL", "(", "stream", ",", "name", ")", ";", "cfun", "->", "machine", "->", "label_is_assembled", "=", "true", ";", "}", "</s>" ]

[ "Implement", "ASM_DECLARE_FUNCTION_NAME", ".", "Output", "the", "ISA", "features", "used", "by", "the", "function", "fndecl", "." ]

[ "aarch64", "\"\\t.arch %s\\n\"", "\"\\t\"", "\".tune %s\\n\"", "\"function\"" ]

[]

[ "<s>", "bool", "WebAssemblyPassConfig", "::", "addInstSelector", "(", ")", "{", "(", "void", ")", "TargetPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "createWebAssemblyISelDag", "(", "getWebAssemblyTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createWebAssemblyArgumentMove", "(", ")", ")", ";", "addPass", "(", "createWebAssemblySetP2AlignOperands", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixBrTableDefaults", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "SystemZSubtarget", "&", "SystemZSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "CPUName", "==", "\"generic\"", ")", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "\"generic\"", "\"generic\"" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "Result", ".", "reset", "(", "new", "AMDGPUAAResult", "(", "M", ".", "getDataLayout", "(", ")", ",", "Triple", "(", "M", ".", "getTargetTriple", "(", ")", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "VLIWResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ",", "bool", "IsTop", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ",", "IsTop", ")", "||", "Packet", ".", "size", "(", ")", ">=", "SchedModel", "->", "getIssueWidth", "(", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "ResourcesModel", "->", "reserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "break", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "break", ";", "}", "Packet", ".", "push_back", "(", "SU", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Packet[\"", "<<", "TotalPackets", "<<", "\"]:\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[\"", "<<", "i", "<<", "\"] SU(\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "\")\\t\"", ")", ";", "LLVM_DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "return", "startNewCycle", ";", "}", "</s>" ]

[ "Keep", "track", "of", "available", "resources", "." ]

[ "Hexagon", "\"Packet[\"", "\"]:\\n\"", "0", "\"\\t[\"", "\"] SU(\"", "\")\\t\"" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "return", "Reg", ".", "RegNo", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "R600" ]

[]

[ "<s>", "rtx", "dimode_scalar_chain", "::", "replace_with_subreg", "(", "rtx", "x", ",", "rtx", "reg", ",", "rtx", "new_reg", ")", "{", "if", "(", "x", "==", "reg", ")", "return", "gen_rtx_SUBREG", "(", "V2DImode", ",", "new_reg", ",", "0", ")", ";", "const", "char", "*", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "XEXP", "(", "x", ",", "i", ")", "=", "replace_with_subreg", "(", "XEXP", "(", "x", ",", "i", ")", ",", "reg", ",", "new_reg", ")", ";", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", "=", "replace_with_subreg", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ",", "reg", ",", "new_reg", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Replace", "REG", "in", "X", "with", "a", "V2DI", "subreg", "of", "NEW_REG", "." ]

[ "i386", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "void", "alpha_initialize_trampoline", "(", "rtx", "tramp", ",", "rtx", "fnaddr", ",", "rtx", "cxt", ",", "int", "fnofs", ",", "int", "cxtofs", ",", "int", "jmpofs", ")", "{", "rtx", "temp", ",", "temp1", ",", "addr", ";", "enum", "machine_mode", "mode", "=", "TARGET_ABI_OPEN_VMS", "?", "Pmode", ":", "ptr_mode", ";", "fnaddr", "=", "convert_memory_address", "(", "mode", ",", "fnaddr", ")", ";", "cxt", "=", "convert_memory_address", "(", "mode", ",", "cxt", ")", ";", "addr", "=", "memory_address", "(", "mode", ",", "plus_constant", "(", "tramp", ",", "fnofs", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ",", "fnaddr", ")", ";", "addr", "=", "memory_address", "(", "mode", ",", "plus_constant", "(", "tramp", ",", "cxtofs", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ",", "cxt", ")", ";", "if", "(", "0", "&&", "jmpofs", ">=", "0", ")", "{", "temp", "=", "force_operand", "(", "plus_constant", "(", "tramp", ",", "jmpofs", "+", "4", ")", ",", "NULL_RTX", ")", ";", "temp", "=", "expand_binop", "(", "DImode", ",", "sub_optab", ",", "fnaddr", ",", "temp", ",", "temp", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "temp", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "Pmode", ",", "temp", ",", "build_int_cst", "(", "NULL_TREE", ",", "2", ")", ",", "NULL_RTX", ",", "1", ")", ";", "temp", "=", "expand_and", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "temp", ")", ",", "GEN_INT", "(", "0x3fff", ")", ",", "0", ")", ";", "addr", "=", "memory_address", "(", "SImode", ",", "plus_constant", "(", "tramp", ",", "jmpofs", ")", ")", ";", "temp1", "=", "force_reg", "(", "SImode", ",", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ")", ";", "temp1", "=", "expand_and", "(", "SImode", ",", "temp1", ",", "GEN_INT", "(", "0xffffc000", ")", ",", "NULL_RTX", ")", ";", "temp1", "=", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "temp1", ",", "temp", ",", "temp1", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ",", "temp1", ")", ";", "}", "emit_library_call", "(", "init_one_libfunc", "(", "\"__enable_execute_stack\"", ")", ",", "0", ",", "VOIDmode", ",", "1", ",", "tramp", ",", "Pmode", ")", ";", "if", "(", "jmpofs", ">=", "0", ")", "emit_insn", "(", "gen_imb", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "TRAMP", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "The", "three", "offset", "parameters", "are", "for", "the", "individual", "template", "'s", "layout", ".", "A", "JMPOFS", "<", "0", "indicates", "that", "the", "trampoline", "does", "not", "contain", "instructions", "at", "all", ".", "We", "assume", "here", "that", "a", "function", "will", "be", "called", "many", "more", "times", "than", "its", "address", "is", "taken", "(", "e.g.", ",", "it", "might", "be", "passed", "to", "qsort", ")", ",", "so", "we", "take", "the", "trouble", "to", "initialize", "the", "``", "hint", "''", "field", "in", "the", "JMP", "insn", ".", "Note", "that", "the", "hint", "field", "is", "PC", "(", "new", ")", "+", "4", "*", "bits", "13:0", "." ]

[ "alpha", "0", "0", "4", "1", "2", "1", "0x3fff", "0", "0xffffc000", "1", "\"__enable_execute_stack\"", "0", "1", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "isTriviallyReMaterializable", "(", "MI", ",", "AA", ")", ";", "case", "AMDGPU", "::", "S_MOV_B32", ":", "case", "AMDGPU", "::", "S_MOV_B64", ":", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "return", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "trivially", "rematerializable", ",", "meaning", "it", "has", "no", "side", "effects", "and", "requires", "no", "operands", "that", "are", "n't", "always", "available", "." ]

[ "R600", "SI", "1" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "ScalarizeVectorLoad", "(", "Op", ",", "DAG", ")", ";", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "PtrVT", "=", "BasePtr", ".", "getValueType", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "MachinePointerInfo", "SrcValue", "(", "Load", "->", "getMemOperand", "(", ")", "->", "getValue", "(", ")", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "Load", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ",", "PtrVT", ")", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "Load", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "R600", "2", "ISD::ADD", "ISD::CONCAT_VECTORS", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "static", "void", "visium_print_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "int", "letter", ")", "{", "switch", "(", "letter", ")", "{", "case", "'#'", ":", "if", "(", "final_sequence", ")", "visium_indent_opcode", "=", "1", ";", "else", "fputs", "(", "\"\\n\\t nop\"", ",", "file", ")", ";", "return", ";", "case", "'b'", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "UINTVAL", "(", "op", ")", "&", "0xff", ")", ";", "return", ";", "case", "'w'", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "UINTVAL", "(", "op", ")", "&", "0xffff", ")", ";", "return", ";", "case", "'u'", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "(", "UINTVAL", "(", "op", ")", ">>", "16", ")", "&", "0xffff", ")", ";", "return", ";", "case", "'r'", ":", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "]", ",", "file", ")", ";", "else", "fputs", "(", "reg_names", "[", "0", "]", ",", "file", ")", ";", "return", ";", "case", "'f'", ":", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "]", ",", "file", ")", ";", "else", "fputs", "(", "reg_names", "[", "FP_FIRST_REGNUM", "]", ",", "file", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "if", "(", "letter", "==", "'d'", ")", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "+", "1", "]", ",", "file", ")", ";", "else", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "break", ";", "case", "MEM", ":", "visium_print_operand_address", "(", "file", ",", "GET_MODE", "(", "op", ")", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "break", ";", "case", "CONST_INT", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "op", ")", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "asm_fprintf", "(", "file", ",", "\"%LL%d\"", ",", "CODE_LABEL_NUMBER", "(", "op", ")", ")", ";", "break", ";", "case", "HIGH", ":", "visium_print_operand", "(", "file", ",", "XEXP", "(", "op", ",", "1", ")", ",", "letter", ")", ";", "break", ";", "default", ":", "fatal_insn", "(", "\"illegal operand \"", ",", "op", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND", ".", "Output", "to", "stdio", "stream", "FILE", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "OP", "subject", "to", "the", "modifier", "LETTER", "." ]

[ "visium", "1", "\"\\n\\t nop\"", "0xff", "0xffff", "16", "0xffff", "0", "1", "0", "\"%LL%d\"", "1", "\"illegal operand \"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMRegisterInfo", "::", "getPointerRegClass", "(", ")", "const", "{", "return", "&", "ARM", "::", "GPRRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "ARM", "ARM", "ARM::GPRRegClass" ]

[]

[ "<s>", "static", "void", "sh_override_options_after_change", "(", "void", ")", "{", "if", "(", "align_loops", "==", "0", ")", "{", "if", "(", "TARGET_SH5", ")", "align_loops", "=", "8", ";", "else", "align_loops", "=", "optimize_size", "?", "2", ":", "4", ";", "}", "if", "(", "align_jumps", "==", "0", ")", "{", "if", "(", "TARGET_SHMEDIA", ")", "align_jumps", "=", "1", "<<", "CACHE_LOG", ";", "else", "align_jumps", "=", "2", ";", "}", "else", "if", "(", "align_jumps", "<", "(", "TARGET_SHMEDIA", "?", "4", ":", "2", ")", ")", "align_jumps", "=", "TARGET_SHMEDIA", "?", "4", ":", "2", ";", "if", "(", "align_functions", "==", "0", ")", "{", "if", "(", "TARGET_SHMEDIA", ")", "align_functions", "=", "optimize_size", "?", "FUNCTION_BOUNDARY", "/", "8", ":", "(", "1", "<<", "CACHE_LOG", ")", ";", "else", "align_functions", "=", "optimize_size", "?", "2", ":", "4", ";", "}", "if", "(", "TARGET_RELAX", ")", "{", "int", "min_align", "=", "align_loops", ">", "align_jumps", "?", "align_loops", ":", "align_jumps", ";", "if", "(", "min_align", "<", "4", ")", "min_align", "=", "4", ";", "if", "(", "align_functions", "<", "min_align", ")", "align_functions", "=", "min_align", ";", "}", "}", "</s>" ]

[ "Implement", "targetm.override_options_after_change", "." ]

[ "sh", "0", "8", "2", "4", "0", "1", "2", "4", "2", "4", "2", "0", "8", "1", "2", "4", "4", "4" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "unsigned", "Size", "=", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "Size", "==", "128", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "store", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "into", "." ]

[ "AArch64", "AArch64", "128" ]

[]

[ "<s>", "void", "MOSPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createMOSPostRAScavengingPass", "(", ")", ")", ";", "addPass", "(", "&", "FinalizeISelID", ")", ";", "addPass", "(", "&", "ExpandPostRAPseudosID", ")", ";", "addPass", "(", "createMOSLateOptimizationPass", "(", ")", ")", ";", "addPass", "(", "createMOSStaticStackAllocPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "MOS", "MOS", "MOS", "MOS", "MOS" ]

[]

[ "<s>", "InstructionCost", "AArch64TTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "auto", "*", "RetTy", "=", "ICA", ".", "getReturnType", "(", ")", ";", "switch", "(", "ICA", ".", "getID", "(", ")", ")", "{", "case", "Intrinsic", "::", "umin", ":", "case", "Intrinsic", "::", "umax", ":", "{", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "LT", ".", "second", "==", "MVT", "::", "v2i64", ")", "return", "LT", ".", "first", "*", "2", ";", "LLVM_FALLTHROUGH", ";", "}", "case", "Intrinsic", "::", "smin", ":", "case", "Intrinsic", "::", "smax", ":", "{", "static", "const", "auto", "ValidMinMaxTys", "=", "{", "MVT", "::", "v8i8", ",", "MVT", "::", "v16i8", ",", "MVT", "::", "v4i16", ",", "MVT", "::", "v8i16", ",", "MVT", "::", "v2i32", ",", "MVT", "::", "v4i32", "}", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "any_of", "(", "ValidMinMaxTys", ",", "[", "&", "LT", "]", "(", "MVT", "M", ")", "{", "return", "M", "==", "LT", ".", "second", ";", "}", ")", ")", "return", "LT", ".", "first", ";", "break", ";", "}", "case", "Intrinsic", "::", "sadd_sat", ":", "case", "Intrinsic", "::", "ssub_sat", ":", "case", "Intrinsic", "::", "uadd_sat", ":", "case", "Intrinsic", "::", "usub_sat", ":", "{", "static", "const", "auto", "ValidSatTys", "=", "{", "MVT", "::", "v8i8", ",", "MVT", "::", "v16i8", ",", "MVT", "::", "v4i16", ",", "MVT", "::", "v8i16", ",", "MVT", "::", "v2i32", ",", "MVT", "::", "v4i32", ",", "MVT", "::", "v2i64", "}", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "unsigned", "Instrs", "=", "LT", ".", "second", ".", "getScalarSizeInBits", "(", ")", "==", "RetTy", "->", "getScalarSizeInBits", "(", ")", "?", "1", ":", "4", ";", "if", "(", "any_of", "(", "ValidSatTys", ",", "[", "&", "LT", "]", "(", "MVT", "M", ")", "{", "return", "M", "==", "LT", ".", "second", ";", "}", ")", ")", "return", "LT", ".", "first", "*", "Instrs", ";", "break", ";", "}", "case", "Intrinsic", "::", "abs", ":", "{", "static", "const", "auto", "ValidAbsTys", "=", "{", "MVT", "::", "v8i8", ",", "MVT", "::", "v16i8", ",", "MVT", "::", "v4i16", ",", "MVT", "::", "v8i16", ",", "MVT", "::", "v2i32", ",", "MVT", "::", "v4i32", ",", "MVT", "::", "v2i64", "}", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "any_of", "(", "ValidAbsTys", ",", "[", "&", "LT", "]", "(", "MVT", "M", ")", "{", "return", "M", "==", "LT", ".", "second", ";", "}", ")", ")", "return", "LT", ".", "first", ";", "break", ";", "}", "case", "Intrinsic", "::", "experimental_stepvector", ":", "{", "InstructionCost", "Cost", "=", "1", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "LT", ".", "first", ">", "1", ")", "{", "Type", "*", "LegalVTy", "=", "EVT", "(", "LT", ".", "second", ")", ".", "getTypeForEVT", "(", "RetTy", "->", "getContext", "(", ")", ")", ";", "InstructionCost", "AddCost", "=", "getArithmeticInstrCost", "(", "Instruction", "::", "Add", ",", "LegalVTy", ",", "CostKind", ")", ";", "Cost", "+=", "AddCost", "*", "(", "LT", ".", "first", "-", "1", ")", ";", "}", "return", "Cost", ";", "}", "default", ":", "break", ";", "}", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "AArch64", "AArch64", "Intrinsic::umin", "Intrinsic::umax", "MVT::v2i64", "2", "Intrinsic::smin", "Intrinsic::smax", "MVT::v8i8", "MVT::v16i8", "MVT::v4i16", "MVT::v8i16", "MVT::v2i32", "MVT::v4i32", "Intrinsic::sadd_sat", "Intrinsic::ssub_sat", "Intrinsic::uadd_sat", "Intrinsic::usub_sat", "MVT::v8i8", "MVT::v16i8", "MVT::v4i16", "MVT::v8i16", "MVT::v2i32", "MVT::v4i32", "MVT::v2i64", "1", "4", "Intrinsic::abs", "MVT::v8i8", "MVT::v16i8", "MVT::v4i16", "MVT::v8i16", "MVT::v2i32", "MVT::v4i32", "MVT::v2i64", "Intrinsic::experimental_stepvector", "1", "1", "1" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "SIStackID", "::", "SGPR_SPILL", ")", ";", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "SIStackID::SGPR_SPILL", "AMDGPU::M0", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "static", "inline", "tree", "def_builtin_const", "(", "HOST_WIDE_INT", "mask", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "def_builtin", "(", "mask", ",", "name", ",", "tcode", ",", "code", ")", ";", "if", "(", "decl", ")", "TREE_READONLY", "(", "decl", ")", "=", "1", ";", "else", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "const_p", "=", "true", ";", "return", "decl", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "also", "marks", "the", "function", "as", "``", "const", "''", "." ]

[ "i386", "1" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "MSP430" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFPExtFree", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fpext", "operation", "is", "free", "(", "for", "instance", ",", "because", "single-precision", "floating-point", "numbers", "are", "implicitly", "extended", "to", "double-precision", ")", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "const", "SISubtarget", "*", "GCNTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "StringRef", "GPU", "=", "getGPUName", "(", "F", ")", ";", "StringRef", "FS", "=", "getFeatureString", "(", "F", ")", ";", "SmallString", "<", "128", ">", "SubtargetKey", "(", "GPU", ")", ";", "SubtargetKey", ".", "append", "(", "FS", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "SubtargetKey", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "SISubtarget", ">", "(", "TargetTriple", ",", "GPU", ",", "FS", ",", "*", "this", ")", ";", "}", "I", "->", "setScalarizeGlobalBehavior", "(", "ScalarizeGlobal", ")", ";", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "AMDGPU", "SI", "128", "SI" ]

[]

[ "<s>", "bool", "isIntrinsic", "(", ")", "const", "{", "return", "(", "Attributes", "&", "X86FMA3Intrinsic", ")", "!=", "0", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "group", "of", "FMA", "opcodes", "holds", "intrinsic", "opcodes", "." ]

[ "X86", "X86", "0" ]

[]

[ "<s>", "void", "rs6000_emit_le_vsx_move", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "!", "BYTES_BIG_ENDIAN", "&&", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "gpr_or_gpr_p", "(", "dest", ",", "source", ")", "&&", "(", "MEM_P", "(", "source", ")", "^", "MEM_P", "(", "dest", ")", ")", ")", ";", "if", "(", "MEM_P", "(", "source", ")", ")", "{", "gcc_assert", "(", "REG_P", "(", "dest", ")", "||", "GET_CODE", "(", "dest", ")", "==", "SUBREG", ")", ";", "rs6000_emit_le_vsx_load", "(", "dest", ",", "source", ",", "mode", ")", ";", "}", "else", "{", "if", "(", "!", "REG_P", "(", "source", ")", ")", "source", "=", "force_reg", "(", "mode", ",", "source", ")", ";", "rs6000_emit_le_vsx_store", "(", "dest", ",", "source", ",", "mode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "sequence", "representing", "a", "little-endian", "VSX", "load", "or", "store", ",", "moving", "data", "from", "SOURCE", "to", "DEST", "in", "mode", "MODE", ".", "This", "is", "done", "separately", "from", "rs6000_emit_move", "to", "ensure", "it", "is", "called", "only", "during", "expand", ".", "LE", "VSX", "loads", "and", "stores", "introduced", "later", "are", "handled", "with", "a", "split", ".", "The", "expand-time", "RTL", "generation", "allows", "us", "to", "optimize", "away", "redundant", "pairs", "of", "register-permutes", "." ]

[ "rs6000" ]

[]

[ "<s>", "InstrStage", "::", "FuncUnits", "HexagonInstrInfo", "::", "getUnits", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "InstrItineraryData", "&", "II", "=", "*", "Subtarget", ".", "getInstrItineraryData", "(", ")", ";", "const", "InstrStage", "&", "IS", "=", "*", "II", ".", "beginStage", "(", "MI", ".", "getDesc", "(", ")", ".", "getSchedClass", "(", ")", ")", ";", "return", "IS", ".", "getUnits", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "choice", "of", "FUs", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "virtual", "unsigned", "getNumFixupKinds", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "SystemZ", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "SystemZ", "SystemZ::NumTargetFixupKinds" ]

[]

[ "<s>", "static", "void", "ia64_asm_emit_except_personality", "(", "rtx", "personality", ")", "{", "fputs", "(", "\"\\t.personality\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "personality", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_EMIT_EXCEPT_PERSONALITY", "." ]

[ "ia64", "\"\\t.personality\\t\"" ]

[]

[ "<s>", "static", "void", "s390_register_info", "(", ")", "{", "int", "i", ";", "char", "clobbered_regs", "[", "32", "]", ";", "gcc_assert", "(", "!", "epilogue_completed", ")", ";", "if", "(", "reload_completed", ")", "s390_regs_ever_clobbered", "(", "clobbered_regs", ")", ";", "else", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "df_regs_ever_live_p", "(", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "clobbered_regs", "[", "i", "]", "&&", "!", "global_regs", "[", "i", "]", ";", "cfun_frame_layout", ".", "fpr_bitmap", "=", "0", ";", "cfun_frame_layout", ".", "high_fprs", "=", "0", ";", "for", "(", "i", "=", "FPR0_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", "&&", "!", "call_really_used_regs", "[", "i", "]", ")", "{", "cfun_set_fpr_save", "(", "i", ")", ";", "if", "(", "i", ">=", "FPR8_REGNUM", ")", "cfun_frame_layout", ".", "high_fprs", "++", ";", "}", "clobbered_regs", "[", "12", "]", "|=", "(", "(", "flag_pic", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "||", "(", "flag_split_stack", "&&", "cfun", "->", "stdarg", "&&", "(", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "has_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_REGNUM", ")", ")", ")", ")", ";", "clobbered_regs", "[", "BASE_REGNUM", "]", "|=", "(", "cfun", "->", "machine", "->", "base_reg", "&&", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "BASE_REGNUM", ")", ";", "clobbered_regs", "[", "HARD_FRAME_POINTER_REGNUM", "]", "|=", "!", "!", "frame_pointer_needed", ";", "clobbered_regs", "[", "RETURN_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun", "->", "machine", "->", "split_branches_pending_p", "||", "cfun_frame_layout", ".", "save_return_addr_p", "||", "crtl", "->", "calls_eh_return", ")", ";", "clobbered_regs", "[", "STACK_POINTER_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun_save_high_fprs_p", "||", "get_frame_size", "(", ")", ">", "0", "||", "(", "reload_completed", "&&", "cfun_frame_layout", ".", "frame_size", ">", "0", ")", "||", "cfun", "->", "calls_alloca", ")", ";", "memset", "(", "cfun_frame_layout", ".", "gpr_save_slots", ",", "SAVE_SLOT_NONE", ",", "16", ")", ";", "for", "(", "i", "=", "6", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", ")", "cfun_gpr_save_slot", "(", "i", ")", "=", "SAVE_SLOT_STACK", ";", "s390_register_info_stdarg_fpr", "(", ")", ";", "s390_register_info_gprtofpr", "(", ")", ";", "s390_register_info_set_ranges", "(", ")", ";", "s390_register_info_stdarg_gpr", "(", ")", ";", "}", "</s>" ]

[ "Fill", "cfun-", ">", "machine", "with", "info", "about", "register", "usage", "of", "current", "function", ".", "Return", "in", "CLOBBERED_REGS", "which", "GPRs", "are", "currently", "considered", "set", "." ]

[ "s390", "32", "0", "32", "0", "32", "0", "0", "12", "0", "0", "16", "6", "16" ]

[]

[ "<s>", "PreservedAnalyses", "AMDGPUUnifyMetadataPass", "::", "run", "(", "Module", "&", "M", ",", "ModuleAnalysisManager", "&", "AM", ")", "{", "return", "unifyMetadataImpl", "(", "M", ")", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "errs", "(", ")", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "nullptr", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6", ":", "XCore", "::", "LDAWSP_lru6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "XCore", "XCore", "XCore", "XCore", "0", "0", "1", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6", "XCore::LDAWSP_lru6", "XCore::SP" ]

[]

[ "<s>", "void", "final_prescan_insn", "(", "rtx", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n! at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "TARGET_RELAX", ")", "{", "rtx", "note", ";", "note", "=", "find_reg_note", "(", "insn", ",", "REG_LABEL", ",", "NULL_RTX", ")", ";", "if", "(", "note", ")", "{", "rtx", "pattern", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "pattern", ")", ")", "{", "case", "SET", ":", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "CALL", "&&", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SFUNC", ")", "{", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "note", ",", "0", ")", ")", ")", ";", "break", ";", "}", "case", "CALL", ":", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.uses %LL%d\\n\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "note", ",", "0", ")", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "sh", "\"\\n! at %04x\\n\"", "0", "0", "\"L\"", "0", "\"\\t.uses %LL%d\\n\"", "0" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createX86ISelDag", "(", "*", "this", ",", "OptLevel", ")", ")", ";", "PM", ".", "add", "(", "createX87FPRegKillInserterPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "X86", "X86", "X86" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "WebAssemblyDisassembler", "::", "onSymbolStart", "(", "StringRef", "Name", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "Size", "=", "0", ";", "if", "(", "Address", "==", "0", ")", "{", "int64_t", "FunctionCount", ";", "if", "(", "!", "nextLEB", "(", "FunctionCount", ",", "Bytes", ",", "Size", ",", "false", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "outs", "(", ")", "<<", "\" # \"", "<<", "FunctionCount", "<<", "\" functions in section.\"", ";", "}", "else", "{", "int64_t", "BodySize", ",", "LocalEntryCount", ";", "if", "(", "!", "nextLEB", "(", "BodySize", ",", "Bytes", ",", "Size", ",", "false", ")", "||", "!", "nextLEB", "(", "LocalEntryCount", ",", "Bytes", ",", "Size", ",", "false", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "LocalEntryCount", ")", "{", "outs", "(", ")", "<<", "\" .local \"", ";", "for", "(", "int64_t", "I", "=", "0", ";", "I", "<", "LocalEntryCount", ";", "I", "++", ")", "{", "int64_t", "Count", ",", "Type", ";", "if", "(", "!", "nextLEB", "(", "Count", ",", "Bytes", ",", "Size", ",", "false", ")", "||", "!", "nextLEB", "(", "Type", ",", "Bytes", ",", "Size", ",", "false", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "for", "(", "int64_t", "J", "=", "0", ";", "J", "<", "Count", ";", "J", "++", ")", "{", "if", "(", "I", "||", "J", ")", "outs", "(", ")", "<<", "\", \"", ";", "outs", "(", ")", "<<", "WebAssembly", "::", "anyTypeToString", "(", "Type", ")", ";", "}", "}", "}", "}", "outs", "(", ")", "<<", "\"\\n\"", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

[ "Used", "to", "perform", "separate", "target", "specific", "disassembly", "for", "a", "particular", "symbol", "." ]

[ "WebAssembly", "WebAssembly", "0", "0", "\" # \"", "\" functions in section.\"", "\" .local \"", "0", "0", "\", \"", "WebAssembly::anyTypeToString", "\"\\n\"" ]

[]

[ "<s>", "enum", "attr_cc", "compute_logical_op_cc", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "intval", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "&&", "register_operand", "(", "operands", "[", "1", "]", ",", "VOIDmode", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0x55555555", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "det", "=", "(", "code", "!=", "AND", ")", "?", "intval", ":", "~", "intval", ";", "const", "unsigned", "HOST_WIDE_INT", "b0", "=", "(", "det", ">>", "0", ")", "&", "0xff", ";", "const", "unsigned", "HOST_WIDE_INT", "b1", "=", "(", "det", ">>", "8", ")", "&", "0xff", ";", "const", "unsigned", "HOST_WIDE_INT", "w0", "=", "(", "det", ">>", "0", ")", "&", "0xffff", ";", "const", "unsigned", "HOST_WIDE_INT", "w1", "=", "(", "det", ">>", "16", ")", "&", "0xffff", ";", "int", "lower_half_easy_p", "=", "0", ";", "int", "upper_half_easy_p", "=", "0", ";", "enum", "attr_cc", "cc", "=", "CC_CLOBBER", ";", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "b0", "!=", "0", "&&", "b1", "!=", "0", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "break", ";", "case", "SImode", ":", "if", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "{", "lower_half_easy_p", "=", "(", "b0", "==", "0", "||", "b1", "==", "0", "||", "(", "code", "!=", "IOR", "&&", "w0", "==", "0xffff", ")", ")", ";", "upper_half_easy_p", "=", "(", "(", "code", "!=", "IOR", "&&", "w1", "==", "0xffff", ")", "||", "(", "code", "==", "AND", "&&", "w1", "==", "0xff00", ")", ")", ";", "}", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "w0", "!=", "0", "&&", "w1", "!=", "0", "&&", "!", "(", "lower_half_easy_p", "&&", "upper_half_easy_p", ")", "&&", "!", "(", "code", "==", "IOR", "&&", "w1", "==", "0xffff", "&&", "(", "w0", "&", "0x8000", ")", "!=", "0", "&&", "lower_half_easy_p", ")", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "else", "{", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "code", "==", "IOR", "&&", "w1", "==", "0xffff", "&&", "(", "w0", "&", "0x8000", ")", "!=", "0", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "cc", ";", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "a", "logical", "insn", "." ]

[ "h8300", "3", "2", "1", "2", "0x55555555", "0", "0xff", "8", "0xff", "0", "0xffff", "16", "0xffff", "0", "0", "0", "0", "0", "0", "0xffff", "0xffff", "0xff00", "0", "0", "0xffff", "0x8000", "0", "0xffff", "0x8000", "0" ]

[]

[ "<s>", "void", "gen_ashift_hi", "(", "int", "type", ",", "int", "n", ",", "rtx", "reg", ")", "{", "if", "(", "n", "<", "0", ")", "{", "if", "(", "type", "==", "ASHIFT", ")", "type", "=", "LSHIFTRT", ";", "else", "type", "=", "ASHIFT", ";", "n", "=", "-", "n", ";", "}", "switch", "(", "type", ")", "{", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "{", "int", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "offset", "=", "SUBREG_BYTE", "(", "reg", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "gen_ashift", "(", "type", ",", "n", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "offset", ")", ")", ";", "break", ";", "}", "case", "ASHIFT", ":", "emit_insn", "(", "gen_ashlhi3_k", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Same", "for", "HImode" ]

[ "sh", "0", "0" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "AArch64RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AArch64", "::", "GPR64RegClass", ";", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "Register", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::GPR64RegClass", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "static", "bool", "c6x_registers_update", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_cross", "cross", ";", "enum", "attr_dest_regfile", "destrf", ";", "int", "i", ",", "nops", ";", "rtx", "x", ";", "if", "(", "!", "reload_completed", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "false", ";", "reg_access_stall", "=", "false", ";", "memcpy", "(", "ss", ".", "tmp_reg_n_accesses", ",", "ss", ".", "reg_n_accesses", ",", "sizeof", "ss", ".", "tmp_reg_n_accesses", ")", ";", "memcpy", "(", "ss", ".", "tmp_reg_n_xaccesses", ",", "ss", ".", "reg_n_xaccesses", ",", "sizeof", "ss", ".", "tmp_reg_n_xaccesses", ")", ";", "extract_insn", "(", "insn", ")", ";", "cross", "=", "get_attr_cross", "(", "insn", ")", ";", "destrf", "=", "get_attr_dest_regfile", "(", "insn", ")", ";", "nops", "=", "recog_data", ".", "n_operands", ";", "x", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "COND_EXEC", ")", "{", "c6x_mark_reg_read", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ",", "false", ")", ";", "nops", "-=", "2", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nops", ";", "i", "++", ")", "{", "rtx", "op", "=", "recog_data", ".", "operand", "[", "i", "]", ";", "if", "(", "recog_data", ".", "operand_type", "[", "i", "]", "==", "OP_OUT", ")", "continue", ";", "if", "(", "REG_P", "(", "op", ")", ")", "{", "bool", "this_cross", "=", "cross", ";", "if", "(", "destrf", "==", "DEST_REGFILE_A", "&&", "A_REGNO_P", "(", "REGNO", "(", "op", ")", ")", ")", "this_cross", "=", "false", ";", "if", "(", "destrf", "==", "DEST_REGFILE_B", "&&", "B_REGNO_P", "(", "REGNO", "(", "op", ")", ")", ")", "this_cross", "=", "false", ";", "c6x_mark_reg_read", "(", "op", ",", "this_cross", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "op", ")", ")", "{", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "POST_INC", ":", "case", "PRE_INC", ":", "case", "POST_DEC", ":", "case", "PRE_DEC", ":", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "case", "REG", ":", "c6x_mark_reg_read", "(", "op", ",", "false", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "case", "PRE_MODIFY", ":", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", ")", ";", "case", "PLUS", ":", "c6x_mark_reg_read", "(", "XEXP", "(", "op", ",", "0", ")", ",", "false", ")", ";", "if", "(", "REG_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "c6x_mark_reg_read", "(", "XEXP", "(", "op", ",", "1", ")", ",", "false", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "c6x_mark_regno_read", "(", "REG_B14", ",", "false", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "!", "CONSTANT_P", "(", "op", ")", "&&", "strlen", "(", "recog_data", ".", "constraints", "[", "i", "]", ")", ">", "0", ")", "gcc_unreachable", "(", ")", ";", "}", "return", "reg_access_stall", ";", "}", "</s>" ]

[ "Update", "the", "register", "state", "information", "for", "an", "instruction", "whose", "body", "is", "X", ".", "Return", "true", "if", "the", "instruction", "has", "to", "be", "delayed", "until", "the", "next", "cycle", "." ]

[ "c6x", "0", "0", "0", "2", "0", "0", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Intrn", "=", "MF", ".", "getFunction", "(", ")", "->", "hasInternalLinkage", "(", ")", ";", "OutStreamer", ".", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", ".", "EmitCOFFSymbolStorageClass", "(", "Intrn", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", ".", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", ".", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionHeader", "(", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "ix86_expand_divmod_libfunc", "(", "rtx", "libfunc", ",", "machine_mode", "mode", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "*", "quot_p", ",", "rtx", "*", "rem_p", ")", "{", "rtx", "rem", "=", "assign_386_stack_local", "(", "mode", ",", "SLOT_TEMP", ")", ";", "rtx", "quot", "=", "emit_library_call_value", "(", "libfunc", ",", "NULL_RTX", ",", "LCT_NORMAL", ",", "mode", ",", "op0", ",", "mode", ",", "op1", ",", "mode", ",", "XEXP", "(", "rem", ",", "0", ")", ",", "Pmode", ")", ";", "*", "quot_p", "=", "quot", ";", "*", "rem_p", "=", "rem", ";", "}", "</s>" ]

[ "Generate", "call", "to", "__divmoddi4", "." ]

[ "i386", "0" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "STri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "STXri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "STFri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "STDFri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "STQFri", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Sparc", "Sparc", "SP::STri", "SP::STXri", "SP::STFri", "SP::STDFri", "SP::STQFri", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "static", "inline", "unsigned", "int", "rx_round_up", "(", "unsigned", "int", "value", ",", "unsigned", "int", "alignment", ")", "{", "alignment", "-=", "1", ";", "return", "(", "value", "+", "alignment", ")", "&", "(", "~", "alignment", ")", ";", "}", "</s>" ]

[ "Return", "VALUE", "rounded", "up", "to", "the", "next", "ALIGNMENT", "boundary", "." ]

[ "rx", "1" ]

[]

[ "<s>", "void", "PIC16TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "Results", ".", "push_back", "(", "ExpandGlobalAddress", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "ExternalSymbol", ":", "Results", ".", "push_back", "(", "ExpandExternalSymbol", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "STORE", ":", "Results", ".", "push_back", "(", "ExpandStore", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "PopulateResults", "(", "ExpandLoad", "(", "N", ",", "DAG", ")", ",", "Results", ")", ";", "return", ";", "case", "ISD", "::", "ADD", ":", "return", ";", "case", "ISD", "::", "FrameIndex", ":", "Results", ".", "push_back", "(", "ExpandFrameIndex", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "default", ":", "assert", "(", "0", "&&", "\"not implemented\"", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "PIC16", "PIC16", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::STORE", "ISD::LOAD", "ISD::ADD", "ISD::FrameIndex", "0", "\"not implemented\"" ]

[]

[ "<s>", "void", "CSKYInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "LD32W", ";", "}", "else", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "RESTORE_CARRY", ";", "CFI", "->", "setSpillsCR", "(", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "CSKY", "CSKY", "CSKY", "CSKY", "0", "CSKY::GPRRegClass", "CSKY::LD32W", "CSKY::CARRYRegClass", "CSKY::RESTORE_CARRY", "\"Unknown RegisterClass\"", "0" ]

[]

[ "<s>", "bool", "x86_maybe_negate_const_int", "(", "rtx", "*", "loc", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "val", ";", "if", "(", "!", "CONST_INT_P", "(", "*", "loc", ")", ")", "return", "false", ";", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "gcc_assert", "(", "x86_64_immediate_operand", "(", "*", "loc", ",", "mode", ")", ")", ";", "mode", "=", "SImode", ";", "break", ";", "case", "E_SImode", ":", "case", "E_HImode", ":", "case", "E_QImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "mode_signbit_p", "(", "mode", ",", "*", "loc", ")", ")", "return", "false", ";", "val", "=", "INTVAL", "(", "*", "loc", ")", ";", "if", "(", "(", "val", "<", "0", "&&", "val", "!=", "-", "128", ")", "||", "val", "==", "128", ")", "{", "*", "loc", "=", "GEN_INT", "(", "-", "val", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "profitable", ",", "negate", "(", "without", "causing", "overflow", ")", "integer", "constant", "of", "mode", "MODE", "at", "location", "LOC", ".", "Return", "true", "in", "this", "case", "." ]

[ "i386", "0", "128", "128" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "SparcFI", "=", "MF", "->", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "SparcFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "SP", "::", "IntRegsRegClass", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "get", "(", "SP", "::", "GETPCX", ")", ",", "GlobalBaseReg", ")", ";", "SparcFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "0", "SP::IntRegsRegClass", "SP::GETPCX", "Sparc" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIInstrInfo", "::", "getOpRegClass", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "MI", ".", "isVariadic", "(", ")", "||", "OpNo", ">=", "Desc", ".", "getNumOperands", "(", ")", "||", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", "==", "-", "1", ")", "{", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", "return", "MRI", ".", "getRegClass", "(", "Reg", ")", ";", "return", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "}", "unsigned", "RCID", "=", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", ";", "return", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "}", "</s>" ]

[ "Return", "the", "correct", "register", "class", "for", "OpNo", "." ]

[ "R600", "SI", "1" ]

[]

[ "<s>", "static", "rtx", "emit_memset", "(", "rtx", "destmem", ",", "rtx", "destptr", ",", "rtx", "promoted_val", ",", "HOST_WIDE_INT", "size_to_move", ")", "{", "rtx", "dst", "=", "destmem", ",", "adjust", ";", "enum", "insn_code", "code", ";", "machine_mode", "move_mode", ";", "int", "piece_size", ",", "i", ";", "move_mode", "=", "GET_MODE", "(", "promoted_val", ")", ";", "if", "(", "move_mode", "==", "VOIDmode", ")", "move_mode", "=", "QImode", ";", "if", "(", "size_to_move", "<", "GET_MODE_SIZE", "(", "move_mode", ")", ")", "{", "move_mode", "=", "mode_for_size", "(", "size_to_move", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "promoted_val", "=", "gen_lowpart", "(", "move_mode", ",", "promoted_val", ")", ";", "}", "piece_size", "=", "GET_MODE_SIZE", "(", "move_mode", ")", ";", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ";", "gcc_assert", "(", "code", "!=", "CODE_FOR_nothing", "&&", "promoted_val", "!=", "NULL_RTX", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "0", ")", ";", "gcc_assert", "(", "size_to_move", "%", "piece_size", "==", "0", ")", ";", "adjust", "=", "GEN_INT", "(", "piece_size", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size_to_move", ";", "i", "+=", "piece_size", ")", "{", "if", "(", "piece_size", "<=", "GET_MODE_SIZE", "(", "word_mode", ")", ")", "{", "emit_insn", "(", "gen_strset", "(", "destptr", ",", "dst", ",", "promoted_val", ")", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "piece_size", ")", ";", "continue", ";", "}", "emit_insn", "(", "GEN_FCN", "(", "code", ")", "(", "dst", ",", "promoted_val", ")", ")", ";", "emit_move_insn", "(", "destptr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "copy_rtx", "(", "destptr", ")", ",", "adjust", ")", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "piece_size", ")", ";", "}", "return", "dst", ";", "}", "</s>" ]

[ "This", "function", "emits", "moves", "to", "fill", "SIZE_TO_MOVE", "bytes", "starting", "from", "DESTMEM", "with", "value", "PROMOTED_VAL", ".", "SRC", "is", "passed", "by", "pointer", "to", "be", "updated", "on", "return", ".", "Return", "value", "is", "updated", "DST", "." ]

[ "i386", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "AArch64TTIImpl", "::", "shouldConsiderAddressTypePromotion", "(", "const", "Instruction", "&", "I", ",", "bool", "&", "AllowPromotionWithoutCommonHeader", ")", "{", "bool", "Considerable", "=", "false", ";", "AllowPromotionWithoutCommonHeader", "=", "false", ";", "if", "(", "!", "isa", "<", "SExtInst", ">", "(", "&", "I", ")", ")", "return", "false", ";", "Type", "*", "ConsideredSExtType", "=", "Type", "::", "getInt64Ty", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ")", ";", "if", "(", "I", ".", "getType", "(", ")", "!=", "ConsideredSExtType", ")", "return", "false", ";", "for", "(", "const", "User", "*", "U", ":", "I", ".", "users", "(", ")", ")", "{", "if", "(", "const", "GetElementPtrInst", "*", "GEPInst", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "U", ")", ")", "{", "Considerable", "=", "true", ";", "if", "(", "GEPInst", "->", "getNumOperands", "(", ")", ">", "2", ")", "{", "AllowPromotionWithoutCommonHeader", "=", "true", ";", "break", ";", "}", "}", "}", "return", "Considerable", ";", "}", "</s>" ]

[ "See", "if", "I", "should", "be", "considered", "for", "address", "type", "promotion", "." ]

[ "AArch64", "AArch64", "2" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "split", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "TfrLimitActive", ")", "{", "if", "(", "TfrCounter", ">=", "TfrLimit", ")", "return", "false", ";", "TfrCounter", "++", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nsplitting BB#\"", "<<", "MI", "->", "getParent", "(", ")", "->", "getNumber", "(", ")", "<<", "\": \"", "<<", "*", "MI", ")", ";", "MachineOperand", "&", "MD", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MP", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "assert", "(", "MD", ".", "isDef", "(", ")", ")", ";", "unsigned", "DR", "=", "MD", ".", "getReg", "(", ")", ",", "DSR", "=", "MD", ".", "getSubReg", "(", ")", ";", "if", "(", "MachineInstr", "*", "TfrT", "=", "genTfrFor", "(", "MI", "->", "getOperand", "(", "2", ")", ",", "DR", ",", "DSR", ",", "MP", ",", "true", ")", ")", "addInstrToLiveness", "(", "TfrT", ")", ";", "if", "(", "MachineInstr", "*", "TfrF", "=", "genTfrFor", "(", "MI", "->", "getOperand", "(", "3", ")", ",", "DR", ",", "DSR", ",", "MP", ",", "false", ")", ")", "addInstrToLiveness", "(", "TfrF", ")", ";", "removeInstrFromLiveness", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Split", "into", "substrings", "around", "the", "occurrences", "of", "a", "separator", "character", "." ]

[ "Hexagon", "Hexagon", "\"\\nsplitting BB#\"", "\": \"", "0", "1", "2", "3" ]

[]

[ "<s>", "static", "rtx", "nios2_expand_ldstio_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "const", "struct", "nios2_builtin_desc", "*", "d", ")", "{", "bool", "has_target_p", ";", "rtx", "addr", ",", "mem", ",", "val", ";", "struct", "expand_operand", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "machine_mode", "mode", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "addr", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "if", "(", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "allows_mem", ")", "{", "val", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "force_reg", "(", "mode", ",", "gen_int_mode", "(", "INTVAL", "(", "val", ")", ",", "mode", ")", ")", ";", "val", "=", "simplify_gen_subreg", "(", "mode", ",", "val", ",", "GET_MODE", "(", "val", ")", ",", "0", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "mem", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "val", ",", "mode", ")", ";", "has_target_p", "=", "false", ";", "}", "else", "{", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "mem", ",", "mode", ")", ";", "has_target_p", "=", "true", ";", "}", "return", "nios2_expand_builtin_insn", "(", "d", ",", "2", ",", "ops", ",", "has_target_p", ")", ";", "}", "</s>" ]

[ "Expand", "ldio/stio", "form", "load-store", "instruction", "builtins", "." ]

[ "nios2", "0", "0", "0", "1", "0", "0", "1", "0", "1", "2" ]

[]

[ "<s>", "int", "typemap_cmp", "(", "const", "void", "*", "key", ",", "const", "void", "*", "entry", ")", "{", "return", "strcmp", "(", "(", "const", "char", "*", ")", "key", ",", "(", "(", "const", "typemap", "*", ")", "entry", ")", "->", "key", ")", ";", "}", "</s>" ]

[ "Comparator", "for", "bsearch", "on", "the", "type", "map", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "SPUTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "CellSPU", "SPU" ]

[]

[ "<s>", "static", "void", "initialize_aarch64_code_model", "(", "void", ")", "{", "if", "(", "flag_pic", ")", "{", "switch", "(", "aarch64_cmodel_var", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "aarch64_cmodel", "=", "AARCH64_CMODEL_TINY_PIC", ";", "break", ";", "case", "AARCH64_CMODEL_SMALL", ":", "aarch64_cmodel", "=", "AARCH64_CMODEL_SMALL_PIC", ";", "break", ";", "case", "AARCH64_CMODEL_LARGE", ":", "sorry", "(", "\"code model %qs with -f%s\"", ",", "\"large\"", ",", "flag_pic", ">", "1", "?", "\"PIC\"", ":", "\"pic\"", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "aarch64_cmodel", "=", "aarch64_cmodel_var", ";", "}", "</s>" ]

[ "A", "checking", "mechanism", "for", "the", "implementation", "of", "the", "various", "code", "models", "." ]

[ "aarch64", "\"code model %qs with -f%s\"", "\"large\"", "1", "\"PIC\"", "\"pic\"" ]

[]

[ "<s>", "const", "char", "*", "ashrqi3_out", "(", "rtx", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "1", ":", "*", "len", "=", "1", ";", "return", "AS1", "(", "asr", ",", "%", "0", ")", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "4", ":", "*", "len", "=", "4", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "5", ":", "*", "len", "=", "5", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "6", ":", "*", "len", "=", "4", ";", "return", "(", "AS2", "(", "bst", ",", "%", "0", ",", "6", ")", "CR_TAB", "AS1", "(", "lsl", ",", "%", "0", ")", "CR_TAB", "AS2", "(", "sbc", ",", "%", "0", ",", "%", "0", ")", "CR_TAB", "AS2", "(", "bld", ",", "%", "0", ",", "0", ")", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "case", "7", ":", "*", "len", "=", "2", ";", "return", "(", "AS1", "(", "lsl", ",", "%", "0", ")", "CR_TAB", "AS2", "(", "sbc", ",", "%", "0", ",", "%", "0", ")", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error. Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "AS1", "(", "asr", ",", "%", "0", ")", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "8bit", "arithmetic", "shift", "right", "(", "(", "signed", "char", ")", "x", ">", ">", "i", ")" ]

[ "avr", "2", "2", "1", "1", "0", "2", "2", "0", "0", "3", "3", "0", "0", "0", "4", "4", "0", "0", "0", "0", "5", "5", "0", "0", "0", "0", "0", "6", "4", "0", "6", "0", "0", "0", "0", "0", "2", "8", "7", "2", "0", "0", "0", "2", "\"internal compiler error. Incorrect shift:\"", "0", "1", "\"\"" ]

[]

[ "<s>", "nvptx_function_end", "(", "STREAM", ")", "{", "\\", "\"%hr0\"", ",", "\"%outargs\"", ",", "\"%hfp\"", ",", "\"%punbuffer\"", ",", "\"%retval\"", ",", "\"%retval_in\"", ",", "\"%hr6\"", ",", "\"%hr7\"", ",", "\\", "\"%hr8\"", ",", "\"%hr9\"", ",", "\"%hr10\"", ",", "\"%hr11\"", ",", "\"%hr12\"", ",", "\"%hr13\"", ",", "\"%argp\"", ",", "\"%frame\"", "\\", "}", "do", "\\", "{", "\\", "char", "*", "__p", ";", "\\", "__p", "=", "stpcpy", "(", "&", "(", "LABEL", ")", "[", "1", "]", ",", "PREFIX", ")", ";", "\\", "(", "LABEL", ")", "[", "0", "]", "=", "'$'", ";", "\\", "sprint_ul", "(", "__p", ",", "(", "unsigned", "long", ")", "(", "NUM", ")", ")", ";", "\\", "}", "</s>" ]

[ "Terminate", "a", "function", "by", "writing", "a", "closing", "brace", "to", "FILE", "." ]

[ "nvptx", "\"%hr0\"", "\"%outargs\"", "\"%hfp\"", "\"%punbuffer\"", "\"%retval\"", "\"%retval_in\"", "\"%hr6\"", "\"%hr7\"", "\"%hr8\"", "\"%hr9\"", "\"%hr10\"", "\"%hr11\"", "\"%hr12\"", "\"%hr13\"", "\"%argp\"", "\"%frame\"", "1", "0" ]

[]

[ "<s>", "bool", "NVPTXDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "static_cast", "<", "const", "NVPTXSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "X86SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "X86SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "X86SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "X86SelectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "return", "X86SelectZExt", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "X86SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "case", "Instruction", "::", "Shl", ":", "return", "X86SelectShift", "(", "I", ")", ";", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "URem", ":", "return", "X86SelectDivRem", "(", "I", ")", ";", "case", "Instruction", "::", "Select", ":", "return", "X86SelectSelect", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "X86SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "X86SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "X86SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "X86SelectSIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "{", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getType", "(", ")", ")", ";", "if", "(", "DstVT", ".", "bitsGT", "(", "SrcVT", ")", ")", "return", "X86SelectZExt", "(", "I", ")", ";", "if", "(", "DstVT", ".", "bitsLT", "(", "SrcVT", ")", ")", "return", "X86SelectTrunc", "(", "I", ")", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "Reg", "==", "0", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "X86", "0", "0" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "output_addr_const", "(", "file", ",", "x", ")", ";", "if", "(", "small_data_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"@%s(%s)\"", ",", "SMALL_DATA_RELOC", ",", "reg_names", "[", "SMALL_DATA_REG", "]", ")", ";", "else", "gcc_assert", "(", "!", "TARGET_TOC", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "if", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "0", ")", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"(%s)\"", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "fprintf", "(", "file", ",", "\"lo16(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\")(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "toc_relative_expr_p", "(", "x", ",", "false", ")", ")", "{", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_base", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XVECEXP", "(", "tocrel_base", ",", "0", ",", "1", ")", ")", "]", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "rs6000", "\"0(%s)\"", "\"@%s(%s)\"", "0", "1", "0", "0", "\"%s,%s\"", "1", "0", "\"%s,%s\"", "0", "1", "0", "1", "\"(%s)\"", "1", "0", "0", "1", "\"lo16(\"", "1", "\")(%s)\"", "0", "0", "1", "1", "\"@l(%s)\"", "0", "\"@l(%s)\"", "0", "\"(%s)\"", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"DXIL Op Lowering\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "DirectX", "\"DXIL Op Lowering\"" ]

[]

[ "<s>", "TargetFrameLowering", "::", "DwarfFrameBase", "NVPTXFrameLowering", "::", "getDwarfFrameBase", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "{", "DwarfFrameBase", "::", "CFA", ",", "{", "0", "}", "}", ";", "}", "</s>" ]

[ "Return", "the", "frame", "base", "information", "to", "be", "encoded", "in", "the", "DWARF", "subprogram", "debug", "info", "." ]

[ "NVPTX", "NVPTX", "0" ]

[]

[ "<s>", "void", "SystemZOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "break", ";", "case", "KindToken", ":", "OS", "<<", "\"Token:\"", "<<", "getToken", "(", ")", ";", "break", ";", "case", "KindReg", ":", "OS", "<<", "\"Reg:\"", "<<", "SystemZInstPrinter", "::", "getRegisterName", "(", "getReg", "(", ")", ")", ";", "break", ";", "case", "KindImm", ":", "OS", "<<", "\"Imm:\"", ";", "printMCExpr", "(", "getImm", "(", ")", ",", "OS", ")", ";", "break", ";", "case", "KindImmTLS", ":", "OS", "<<", "\"ImmTLS:\"", ";", "printMCExpr", "(", "getImmTLS", "(", ")", ".", "Imm", ",", "OS", ")", ";", "if", "(", "getImmTLS", "(", ")", ".", "Sym", ")", "{", "OS", "<<", "\", \"", ";", "printMCExpr", "(", "getImmTLS", "(", ")", ".", "Sym", ",", "OS", ")", ";", "}", "break", ";", "case", "KindMem", ":", "{", "const", "MemOp", "&", "Op", "=", "getMem", "(", ")", ";", "OS", "<<", "\"Mem:\"", "<<", "*", "cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "Disp", ")", ";", "if", "(", "Op", ".", "Base", ")", "{", "OS", "<<", "\"(\"", ";", "if", "(", "Op", ".", "MemKind", "==", "BDLMem", ")", "OS", "<<", "*", "cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "Length", ".", "Imm", ")", "<<", "\",\"", ";", "else", "if", "(", "Op", ".", "MemKind", "==", "BDRMem", ")", "OS", "<<", "SystemZInstPrinter", "::", "getRegisterName", "(", "Op", ".", "Length", ".", "Reg", ")", "<<", "\",\"", ";", "if", "(", "Op", ".", "Index", ")", "OS", "<<", "SystemZInstPrinter", "::", "getRegisterName", "(", "Op", ".", "Index", ")", "<<", "\",\"", ";", "OS", "<<", "SystemZInstPrinter", "::", "getRegisterName", "(", "Op", ".", "Base", ")", ";", "OS", "<<", "\")\"", ";", "}", "break", ";", "}", "case", "KindInvalid", ":", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "SystemZ", "SystemZ", "\"Token:\"", "\"Reg:\"", "SystemZ", "\"Imm:\"", "\"ImmTLS:\"", "\", \"", "\"Mem:\"", "\"(\"", "\",\"", "SystemZ", "\",\"", "SystemZ", "\",\"", "SystemZ", "\")\"" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "reservedPrivateSegmentBufferReg", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "BaseIdx", "=", "alignDown", "(", "getMaxNumSGPRs", "(", "MF", ")", ",", "4", ")", "-", "4", ";", "unsigned", "BaseReg", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "BaseIdx", ")", ")", ";", "return", "getMatchingSuperReg", "(", "BaseReg", ",", "AMDGPU", "::", "sub0", ",", "&", "AMDGPU", "::", "SReg_128RegClass", ")", ";", "}", "</s>" ]

[ "Return", "the", "end", "register", "initially", "reserved", "for", "the", "scratch", "buffer", "in", "case", "spilling", "is", "needed", "." ]

[ "AMDGPU", "SI", "4", "4", "AMDGPU::SGPR_32RegClass", "AMDGPU::sub0", "AMDGPU::SReg_128RegClass" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "report_fatal_error", "(", "\"RISCVAsmBackend::relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "RISCV", "\"RISCVAsmBackend::relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "void", "ix86_avx_emit_vzeroupper", "(", "HARD_REG_SET", "regs_live", ")", "{", "int", "i", ";", "for", "(", "i", "=", "FIRST_SSE_REG", ";", "i", "<=", "LAST_SSE_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "regs_live", ",", "i", ")", "&&", "!", "call_used_regs", "[", "i", "]", ")", "return", ";", "if", "(", "TARGET_64BIT", ")", "for", "(", "i", "=", "FIRST_REX_SSE_REG", ";", "i", "<=", "LAST_REX_SSE_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "regs_live", ",", "i", ")", "&&", "!", "call_used_regs", "[", "i", "]", ")", "return", ";", "emit_insn", "(", "gen_avx_vzeroupper", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "vzeroupper", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "avr_addr_space_subset_p", "(", "addr_space_t", "subset", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "superset", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_SUBSET_P", "'", "." ]

[ "avr" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "1", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "BPF", "1" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MipsTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "const", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIRegisterInfo", "::", "getCFGStructurizerRegClass", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "case", "MVT", "::", "i32", ":", "return", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "}", "</s>" ]

[ "get", "the", "register", "class", "of", "the", "specified", "type", "to", "use", "in", "the", "CFGStructurizer" ]

[ "R600", "SI", "MVT::i32" ]

[]

[ "<s>", "virtual", "const", "MandarinInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Mandarin" ]

[]

[ "<s>", "bool", "legitimate_constant_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "TARGET_MACHO", "&&", "darwin_local_data_pic", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOTOFF", ":", "return", "TARGET_64BIT", ";", "case", "UNSPEC_TPOFF", ":", "case", "UNSPEC_NTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", ";", "case", "UNSPEC_DTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "break", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "i386", "0", "1", "0", "1", "0", "0", "0", "0" ]

[]