Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", ";", "}", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "CSKYSubtarget", "&", "CSKYSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPUName", ",", "StringRef", "TuneCPUName", ",", "StringRef", "FS", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "TuneCPUName", ".", "empty", "(", ")", ")", "TuneCPUName", "=", "CPUName", ";", "UseHardFloat", "=", "false", ";", "UseHardFloatABI", "=", "false", ";", "HasFPUv2SingleFloat", "=", "false", ";", "HasFPUv2DoubleFloat", "=", "false", ";", "HasFPUv3SingleFloat", "=", "false", ";", "HasFPUv3DoubleFloat", "=", "false", ";", "HasBTST16", "=", "false", ";", "HasJAVA", "=", "false", ";", "HasExtendLrw", "=", "false", ";", "HasDoloop", "=", "false", ";", "HasHighRegisters", "=", "false", ";", "HasE1", "=", "false", ";", "HasE2", "=", "false", ";", "Has2E3", "=", "false", ";", "HasMP", "=", "false", ";", "Has3E3r1", "=", "false", ";", "Has3r1E3r2", "=", "false", ";", "Has3r2E3r3", "=", "false", ";", "Has3E7", "=", "false", ";", "HasMP1E2", "=", "false", ";", "Has7E10", "=", "false", ";", "Has10E60", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "TuneCPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY", "\"generic\"" ]

[]

[ "<s>", "const", "MCExpr", "*", "PPCTargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "const", "MachineFunction", "*", "MF", ",", "unsigned", "JTI", ",", "MCContext", "&", "Ctx", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "TargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "MF", ",", "JTI", ",", "Ctx", ")", ";", "switch", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ")", "{", "case", "CodeModel", "::", "Default", ":", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Medium", ":", "return", "TargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "MF", ",", "JTI", ",", "Ctx", ")", ";", "default", ":", "return", "MCSymbolRefExpr", "::", "create", "(", "MF", "->", "getPICBaseSymbol", "(", ")", ",", "Ctx", ")", ";", "}", "}", "</s>" ]

[ "This", "returns", "the", "relocation", "base", "for", "the", "given", "PIC", "jumptable", ",", "the", "same", "as", "getPICJumpTableRelocBase", ",", "but", "as", "an", "MCExpr", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "bool", "mips_int_order_operand_ok_p", "(", "enum", "rtx_code", "code", ",", "rtx", "cmp1", ")", "{", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "GTU", ":", "return", "reg_or_0_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "GE", ":", "case", "GEU", ":", "return", "!", "TARGET_MIPS16", "&&", "cmp1", "==", "const1_rtx", ";", "case", "LT", ":", "case", "LTU", ":", "return", "arith_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "LE", ":", "return", "sle_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "LEU", ":", "return", "sleu_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "CMP1", "is", "a", "suitable", "second", "operand", "for", "integer", "ordering", "test", "CODE", ".", "See", "also", "the", "*", "sCC", "patterns", "in", "mips.md", "." ]

[ "mips" ]

[]

[ "<s>", "const", "WebAssemblyRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "isCheapToSpeculateCtlz", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "AArch64" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "SITargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "RMW", ")", "const", "{", "unsigned", "AS", "=", "RMW", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "NotAtomic", ";", "auto", "ReportUnsafeHWInst", "=", "[", "&", "]", "(", "TargetLowering", "::", "AtomicExpansionKind", "Kind", ")", "{", "OptimizationRemarkEmitter", "ORE", "(", "RMW", "->", "getFunction", "(", ")", ")", ";", "LLVMContext", "&", "Ctx", "=", "RMW", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "SmallVector", "<", "StringRef", ">", "SSNs", ";", "Ctx", ".", "getSyncScopeNames", "(", "SSNs", ")", ";", "auto", "MemScope", "=", "SSNs", "[", "RMW", "->", "getSyncScopeID", "(", ")", "]", ".", "empty", "(", ")", "?", "\"system\"", ":", "SSNs", "[", "RMW", "->", "getSyncScopeID", "(", ")", "]", ";", "ORE", ".", "emit", "(", "[", "&", "]", "(", ")", "{", "return", "OptimizationRemark", "(", "DEBUG_TYPE", ",", "\"Passed\"", ",", "RMW", ")", "<<", "\"Hardware instruction generated for atomic \"", "<<", "RMW", "->", "getOperationName", "(", "RMW", "->", "getOperation", "(", ")", ")", "<<", "\" operation at memory scope \"", "<<", "MemScope", "<<", "\" due to an unsafe request.\"", ";", "}", ")", ";", "return", "Kind", ";", "}", ";", "switch", "(", "RMW", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "FAdd", ":", "{", "Type", "*", "Ty", "=", "RMW", "->", "getType", "(", ")", ";", "if", "(", "Ty", "->", "isHalfTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "!", "Ty", "->", "isFloatTy", "(", ")", "&&", "(", "!", "Subtarget", "->", "hasGFX90AInsts", "(", ")", "||", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "if", "(", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "&&", "Subtarget", "->", "hasAtomicFaddInsts", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasGFX940Insts", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "!=", "\"true\"", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "if", "(", "Subtarget", "->", "hasGFX90AInsts", "(", ")", ")", "{", "if", "(", "Ty", "->", "isFloatTy", "(", ")", "&&", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "auto", "SSID", "=", "RMW", "->", "getSyncScopeID", "(", ")", ";", "if", "(", "SSID", "==", "SyncScope", "::", "System", "||", "SSID", "==", "RMW", "->", "getContext", "(", ")", ".", "getOrInsertSyncScopeID", "(", "\"one-as\"", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "RMW", "->", "use_empty", "(", ")", "?", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "Subtarget", "->", "hasLDSFPAtomicAdd", "(", ")", ")", "{", "if", "(", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "fpModeMatchesGlobalFPAtomicMode", "(", "RMW", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", "?", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "default", ":", "break", ";", "}", "return", "AMDGPUTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "RMW", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "AMDGPU", "SI", "AMDGPU", "\"system\"", "\"Passed\"", "\"Hardware instruction generated for atomic \"", "\" operation at memory scope \"", "\" due to an unsafe request.\"", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU", "SI", "SI", "SI", "\"one-as\"", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU" ]

[]

[ "<s>", "unsigned", "getEUsPerCU", "(", ")", "const", "{", "return", "AMDGPU", "::", "IsaInfo", "::", "getEUsPerCU", "(", "MCSubtargetInfo", "::", "getFeatureBits", "(", ")", ")", ";", "}", "</s>" ]

[ "Number", "of", "SIMDs/EUs", "(", "execution", "units", ")", "per", "``", "CU", "''", "(", "``", "compute", "unit", "''", ")", ",", "where", "the", "``", "CU", "''", "is", "the", "unit", "onto", "which", "workgroups", "are", "mapped", "." ]

[ "AMDGPU", "AMDGPU::IsaInfo" ]

[]

[ "<s>", "bool", "M68kTargetLowering", "::", "decomposeMulByConstant", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ",", "SDValue", "C", ")", "const", "{", "return", "VT", ".", "bitsLE", "(", "MVT", "::", "i32", ")", "||", "Subtarget", ".", "atLeastM68020", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "transform", "an", "integer", "multiplication-by-constant", "into", "simpler", "operations", "like", "shifts", "and", "adds", "." ]

[ "M68k", "M68k", "MVT::i32" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "getRegAllocationHints", "(", "Register", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "*", "MRI", "->", "getRegClass", "(", "VirtReg", ")", ";", "bool", "BaseImplRetVal", "=", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ",", "Matrix", ")", ";", "if", "(", "RC", ".", "getID", "(", ")", "!=", "X86", "::", "TILERegClassID", ")", "return", "BaseImplRetVal", ";", "ShapeT", "VirtShape", "=", "getTileShape", "(", "VirtReg", ",", "const_cast", "<", "VirtRegMap", "*", ">", "(", "VRM", ")", ",", "MRI", ")", ";", "auto", "AddHint", "=", "[", "&", "]", "(", "MCPhysReg", "PhysReg", ")", "{", "Register", "VReg", "=", "Matrix", "->", "getOneVReg", "(", "PhysReg", ")", ";", "if", "(", "VReg", "==", "MCRegister", "::", "NoRegister", ")", "{", "Hints", ".", "push_back", "(", "PhysReg", ")", ";", "return", ";", "}", "ShapeT", "PhysShape", "=", "getTileShape", "(", "VReg", ",", "const_cast", "<", "VirtRegMap", "*", ">", "(", "VRM", ")", ",", "MRI", ")", ";", "if", "(", "PhysShape", "==", "VirtShape", ")", "Hints", ".", "push_back", "(", "PhysReg", ")", ";", "}", ";", "SmallSet", "<", "MCPhysReg", ",", "4", ">", "CopyHints", ";", "CopyHints", ".", "insert", "(", "Hints", ".", "begin", "(", ")", ",", "Hints", ".", "end", "(", ")", ")", ";", "Hints", ".", "clear", "(", ")", ";", "for", "(", "auto", "Hint", ":", "CopyHints", ")", "{", "if", "(", "RC", ".", "contains", "(", "Hint", ")", "&&", "!", "MRI", "->", "isReserved", "(", "Hint", ")", ")", "AddHint", "(", "Hint", ")", ";", "}", "for", "(", "MCPhysReg", "PhysReg", ":", "Order", ")", "{", "if", "(", "!", "CopyHints", ".", "count", "(", "PhysReg", ")", "&&", "RC", ".", "contains", "(", "PhysReg", ")", "&&", "!", "MRI", "->", "isReserved", "(", "PhysReg", ")", ")", "AddHint", "(", "PhysReg", ")", ";", "}", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Hints for virtual register \"", "<<", "format_hex", "(", "VirtReg", ",", "8", ")", "<<", "\"\\n\"", ";", "for", "(", "auto", "Hint", ":", "Hints", ")", "{", "dbgs", "(", ")", "<<", "\"tmm\"", "<<", "Hint", "<<", "\",\"", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "X86", "X86", "X86::TILERegClassID", "4", "\"Hints for virtual register \"", "8", "\"\\n\"", "\"tmm\"", "\",\"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "return", "X86II", "::", "MO_COFFSTUB", ";", "}", "const", "Function", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "isTargetELF", "(", ")", ")", "{", "if", "(", "is64Bit", "(", ")", "&&", "F", "&&", "(", "CallingConv", "::", "X86_RegCall", "==", "F", "->", "getCallingConv", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "(", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "||", "(", "!", "F", "&&", "M", ".", "getRtLibUseGOT", "(", ")", ")", ")", "&&", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "!", "is64Bit", "(", ")", "&&", "!", "GV", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_PLT", ";", "}", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_COFFSTUB", "X86", "X86II::MO_GOTPCREL", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_PLT", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "lowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "lowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "lowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "lowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "lowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_DWARF_CFA", ":", "return", "lowerEH_DWARF_CFA", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "lowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Mips", "Mips", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SETCC", "ISD::VASTART", "ISD::VAARG", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::EH_DWARF_CFA", "ISD::FP_TO_SINT" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "BuildPairF64", ":", "ExpandBuildPairF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "ExpandExtractElementF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips::BuildPairF64", "Mips::ExtractElementF64" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "VReg", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "ArgInfo", "OrigArg", "{", "VReg", ",", "Val", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "if", "(", "!", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VReg", ")", ";", "}", ")", ")", "return", "false", ";", "OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "8", "X86" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "mbb", ":", "MF", ")", "{", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "for", "(", "MachineInstr", "&", "mi", ":", "mbb", ")", "{", "dbgs", "(", ")", "<<", "\">>>\"", "<<", "TII", "->", "getName", "(", "mi", ".", "getOpcode", "(", ")", ")", "<<", "\"\\n\"", ";", "}", "}", "}", "</s>" ]

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

[ "AVR", "\"\\n\"", "\">>>\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "PPCDispatchGroupSBHazardRecognizer", "::", "ShouldPreferAnother", "(", "SUnit", "*", "SU", ")", "{", "const", "MCInstrDesc", "*", "MCID", "=", "DAG", "->", "getInstrDesc", "(", "SU", ")", ";", "unsigned", "NSlots", ";", "if", "(", "MCID", "&&", "mustComeFirst", "(", "MCID", ",", "NSlots", ")", "&&", "CurSlots", ")", "return", "true", ";", "return", "ScoreboardHazardRecognizer", "::", "ShouldPreferAnother", "(", "SU", ")", ";", "}", "</s>" ]

[ "ShouldPreferAnother", "-", "This", "callback", "may", "be", "invoked", "if", "getHazardType", "returns", "NoHazard", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "unsigned", "MipsFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "(", "UnsupportedFPMode", ")", "?", "0", ":", "materializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "materializeGV", "(", "GV", ",", "VT", ")", ";", "else", "if", "(", "isa", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "materializeInt", "(", "C", ",", "VT", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

[ "Mips", "Mips", "0", "0", "0" ]

[]

[ "<s>", "void", "s390_register_target_pragmas", "(", "void", ")", "{", "targetm", ".", "resolve_overloaded_builtin", "=", "s390_resolve_overloaded_builtin", ";", "targetm", ".", "target_option", ".", "pragma_parse", "=", "s390_pragma_target_parse", ";", "}", "</s>" ]

[ "This", "is", "used", "to", "define", "the", "REGISTER_TARGET_PRAGMAS", "macro", "in", "s390.h", "." ]

[ "s390" ]

[]

[ "<s>", "void", "pdp10_build_machine_types", "(", ")", "{", "static", "int", "done", "=", "0", ";", "if", "(", "done", ")", "return", ";", "char6_signed_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char6_signed_type_node", ",", "6", ",", "0", ")", ";", "ggc_add_tree_root", "(", "&", "char6_signed_type_node", ",", "1", ")", ";", "char6_unsigned_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char6_unsigned_type_node", ",", "6", ",", "1", ")", ";", "ggc_add_tree_root", "(", "&", "char6_unsigned_type_node", ",", "1", ")", ";", "char7_signed_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char7_signed_type_node", ",", "7", ",", "0", ")", ";", "ggc_add_tree_root", "(", "&", "char7_signed_type_node", ",", "1", ")", ";", "char7_unsigned_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char7_unsigned_type_node", ",", "7", ",", "1", ")", ";", "ggc_add_tree_root", "(", "&", "char7_unsigned_type_node", ",", "1", ")", ";", "char8_signed_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char8_signed_type_node", ",", "8", ",", "0", ")", ";", "ggc_add_tree_root", "(", "&", "char8_signed_type_node", ",", "1", ")", ";", "char8_unsigned_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char8_unsigned_type_node", ",", "8", ",", "1", ")", ";", "ggc_add_tree_root", "(", "&", "char8_unsigned_type_node", ",", "1", ")", ";", "char9_signed_type_node", "=", "flag_signed_char", "?", "char_type_node", ":", "signed_char_type_node", ";", "ggc_add_tree_root", "(", "&", "char9_signed_type_node", ",", "1", ")", ";", "char9_unsigned_type_node", "=", "flag_signed_char", "?", "unsigned_char_type_node", ":", "char_type_node", ";", "ggc_add_tree_root", "(", "&", "char9_unsigned_type_node", ",", "1", ")", ";", "if", "(", "pdp10_char_bytesize", "!=", "9", ")", "{", "switch", "(", "pdp10_char_bytesize", ")", "{", "case", "6", ":", "case", "7", ":", "case", "8", ":", "case", "9", ":", "break", ";", "default", ":", "fprintf", "(", "stderr", ",", "\"Bad value for -mchar-bytesize: %s\\n\"", ",", "pdp10_string_bytesize", ")", ";", "exit", "(", "1", ")", ";", "}", "if", "(", "pdp10_char_bytesize", "!=", "9", ")", "{", "char_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "char_type_node", ",", "pdp10_char_bytesize", ",", "!", "flag_signed_char", ")", ";", "signed_char_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "signed_char_type_node", ",", "pdp10_char_bytesize", ",", "0", ")", ";", "unsigned_char_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "unsigned_char_type_node", ",", "pdp10_char_bytesize", ",", "1", ")", ";", "}", "}", "short16_integer_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "short16_integer_type_node", ",", "16", ",", "0", ")", ";", "ggc_add_tree_root", "(", "&", "short16_integer_type_node", ",", "1", ")", ";", "short16_unsigned_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "short16_unsigned_type_node", ",", "16", ",", "1", ")", ";", "ggc_add_tree_root", "(", "&", "short16_unsigned_type_node", ",", "1", ")", ";", "int32_integer_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "int32_integer_type_node", ",", "32", ",", "0", ")", ";", "ggc_add_tree_root", "(", "&", "int32_integer_type_node", ",", "1", ")", ";", "int32_unsigned_type_node", "=", "make_node", "(", "INTEGER_TYPE", ")", ";", "make_byte_type", "(", "int32_unsigned_type_node", ",", "32", ",", "1", ")", ";", "ggc_add_tree_root", "(", "&", "int32_unsigned_type_node", ",", "1", ")", ";", "done", "=", "1", ";", "}", "</s>" ]

[ "Build", "all", "PDP-10", "byte", "types", "." ]

[ "pdp10", "0", "6", "0", "1", "6", "1", "1", "7", "0", "1", "7", "1", "1", "8", "0", "1", "8", "1", "1", "1", "1", "9", "6", "7", "8", "9", "\"Bad value for -mchar-bytesize: %s\\n\"", "1", "9", "0", "1", "16", "0", "1", "16", "1", "1", "32", "0", "1", "32", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "indexable_address_p", "(", "rtx", "xfoo0", ",", "rtx", "xfoo1", ",", "machine_mode", "mode", ",", "bool", "strict", ")", "{", "if", "(", "!", "CONSTANT_ADDRESS_P", "(", "xfoo0", ")", ")", "return", "false", ";", "if", "(", "BASE_REGISTER_P", "(", "xfoo1", ",", "strict", ")", ")", "return", "!", "flag_pic", "||", "mode", "==", "QImode", ";", "if", "(", "flag_pic", "&&", "symbolic_operand", "(", "xfoo0", ",", "SImode", ")", ")", "return", "false", ";", "return", "reg_plus_index_p", "(", "xfoo1", ",", "mode", ",", "strict", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "xfoo0", "and", "xfoo1", "constitute", "a", "valid", "indexed", "address", "." ]

[ "vax" ]

[]

[ "<s>", "static", "void", "run", "(", "void", "*", "kernargs", ")", "{", "hsa_signal_t", "signal", ";", "XHSA", "(", "hsa_fns", ".", "hsa_signal_create_fn", "(", "1", ",", "0", ",", "NULL", ",", "&", "signal", ")", ",", "\"Create signal\"", ")", ";", "uint64_t", "index", "=", "hsa_fns", ".", "hsa_queue_load_write_index_relaxed_fn", "(", "queue", ")", ";", "const", "uint32_t", "queueMask", "=", "queue", "->", "size", "-", "1", ";", "hsa_kernel_dispatch_packet_t", "*", "dispatch_packet", "=", "&", "(", "(", "(", "hsa_kernel_dispatch_packet_t", "*", ")", "(", "queue", "->", "base_address", ")", ")", "[", "index", "&", "queueMask", "]", ")", ";", "dispatch_packet", "->", "setup", "|=", "3", "<<", "HSA_KERNEL_DISPATCH_PACKET_SETUP_DIMENSIONS", ";", "dispatch_packet", "->", "workgroup_size_x", "=", "(", "uint16_t", ")", "1", ";", "dispatch_packet", "->", "workgroup_size_y", "=", "(", "uint16_t", ")", "64", ";", "dispatch_packet", "->", "workgroup_size_z", "=", "(", "uint16_t", ")", "1", ";", "dispatch_packet", "->", "grid_size_x", "=", "1", ";", "dispatch_packet", "->", "grid_size_y", "=", "64", ";", "dispatch_packet", "->", "grid_size_z", "=", "1", ";", "dispatch_packet", "->", "completion_signal", "=", "signal", ";", "dispatch_packet", "->", "kernel_object", "=", "kernel", ";", "dispatch_packet", "->", "kernarg_address", "=", "(", "void", "*", ")", "kernargs", ";", "dispatch_packet", "->", "private_segment_size", "=", "private_segment_size", ";", "dispatch_packet", "->", "group_segment_size", "=", "group_segment_size", ";", "uint16_t", "header", "=", "0", ";", "header", "|=", "HSA_FENCE_SCOPE_SYSTEM", "<<", "HSA_PACKET_HEADER_ACQUIRE_FENCE_SCOPE", ";", "header", "|=", "HSA_FENCE_SCOPE_SYSTEM", "<<", "HSA_PACKET_HEADER_RELEASE_FENCE_SCOPE", ";", "header", "|=", "HSA_PACKET_TYPE_KERNEL_DISPATCH", "<<", "HSA_PACKET_HEADER_TYPE", ";", "__atomic_store_n", "(", "(", "uint32_t", "*", ")", "dispatch_packet", ",", "header", "|", "(", "dispatch_packet", "->", "setup", "<<", "16", ")", ",", "__ATOMIC_RELEASE", ")", ";", "if", "(", "debug", ")", "fprintf", "(", "stderr", ",", "\"Launch kernel\\n\"", ")", ";", "hsa_fns", ".", "hsa_queue_store_write_index_relaxed_fn", "(", "queue", ",", "index", "+", "1", ")", ";", "hsa_fns", ".", "hsa_signal_store_relaxed_fn", "(", "queue", "->", "doorbell_signal", ",", "index", ")", ";", "while", "(", "hsa_fns", ".", "hsa_signal_wait_relaxed_fn", "(", "signal", ",", "HSA_SIGNAL_CONDITION_LT", ",", "1", ",", "1000000", ",", "HSA_WAIT_STATE_ACTIVE", ")", "!=", "0", ")", "{", "usleep", "(", "10000", ")", ";", "gomp_print_output", "(", "kernargs", ",", "false", ")", ";", "}", "gomp_print_output", "(", "kernargs", ",", "true", ")", ";", "if", "(", "debug", ")", "fprintf", "(", "stderr", ",", "\"Kernel exited\\n\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_signal_destroy_fn", "(", "signal", ")", ",", "\"Clean up signal\"", ")", ";", "}", "</s>" ]

[ "Execute", "an", "already-loaded", "kernel", "on", "the", "device", "." ]

[ "gcn", "1", "0", "\"Create signal\"", "1", "3", "1", "64", "1", "1", "64", "1", "0", "16", "\"Launch kernel\\n\"", "1", "1", "1000000", "0", "10000", "\"Kernel exited\\n\"", "\"Clean up signal\"" ]

[]

[ "<s>", "virtual", "void", "initializePass", "(", ")", "{", "pushTTIStack", "(", "this", ")", ";", "}", "</s>" ]

[ "initializePass", "-", "This", "method", "may", "be", "overriden", "by", "immutable", "passes", "to", "allow", "them", "to", "perform", "various", "initialization", "actions", "they", "require", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "LC3MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "getSize", "(", ")", "!=", "2", ")", "{", "llvm_unreachable", "(", "\"Unexpected instruction size!\"", ")", ";", "}", "const", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "EmitConstant", "(", "Binary", ",", "Desc", ".", "getSize", "(", ")", ",", "OS", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "LC3", "LC3", "2", "\"Unexpected instruction size!\"" ]

[]

[ "<s>", "bool", "quad_address_p", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "bool", "strict", ")", "{", "rtx", "op0", ",", "op1", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "16", ")", "return", "false", ";", "if", "(", "legitimate_indirect_address_p", "(", "addr", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "!", "mode_supports_vsx_dform_quad", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", "return", "false", ";", "op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", "||", "!", "INT_REG_OK_FOR_BASE_P", "(", "op0", ",", "strict", ")", ")", "return", "false", ";", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", ")", "return", "false", ";", "return", "quad_address_offset_p", "(", "INTVAL", "(", "op1", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "ADDR", "is", "an", "acceptable", "address", "for", "a", "quad", "memory", "operation", "of", "mode", "MODE", "(", "either", "LQ/STQ", "for", "general", "purpose", "registers", ",", "or", "LXV/STXV", "for", "vector", "registers", "under", "ISA", "3.0", ".", "GPR_P", "is", "true", "if", "this", "address", "is", "intended", "for", "LQ/STQ", ".", "If", "it", "is", "false", ",", "the", "address", "is", "intended", "for", "the", "ISA", "3.0", "LXV/STXV", "instruction", "." ]

[ "rs6000", "16", "0", "1" ]

[]

[ "<s>", "unsigned", "AMDGPUPALMetadata", "::", "getType", "(", ")", "const", "{", "return", "BlobType", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "int", "ix86_issue_rate", "(", "void", ")", "{", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_PENTIUM", ":", "case", "PROCESSOR_BONNELL", ":", "case", "PROCESSOR_SILVERMONT", ":", "case", "PROCESSOR_KNL", ":", "case", "PROCESSOR_INTEL", ":", "case", "PROCESSOR_K6", ":", "case", "PROCESSOR_BTVER2", ":", "case", "PROCESSOR_PENTIUM4", ":", "case", "PROCESSOR_NOCONA", ":", "return", "2", ";", "case", "PROCESSOR_PENTIUMPRO", ":", "case", "PROCESSOR_ATHLON", ":", "case", "PROCESSOR_K8", ":", "case", "PROCESSOR_AMDFAM10", ":", "case", "PROCESSOR_GENERIC", ":", "case", "PROCESSOR_BTVER1", ":", "return", "3", ";", "case", "PROCESSOR_BDVER1", ":", "case", "PROCESSOR_BDVER2", ":", "case", "PROCESSOR_BDVER3", ":", "case", "PROCESSOR_BDVER4", ":", "case", "PROCESSOR_CORE2", ":", "case", "PROCESSOR_NEHALEM", ":", "case", "PROCESSOR_SANDYBRIDGE", ":", "case", "PROCESSOR_HASWELL", ":", "return", "4", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "instructions", "a", "cpu", "can", "issue", "." ]

[ "i386", "2", "3", "4", "1" ]

[]

[ "<s>", "bool", "OptimizeLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "DisableX86LEAOpt", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "MemOpMap", "LEAs", ";", "InstrPos", ".", "clear", "(", ")", ";", "findLEAs", "(", "MBB", ",", "LEAs", ")", ";", "if", "(", "LEAs", ".", "empty", "(", ")", ")", "continue", ";", "Changed", "|=", "removeRedundantLEAs", "(", "LEAs", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ")", "Changed", "|=", "removeRedundantAddrCalc", "(", "LEAs", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "RV16KAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "!", "Value", ")", "return", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "alignTo", "(", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ",", "8", ")", "/", "8", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "RV16K", "RV16K", "8", "8", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Fix Irreducible Control Flow\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Fix Irreducible Control Flow\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "auto", "ValSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "auto", "LocSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "ValSize", "<=", "64", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "LocSize", "<=", "64", "&&", "\"Unsupported location size\"", ")", ";", "markPhysRegUsed", "(", "PhysReg", ")", ";", "if", "(", "ValSize", "==", "LocSize", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "else", "{", "assert", "(", "ValSize", "<", "LocSize", "&&", "\"Extensions not supported\"", ")", ";", "auto", "PhysRegToVReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "LocSize", ")", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysRegToVReg", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "PhysRegToVReg", ")", ";", "}", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "ARM", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "64", "\"Unsupported value size\"", "64", "\"Unsupported location size\"", "\"Extensions not supported\"" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "uint64_t", "VESubtarget", "::", "getAdjustedFrameSize", "(", "uint64_t", "FrameSize", ")", "const", "{", "const", "VEFrameLowering", "*", "TFL", "=", "getFrameLowering", "(", ")", ";", "FrameSize", "+=", "getRsaSize", "(", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "TFL", "->", "getStackAlign", "(", ")", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

[ "Given", "a", "actual", "stack", "size", "as", "determined", "by", "FrameInfo", ",", "this", "function", "returns", "adjusted", "framesize", "which", "includes", "space", "for", "RSA", ",", "return", "address", ",", "and", "frame", "poitner", "." ]

[ "VE", "VE", "VE" ]

[]

[ "<s>", "Value", "*", "HexagonTargetLowering", "::", "emitStoreConditional", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "BasicBlock", "*", "BB", "=", "Builder", ".", "GetInsertBlock", "(", ")", ";", "Module", "*", "M", "=", "BB", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "Ty", "=", "Val", "->", "getType", "(", ")", ";", "unsigned", "SZ", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "Type", "*", "CastTy", "=", "Builder", ".", "getIntNTy", "(", "SZ", ")", ";", "assert", "(", "(", "SZ", "==", "32", "||", "SZ", "==", "64", ")", "&&", "\"Only 32/64-bit atomic stores supported\"", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "(", "SZ", "==", "32", ")", "?", "Intrinsic", "::", "hexagon_S2_storew_locked", ":", "Intrinsic", "::", "hexagon_S4_stored_locked", ";", "Function", "*", "Fn", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "IntID", ")", ";", "unsigned", "AS", "=", "Addr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "CastTy", "->", "getPointerTo", "(", "AS", ")", ")", ";", "Val", "=", "Builder", ".", "CreateBitCast", "(", "Val", ",", "CastTy", ")", ";", "Value", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "Fn", ",", "{", "Addr", ",", "Val", "}", ",", "\"stcx\"", ")", ";", "Value", "*", "Cmp", "=", "Builder", ".", "CreateICmpEQ", "(", "Call", ",", "Builder", ".", "getInt32", "(", "0", ")", ",", "\"\"", ")", ";", "Value", "*", "Ext", "=", "Builder", ".", "CreateZExt", "(", "Cmp", ",", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Ext", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "Hexagon", "Hexagon", "32", "64", "\"Only 32/64-bit atomic stores supported\"", "Intrinsic::ID", "32", "Intrinsic::hexagon_S2_storew_locked", "Intrinsic::hexagon_S4_stored_locked", "Intrinsic::getDeclaration", "\"stcx\"", "0", "\"\"" ]

[]

[ "<s>", "void", "aarch64_print_hint_for_extensions", "(", "const", "std", "::", "string", "&", "str", ")", "{", "auto_vec", "<", "const", "char", "*", ">", "candidates", ";", "aarch64_get_all_extension_candidates", "(", "&", "candidates", ")", ";", "char", "*", "s", ";", "const", "char", "*", "hint", "=", "candidates_list_and_hint", "(", "str", ".", "c_str", "(", ")", ",", "s", ",", "candidates", ")", ";", "if", "(", "hint", ")", "inform", "(", "input_location", ",", "\"valid arguments are: %s;\"", "\" did you mean %qs?\"", ",", "s", ",", "hint", ")", ";", "else", "inform", "(", "input_location", ",", "\"valid arguments are: %s;\"", ",", "s", ")", ";", "XDELETEVEC", "(", "s", ")", ";", "}", "</s>" ]

[ "Print", "a", "hint", "with", "a", "suggestion", "for", "an", "extension", "name", "that", "most", "closely", "resembles", "what", "the", "user", "passed", "in", "STR", "." ]

[ "aarch64", "\"valid arguments are: %s;\"", "\" did you mean %qs?\"", "\"valid arguments are: %s;\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MOSRegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "MOS", "::", "Imag8RegClass", ")", "return", "&", "MOS", "::", "GPRRegClass", ";", "if", "(", "RC", "==", "&", "MOS", "::", "YcRegClass", "||", "RC", "==", "&", "MOS", "::", "XYRegClass", ")", "return", "&", "MOS", "::", "AImag8RegClass", ";", "return", "RC", ";", "}", "</s>" ]

[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]

[ "MOS", "MOS", "MOS::Imag8RegClass", "MOS::GPRRegClass", "MOS::YcRegClass", "MOS::XYRegClass", "MOS::AImag8RegClass" ]

[]

[ "<s>", "static", "tree", "resolve_vec_splats", "(", "resolution", "*", "res", ",", "rs6000_gen_builtins", "fcode", ",", "vec", "<", "tree", ",", "va_gc", ">", "*", "arglist", ",", "unsigned", "nargs", ")", "{", "const", "char", "*", "name", ";", "name", "=", "fcode", "==", "RS6000_OVLD_VEC_SPLATS", "?", "\"vec_splats\"", ":", "\"vec_promote\"", ";", "if", "(", "fcode", "==", "RS6000_OVLD_VEC_SPLATS", "&&", "nargs", "!=", "1", ")", "{", "error", "(", "\"builtin %qs only accepts 1 argument\"", ",", "name", ")", ";", "*", "res", "=", "resolved", ";", "return", "error_mark_node", ";", "}", "if", "(", "fcode", "==", "RS6000_OVLD_VEC_PROMOTE", "&&", "nargs", "!=", "2", ")", "{", "error", "(", "\"builtin %qs only accepts 2 arguments\"", ",", "name", ")", ";", "*", "res", "=", "resolved", ";", "return", "error_mark_node", ";", "}", "if", "(", "fcode", "==", "RS6000_OVLD_VEC_PROMOTE", "&&", "!", "INTEGRAL_TYPE_P", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "1", "]", ")", ")", ")", "{", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "tree", "arg", "=", "(", "*", "arglist", ")", "[", "0", "]", ";", "tree", "type", "=", "TREE_TYPE", "(", "arg", ")", ";", "if", "(", "!", "SCALAR_FLOAT_TYPE_P", "(", "type", ")", "&&", "!", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "{", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "bool", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "int", "size", ";", "switch", "(", "TYPE_MODE", "(", "type", ")", ")", "{", "case", "E_TImode", ":", "type", "=", "unsigned_p", "?", "unsigned_V1TI_type_node", ":", "V1TI_type_node", ";", "size", "=", "1", ";", "break", ";", "case", "E_DImode", ":", "type", "=", "unsigned_p", "?", "unsigned_V2DI_type_node", ":", "V2DI_type_node", ";", "size", "=", "2", ";", "break", ";", "case", "E_SImode", ":", "type", "=", "unsigned_p", "?", "unsigned_V4SI_type_node", ":", "V4SI_type_node", ";", "size", "=", "4", ";", "break", ";", "case", "E_HImode", ":", "type", "=", "unsigned_p", "?", "unsigned_V8HI_type_node", ":", "V8HI_type_node", ";", "size", "=", "8", ";", "break", ";", "case", "E_QImode", ":", "type", "=", "unsigned_p", "?", "unsigned_V16QI_type_node", ":", "V16QI_type_node", ";", "size", "=", "16", ";", "break", ";", "case", "E_SFmode", ":", "type", "=", "V4SF_type_node", ";", "size", "=", "4", ";", "break", ";", "case", "E_DFmode", ":", "type", "=", "V2DF_type_node", ";", "size", "=", "2", ";", "break", ";", "default", ":", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "arg", "=", "save_expr", "(", "fold_convert", "(", "TREE_TYPE", "(", "type", ")", ",", "arg", ")", ")", ";", "vec", "<", "constructor_elt", ",", "va_gc", ">", "*", "vec", ";", "vec_alloc", "(", "vec", ",", "size", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "constructor_elt", "elt", "=", "{", "NULL_TREE", ",", "arg", "}", ";", "vec", "->", "quick_push", "(", "elt", ")", ";", "}", "*", "res", "=", "resolved", ";", "return", "build_constructor", "(", "type", ",", "vec", ")", ";", "}", "</s>" ]

[ "Resolve", "an", "overloaded", "vec_splats", "or", "vec_promote", "call", "and", "return", "a", "tree", "expression", "for", "the", "resolved", "call", "if", "successful", ".", "NARGS", "is", "the", "number", "of", "arguments", "to", "the", "call", ".", "ARGLIST", "contains", "the", "arguments", ".", "RES", "must", "be", "set", "to", "indicate", "the", "status", "of", "the", "resolution", "attempt", "." ]

[ "rs6000", "\"vec_splats\"", "\"vec_promote\"", "1", "\"builtin %qs only accepts 1 argument\"", "2", "\"builtin %qs only accepts 2 arguments\"", "1", "0", "1", "2", "4", "8", "16", "4", "2", "0" ]

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeFloatZero", "(", "const", "ConstantFP", "*", "CF", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "CF", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "unsigned", "Opc", "=", "0", ";", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "0", ";", "case", "MVT", "::", "f32", ":", "if", "(", "X86ScalarSSEf32", ")", "{", "Opc", "=", "X86", "::", "FsFLD0SS", ";", "RC", "=", "&", "X86", "::", "FR32RegClass", ";", "}", "else", "{", "Opc", "=", "X86", "::", "LD_Fp032", ";", "RC", "=", "&", "X86", "::", "RFP32RegClass", ";", "}", "break", ";", "case", "MVT", "::", "f64", ":", "if", "(", "X86ScalarSSEf64", ")", "{", "Opc", "=", "X86", "::", "FsFLD0SD", ";", "RC", "=", "&", "X86", "::", "FR64RegClass", ";", "}", "else", "{", "Opc", "=", "X86", "::", "LD_Fp064", ";", "RC", "=", "&", "X86", "::", "RFP64RegClass", ";", "}", "break", ";", "case", "MVT", "::", "f80", ":", "return", "0", ";", "}", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ";", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "the", "floating-point", "constant", "+0.0", "in", "a", "register", "using", "target-", "specific", "logic", "." ]

[ "X86", "X86", "0", "0", "0", "MVT::f32", "X86", "X86::FsFLD0SS", "X86::FR32RegClass", "X86::LD_Fp032", "X86::RFP32RegClass", "MVT::f64", "X86", "X86::FsFLD0SD", "X86::FR64RegClass", "X86::LD_Fp064", "X86::RFP64RegClass", "MVT::f80", "0" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "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", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "SlotAlign", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "ModRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_ctr", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxQRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrq_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxVRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrv_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxWRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrw_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::L2_loadri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::L2_loadrd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::LDriw_pred", "0", "Hexagon::ModRegsRegClass", "Hexagon::LDriw_ctr", "0", "Hexagon::HvxQRRegClass", "Hexagon::PS_vloadrq_ai", "0", "Hexagon::HvxVRRegClass", "Hexagon::PS_vloadrv_ai", "0", "Hexagon::HvxWRRegClass", "Hexagon::PS_vloadrw_ai", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "int", "m32c_eh_return_data_regno", "(", "int", "n", ")", "{", "switch", "(", "n", ")", "{", "case", "0", ":", "return", "MEM0_REGNO", ";", "case", "1", ":", "return", "MEM0_REGNO", "+", "4", ";", "default", ":", "return", "INVALID_REGNUM", ";", "}", "}", "</s>" ]

[ "Implements", "EH_RETURN_DATA_REGNO", ".", "Choose", "registers", "able", "to", "hold", "pointers", "." ]

[ "m32c", "0", "1", "4" ]

[]

[ "<s>", "bool", "IA64AsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "printModuleLevelGV", "(", "I", ")", ";", "O", "<<", "\"\\n\\n// br.call targets referenced (and not defined) above: \\n\"", ";", "for", "(", "std", "::", "set", "<", "std", "::", "string", ">", "::", "iterator", "i", "=", "ExternalFunctionNames", ".", "begin", "(", ")", ",", "e", "=", "ExternalFunctionNames", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "O", "<<", "\"\\t.global \"", "<<", "*", "i", "<<", "\"\\n\\t.type \"", "<<", "*", "i", "<<", "\", @function\\n\"", ";", "}", "O", "<<", "\"\\n\\n\"", ";", "O", "<<", "\"\\n\\n// (external) symbols referenced (and not defined) above: \\n\"", ";", "for", "(", "std", "::", "set", "<", "std", "::", "string", ">", "::", "iterator", "i", "=", "ExternalObjectNames", ".", "begin", "(", ")", ",", "e", "=", "ExternalObjectNames", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "O", "<<", "\"\\t.global \"", "<<", "*", "i", "<<", "\"\\n\\t.type \"", "<<", "*", "i", "<<", "\", @object\\n\"", ";", "}", "O", "<<", "\"\\n\\n\"", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "IA64", "IA64", "\"\\n\\n// br.call targets referenced (and not defined) above: \\n\"", "\"\\t.global \"", "\"\\n\\t.type \"", "\", @function\\n\"", "\"\\n\\n\"", "\"\\n\\n// (external) symbols referenced (and not defined) above: \\n\"", "\"\\t.global \"", "\"\\n\\t.type \"", "\", @object\\n\"", "\"\\n\\n\"" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "SystemZII", "::", "Branch", "Branch", "(", "getBranchInfo", "(", "*", "I", ")", ")", ";", "if", "(", "!", "Branch", ".", "Target", "->", "isMBB", "(", ")", ")", "return", "true", ";", "if", "(", "Branch", ".", "Type", "!=", "SystemZII", "::", "BranchNormal", ")", "return", "true", ";", "if", "(", "Branch", ".", "CCMask", "==", "SystemZ", "::", "CCMASK_ANY", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "Branch", ".", "Target", "->", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "Branch", ".", "Target", "->", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "Branch", ".", "Target", "->", "getMBB", "(", ")", ";", "continue", ";", "}", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "Branch", ".", "Target", "->", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Branch", ".", "CCValid", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Branch", ".", "CCMask", ")", ")", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "TBB", "&&", "\"Should have seen a conditional branch\"", ")", ";", "if", "(", "TBB", "!=", "Branch", ".", "Target", "->", "getMBB", "(", ")", ")", "return", "true", ";", "unsigned", "OldCCValid", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "OldCCMask", "=", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ";", "if", "(", "OldCCValid", "==", "Branch", ".", "CCValid", "&&", "OldCCMask", "==", "Branch", ".", "CCMask", ")", "continue", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "SystemZ", "SystemZ", "SystemZII::Branch", "SystemZII::BranchNormal", "SystemZ::CCMASK_ANY", "2", "\"Should have seen a conditional branch\"", "0", "1" ]

[]

[ "<s>", "bool", "HexagonOptimizeSZextends", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "unsigned", "Idx", "=", "1", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "F", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", ".", "getType", "(", ")", ")", ")", "{", "for", "(", "auto", "UI", "=", "Arg", ".", "use_begin", "(", ")", ";", "UI", "!=", "Arg", ".", "use_end", "(", ")", ";", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "*", "UI", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "*", "UI", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "&", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "++", "UI", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "&", "F", ".", "getEntryBlock", "(", ")", ".", "front", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "++", "UI", ";", "}", "}", "}", "}", "++", "Idx", ";", "}", "for", "(", "auto", "&", "B", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "B", ")", "{", "BinaryOperator", "*", "Ashr", "=", "dyn_cast", "<", "BinaryOperator", ">", "(", "&", "I", ")", ";", "if", "(", "!", "(", "Ashr", "&&", "Ashr", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "AShr", ")", ")", "continue", ";", "Value", "*", "AshrOp1", "=", "Ashr", "->", "getOperand", "(", "1", ")", ";", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "AshrOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "Instruction", "*", "Shl", "=", "dyn_cast", "<", "Instruction", ">", "(", "Ashr", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "!", "(", "Shl", "&&", "Shl", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", ")", "continue", ";", "Value", "*", "Intr", "=", "Shl", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "ShlOp1", "=", "Shl", "->", "getOperand", "(", "1", ")", ";", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "ShlOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "if", "(", "IntrinsicInst", "*", "I", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "Intr", ")", ")", "{", "if", "(", "!", "intrinsicAlreadySextended", "(", "I", "->", "getIntrinsicID", "(", ")", ")", ")", "continue", ";", "for", "(", "auto", "UI", "=", "Ashr", "->", "user_begin", "(", ")", ",", "UE", "=", "Ashr", "->", "user_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "const", "Use", "&", "TheUse", "=", "UI", ".", "getUse", "(", ")", ";", "if", "(", "Instruction", "*", "J", "=", "dyn_cast", "<", "Instruction", ">", "(", "TheUse", ".", "getUser", "(", ")", ")", ")", "{", "J", "->", "replaceUsesOfWith", "(", "Ashr", ",", "I", ")", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "Hexagon", "Hexagon", "1", "1", "16", "0", "0", "1", "16" ]

[]

[ "<s>", "rtx", "legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "constant_term", "=", "const0_rtx", ";", "if", "(", "TLS_SYMBOLIC_CONST", "(", "x", ")", ")", "{", "x", "=", "legitimize_tls_address", "(", "x", ",", "0", ")", ";", "if", "(", "legitimate_address_p", "(", "mode", ",", "x", ",", "FALSE", ")", ")", "return", "x", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "if", "(", "SYMBOLIC_CONST", "(", "x", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "(", "SYMBOLIC_CONST", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "SYMBOLIC_CONST", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", ")", "x", "=", "legitimize_pic_address", "(", "x", ",", "0", ")", ";", "if", "(", "legitimate_address_p", "(", "mode", ",", "x", ",", "FALSE", ")", ")", "return", "x", ";", "}", "x", "=", "eliminate_constant_term", "(", "x", ",", "&", "constant_term", ")", ";", "if", "(", "GET_CODE", "(", "constant_term", ")", "==", "CONST_INT", "&&", "!", "TARGET_LONG_DISPLACEMENT", "&&", "!", "DISP_IN_RANGE", "(", "INTVAL", "(", "constant_term", ")", ")", "&&", "!", "(", "REG_P", "(", "x", ")", "&&", "REGNO_PTR_FRAME_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", "{", "HOST_WIDE_INT", "lower", "=", "INTVAL", "(", "constant_term", ")", "&", "0xfff", ";", "HOST_WIDE_INT", "upper", "=", "INTVAL", "(", "constant_term", ")", "^", "lower", ";", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "val", "=", "force_operand", "(", "GEN_INT", "(", "upper", ")", ",", "temp", ")", ";", "if", "(", "val", "!=", "temp", ")", "emit_move_insn", "(", "temp", ",", "val", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "x", ",", "temp", ")", ";", "constant_term", "=", "GEN_INT", "(", "lower", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", ")", "{", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "val", "=", "force_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "temp", ")", ";", "if", "(", "val", "!=", "temp", ")", "emit_move_insn", "(", "temp", ",", "val", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ",", "temp", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "REG", ")", "{", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "val", "=", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "temp", ")", ";", "if", "(", "val", "!=", "temp", ")", "emit_move_insn", "(", "temp", ",", "val", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "}", "if", "(", "constant_term", "!=", "const0_rtx", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "x", ",", "constant_term", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "X", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "the", "mode", "of", "the", "operand", "pointed", "to", "by", "X", "." ]

[ "s390", "0", "0", "1", "0", "0xfff", "0", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "void", "ix86_output_indirect_branch_via_push", "(", "rtx", "call_op", ",", "const", "char", "*", "xasm", ",", "bool", "sibcall_p", ")", "{", "char", "thunk_name_buf", "[", "32", "]", ";", "char", "*", "thunk_name", ";", "char", "push_buf", "[", "64", "]", ";", "enum", "indirect_thunk_prefix", "need_prefix", "=", "indirect_thunk_need_prefix", "(", "current_output_insn", ")", ";", "int", "regno", "=", "-", "1", ";", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "!=", "indirect_branch_thunk_inline", ")", "{", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk", ")", "indirect_thunk_needed", "=", "true", ";", "indirect_thunk_name", "(", "thunk_name_buf", ",", "regno", ",", "need_prefix", ",", "false", ")", ";", "thunk_name", "=", "thunk_name_buf", ";", "}", "else", "thunk_name", "=", "NULL", ";", "snprintf", "(", "push_buf", ",", "sizeof", "(", "push_buf", ")", ",", "\"push{%c}\\t%s\"", ",", "TARGET_64BIT", "?", "'q'", ":", "'l'", ",", "xasm", ")", ";", "if", "(", "sibcall_p", ")", "{", "output_asm_insn", "(", "push_buf", ",", "&", "call_op", ")", ";", "if", "(", "thunk_name", "!=", "NULL", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "else", "output_indirect_thunk", "(", "regno", ")", ";", "}", "else", "{", "char", "indirectlabel1", "[", "32", "]", ";", "char", "indirectlabel2", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel1", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel2", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "fputs", "(", "\"\\tjmp\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "if", "(", "MEM_P", "(", "call_op", ")", ")", "{", "struct", "ix86_address", "parts", ";", "rtx", "addr", "=", "XEXP", "(", "call_op", ",", "0", ")", ";", "if", "(", "ix86_decompose_address", "(", "addr", ",", "&", "parts", ")", "&&", "parts", ".", "base", "==", "stack_pointer_rtx", ")", "{", "if", "(", "parts", ".", "index", ")", "{", "addr", "=", "gen_rtx_MULT", "(", "Pmode", ",", "parts", ".", "index", ",", "GEN_INT", "(", "parts", ".", "scale", ")", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ";", "}", "else", "addr", "=", "stack_pointer_rtx", ";", "rtx", "disp", ";", "if", "(", "parts", ".", "disp", "!=", "NULL_RTX", ")", "disp", "=", "plus_constant", "(", "Pmode", ",", "parts", ".", "disp", ",", "UNITS_PER_WORD", ")", ";", "else", "disp", "=", "GEN_INT", "(", "UNITS_PER_WORD", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "disp", ")", ";", "call_op", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "call_op", ")", ",", "addr", ")", ";", "}", "}", "output_asm_insn", "(", "push_buf", ",", "&", "call_op", ")", ";", "if", "(", "thunk_name", "!=", "NULL", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "else", "output_indirect_thunk", "(", "regno", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputs", "(", "\"\\tcall\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "}", "</s>" ]

[ "Output", "indirect", "branch", "via", "a", "call", "and", "return", "thunk", ".", "CALL_OP", "is", "the", "branch", "target", ".", "XASM", "is", "the", "assembly", "template", "for", "CALL_OP", ".", "Branch", "is", "a", "tail", "call", "if", "SIBCALL_P", "is", "true", ".", "A", "normal", "call", "is", "converted", "to", ":", "jmp", "L2", "L1", ":", "push", "CALL_OP", "jmp", "__x86_indirect_thunk", "L2", ":", "call", "L1", "and", "a", "tail", "call", "is", "converted", "to", ":", "push", "CALL_OP", "jmp", "__x86_indirect_thunk" ]

[ "i386", "32", "64", "1", "\"push{%c}\\t%s\"", "\"\\tjmp\\t%s\\n\"", "32", "32", "\"\\tjmp\\t\"", "0", "\"\\tjmp\\t%s\\n\"", "\"\\tcall\\t\"" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SP", "::", "RETL", "&&", "\"Can only put epilog before 'retl' instruction!\"", ")", ";", "if", "(", "!", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "RESTORErr", ")", ",", "SP", "::", "G0", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ";", "return", ";", "}", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "NumBytes", "=", "SubTarget", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SP", "::", "ADDrr", ",", "SP", "::", "ADDri", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::RETL", "\"Can only put epilog before 'retl' instruction!\"", "SP::RESTORErr", "SP::G0", "SP::G0", "SP::G0", "0", "SP", "SP::ADDrr", "SP::ADDri" ]

[]

[ "<s>", "static", "ds_t", "ia64_get_insn_spec_ds", "(", "rtx_insn", "*", "insn", ")", "{", "int", "code", "=", "get_insn_spec_code", "(", "insn", ")", ";", "switch", "(", "code", ")", "{", "case", "UNSPEC_LDA", ":", "return", "BEGIN_DATA", ";", "case", "UNSPEC_LDS", ":", "case", "UNSPEC_LDS_A", ":", "return", "BEGIN_CONTROL", ";", "case", "UNSPEC_LDSA", ":", "return", "BEGIN_DATA", "|", "BEGIN_CONTROL", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "If", "INSN", "is", "a", "speculative", "load", ",", "return", "a", "ds", "with", "the", "speculation", "types", ".", "Otherwise", "[", "if", "INSN", "is", "a", "normal", "instruction", "]", "return", "0", "." ]

[ "ia64", "0" ]

[]

[ "<s>", "void", "WebAssemblyCFGStackify", "::", "releaseMemory", "(", ")", "{", "ScopeTops", ".", "clear", "(", ")", ";", "BeginToEnd", ".", "clear", "(", ")", ";", "EndToBegin", ".", "clear", "(", ")", ";", "TryToEHPad", ".", "clear", "(", ")", ";", "EHPadToTry", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "releaseMemory", "(", ")", "-", "This", "member", "can", "be", "implemented", "by", "a", "pass", "if", "it", "wants", "to", "be", "able", "to", "release", "its", "memory", "when", "it", "is", "no", "longer", "needed", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "mips_unsigned_immediate_p", "(", "unsigned", "HOST_WIDE_INT", "x", ",", "int", "bits", ",", "int", "shift", "=", "0", ")", "{", "return", "(", "x", "&", "(", "(", "1", "<<", "shift", ")", "-", "1", ")", ")", "==", "0", "&&", "x", "<", "(", "(", "unsigned", ")", "1", "<<", "(", "shift", "+", "bits", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "fits", "within", "an", "unsigned", "field", "of", "BITS", "bits", "that", "is", "shifted", "left", "SHIFT", "bits", "before", "being", "used", "." ]

[ "mips", "0", "1", "1", "0", "1" ]

[]

[ "<s>", "static", "void", "csky_function_arg_advance", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "*", "reg", "=", "&", "pcum", "->", "reg", ";", "machine_mode", "mode", "=", "arg", ".", "mode", ";", "int", "param_size", "=", "csky_num_arg_regs", "(", "mode", ",", "arg", ".", "type", ",", "pcum", "->", "is_stdarg", ")", ";", "int", "param_regs_nums", "=", "CSKY_NPARM_REGS", ";", "if", "(", "FUNCTION_VARG_MODE_P", "(", "mode", ")", "&&", "!", "pcum", "->", "is_stdarg", ")", "{", "reg", "=", "&", "pcum", "->", "freg", ";", "param_regs_nums", "=", "CSKY_NPARM_FREGS", ";", "}", "if", "(", "*", "reg", "+", "param_size", ">", "param_regs_nums", ")", "*", "reg", "=", "param_regs_nums", ";", "else", "*", "reg", "+=", "param_size", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "csky" ]

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "const", "uint16_t", "Thumb1_16bitNopEncoding", "=", "0x46c0", ";", "const", "uint16_t", "Thumb2_16bitNopEncoding", "=", "0xbf00", ";", "const", "uint32_t", "ARMv4_NopEncoding", "=", "0xe1a00000", ";", "const", "uint32_t", "ARMv6T2_NopEncoding", "=", "0xe320f000", ";", "if", "(", "isThumb", "(", ")", ")", "{", "const", "uint16_t", "nopEncoding", "=", "hasNOP", "(", ")", "?", "Thumb2_16bitNopEncoding", ":", "Thumb1_16bitNopEncoding", ";", "uint64_t", "NumNops", "=", "Count", "/", "2", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write16", "(", "nopEncoding", ")", ";", "if", "(", "Count", "&", "1", ")", "OW", "->", "Write8", "(", "0", ")", ";", "return", "true", ";", "}", "const", "uint32_t", "nopEncoding", "=", "hasNOP", "(", ")", "?", "ARMv6T2_NopEncoding", ":", "ARMv4_NopEncoding", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "nopEncoding", ")", ";", "switch", "(", "Count", "%", "4", ")", "{", "default", ":", "break", ";", "case", "1", ":", "OW", "->", "Write8", "(", "0", ")", ";", "break", ";", "case", "2", ":", "OW", "->", "Write16", "(", "0", ")", ";", "break", ";", "case", "3", ":", "OW", "->", "Write16", "(", "0", ")", ";", "OW", "->", "Write8", "(", "0xa0", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "ARM", "ARM", "0x46c0", "0xbf00", "ARM", "0xe1a00000", "ARM", "0xe320f000", "2", "0", "1", "0", "ARM", "ARM", "4", "0", "4", "1", "0", "2", "0", "3", "0", "0xa0" ]

[]

[ "<s>", "static", "rtx", "extract_sfunc_addr", "(", "rtx", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "const", "int", "len", "=", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "rtx", "part", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "part", ")", "==", "USE", "&&", "GET_MODE", "(", "XEXP", "(", "part", ",", "0", ")", ")", "==", "Pmode", "&&", "GENERAL_REGISTER_P", "(", "true_regnum", "(", "XEXP", "(", "part", ",", "0", ")", ")", ")", ")", "return", "XEXP", "(", "part", ",", "0", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", "==", "UNSPEC_VOLATILE", ")", ";", "return", "XVECEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ",", "0", ",", "1", ")", ";", "}", "</s>" ]

[ "INSN", "is", "an", "sfunc", ";", "return", "the", "rtx", "that", "describes", "the", "address", "used", "." ]

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

[]

[ "<s>", "void", "rs6000_expand_vector_extract", "(", "rtx", "target", ",", "rtx", "vec", ",", "rtx", "elt", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vec", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "mem", ";", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "CONST_INT_P", "(", "elt", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_V1TImode", ":", "gcc_assert", "(", "INTVAL", "(", "elt", ")", "==", "0", "&&", "inner_mode", "==", "TImode", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "TImode", ",", "vec", ")", ")", ";", "break", ";", "case", "E_V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V16QImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v16qi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "E_V8HImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v8hi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "E_V4SImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v4si", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "break", ";", "}", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "CONST_INT_P", "(", "elt", ")", "&&", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "if", "(", "GET_MODE", "(", "elt", ")", "!=", "DImode", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "convert_move", "(", "tmp", ",", "elt", ",", "0", ")", ";", "elt", "=", "tmp", ";", "}", "else", "if", "(", "!", "REG_P", "(", "elt", ")", ")", "elt", "=", "force_reg", "(", "DImode", ",", "elt", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SImode", ":", "emit_insn", "(", "gen_vsx_extract_v4si_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V8HImode", ":", "emit_insn", "(", "gen_vsx_extract_v8hi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V16QImode", ":", "emit_insn", "(", "gen_vsx_extract_v16qi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "gcc_assert", "(", "CONST_INT_P", "(", "elt", ")", ")", ";", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "vec", ")", ";", "mem", "=", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "INTVAL", "(", "elt", ")", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ";", "emit_move_insn", "(", "target", ",", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Extract", "field", "ELT", "from", "VEC", "into", "TARGET", "." ]

[ "rs6000", "0", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "int", "MCOpcode", "=", "ST", ".", "getInstrInfo", "(", ")", "->", "pseudoToMCOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "MCOpcode", "==", "-", "1", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "+", "Twine", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "}", "OutMI", ".", "setOpcode", "(", "MCOpcode", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "AMDGPU", "::", "getMCReg", "(", "MO", ".", "getReg", "(", ")", ",", "ST", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "StringRef", "(", "GV", "->", "getName", "(", ")", ")", ")", ";", "const", "MCExpr", "*", "SymExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "getVariantKind", "(", "MO", ".", "getTargetFlags", "(", ")", ")", ",", "Ctx", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCBinaryExpr", "::", "createAdd", "(", "SymExpr", ",", "MCConstantExpr", "::", "create", "(", "MO", ".", "getOffset", "(", ")", ",", "Ctx", ")", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "StringRef", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "Sym", "->", "setExternal", "(", "true", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "break", ";", "}", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "AMDGPU", "AMDGPU", "1", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "\"unknown operand type\"", "AMDGPU::getMCReg" ]

[]

[ "<s>", "const", "PPCSubtarget", "*", "PPCTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "hasFnAttribute", "(", "\"use-soft-float\"", ")", "&&", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "PPCSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "computeFSAdditions", "(", "FS", ",", "getOptLevel", "(", ")", ",", "getTargetTriple", "(", ")", ")", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "PPC" ]

[]

[ "<s>", "static", "void", "init_sched_state", "(", "c6x_sched_context_t", "sc", ")", "{", "sc", "->", "last_scheduled_insn", "=", "NULL", ";", "sc", "->", "last_scheduled_iter0", "=", "NULL", ";", "sc", "->", "issued_this_cycle", "=", "0", ";", "memset", "(", "sc", "->", "jump_cycles", ",", "0", ",", "sizeof", "sc", "->", "jump_cycles", ")", ";", "memset", "(", "sc", "->", "jump_cond", ",", "0", ",", "sizeof", "sc", "->", "jump_cond", ")", ";", "sc", "->", "jump_cycle_index", "=", "0", ";", "sc", "->", "delays_finished_at", "=", "0", ";", "sc", "->", "curr_sched_clock", "=", "0", ";", "sc", "->", "prev_cycle_state_ctx", "=", "xmalloc", "(", "dfa_state_size", ")", ";", "memset", "(", "sc", "->", "reg_n_accesses", ",", "0", ",", "sizeof", "sc", "->", "reg_n_accesses", ")", ";", "memset", "(", "sc", "->", "reg_n_xaccesses", ",", "0", ",", "sizeof", "sc", "->", "reg_n_xaccesses", ")", ";", "memset", "(", "sc", "->", "reg_set_in_cycle", ",", "0", ",", "sizeof", "sc", "->", "reg_set_in_cycle", ")", ";", "state_reset", "(", "sc", "->", "prev_cycle_state_ctx", ")", ";", "}", "</s>" ]

[ "Initialize", "SC", ".", "Used", "by", "c6x_init_sched_context", "and", "c6x_sched_init", "." ]

[ "c6x", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "ix86_expand_sse_fp_minmax", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "if_true", ",", "rtx", "if_false", ")", "{", "machine_mode", "mode", ";", "bool", "is_min", ";", "rtx", "tmp", ";", "if", "(", "code", "==", "LT", ")", ";", "else", "if", "(", "code", "==", "UNGE", ")", "std", "::", "swap", "(", "if_true", ",", "if_false", ")", ";", "else", "return", "false", ";", "if", "(", "rtx_equal_p", "(", "cmp_op0", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op1", ",", "if_false", ")", ")", "is_min", "=", "true", ";", "else", "if", "(", "rtx_equal_p", "(", "cmp_op1", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op0", ",", "if_false", ")", ")", "is_min", "=", "false", ";", "else", "return", "false", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "!", "flag_unsafe_math_optimizations", ")", "{", "int", "u", "=", "is_min", "?", "UNSPEC_IEEE_MIN", ":", "UNSPEC_IEEE_MAX", ";", "rtvec", "v", ";", "if_true", "=", "force_reg", "(", "mode", ",", "if_true", ")", ";", "v", "=", "gen_rtvec", "(", "2", ",", "if_true", ",", "if_false", ")", ";", "tmp", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "v", ",", "u", ")", ";", "}", "else", "{", "code", "=", "is_min", "?", "SMIN", ":", "SMAX", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "if_true", ",", "if_false", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "tmp", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Detect", "conditional", "moves", "that", "exactly", "match", "min/max", "operational", "semantics", ".", "Note", "that", "this", "is", "IEEE", "safe", ",", "as", "long", "as", "we", "do", "n't", "interchange", "the", "operands", ".", "Returns", "FALSE", "if", "this", "conditional", "move", "does", "n't", "match", "a", "MIN/MAX", ",", "and", "TRUE", "if", "the", "operation", "is", "successful", "and", "instructions", "are", "emitted", "." ]

[ "i386", "2" ]

[]

[ "<s>", "void", "TPCSchedStrategy", "::", "releaseBottomNode", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "(", "void", ")", "MI", ";", "if", "(", "SU", "->", "isScheduled", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** release Bot - already scheduled: \"", "<<", "*", "MI", ")", ";", "return", ";", "}", "assert", "(", "SU", "->", "getInstr", "(", ")", "&&", "\"Scheduled SUnit must have instr\"", ")", ";", "for", "(", "SUnit", "::", "succ_iterator", "I", "=", "SU", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "SuccReadyCycle", "=", "I", "->", "getSUnit", "(", ")", "->", "BotReadyCycle", ";", "unsigned", "MinLatency", "=", "I", "->", "getLatency", "(", ")", ";", "Bot", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Bot", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "BotReadyCycle", "<", "SuccReadyCycle", "+", "MinLatency", ")", "SU", "->", "BotReadyCycle", "=", "SuccReadyCycle", "+", "MinLatency", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** released Bot (ready = \"", "<<", "SU", "->", "BotReadyCycle", "<<", "\"): \"", "<<", "*", "MI", ")", ";", "Bot", ".", "releaseNode", "(", "SU", ",", "SU", "->", "BotReadyCycle", ",", "isPostRA", ")", ";", "}", "</s>" ]

[ "Currently", "only", "scheduling", "top-down", ",", "so", "this", "method", "is", "empty", "." ]

[ "TPC", "TPC", "\"*** release Bot - already scheduled: \"", "\"Scheduled SUnit must have instr\"", "\"*** released Bot (ready = \"", "\"): \"" ]

[]

[ "<s>", "bool", "TMS320C64XFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "*", "MF", ";", "unsigned", "int", "i", ",", "reg", ";", "bool", "is_kill", ";", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "is_kill", "=", "true", ";", "reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "MachineRegisterInfo", "::", "livein_iterator", "li", "=", "MRI", ".", "livein_begin", "(", ")", ";", "for", "(", ";", "li", "!=", "MRI", ".", "livein_end", "(", ")", ";", "li", "++", ")", "{", "if", "(", "li", "->", "first", "==", "reg", ")", "{", "is_kill", "=", "false", ";", "break", ";", "}", "}", "MBB", ".", "addLiveIn", "(", "reg", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "(", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "reg", ",", "is_kill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "0", ",", "0", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "TMS320C64X", "TMS320C64X", "0", "0", "0" ]

[]

[ "<s>", "void", "R600TargetLowering", "::", "getStackAddress", "(", "unsigned", "StackWidth", ",", "unsigned", "ElemIdx", ",", "unsigned", "&", "Channel", ",", "unsigned", "&", "PtrIncr", ")", "const", "{", "switch", "(", "StackWidth", ")", "{", "default", ":", "case", "1", ":", "Channel", "=", "0", ";", "if", "(", "ElemIdx", ">", "0", ")", "{", "PtrIncr", "=", "1", ";", "}", "else", "{", "PtrIncr", "=", "0", ";", "}", "break", ";", "case", "2", ":", "Channel", "=", "ElemIdx", "%", "2", ";", "if", "(", "ElemIdx", "==", "2", ")", "{", "PtrIncr", "=", "1", ";", "}", "else", "{", "PtrIncr", "=", "0", ";", "}", "break", ";", "case", "4", ":", "Channel", "=", "ElemIdx", ";", "PtrIncr", "=", "0", ";", "break", ";", "}", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "R600", "1", "0", "0", "1", "0", "2", "2", "2", "1", "0", "4", "0" ]

[]

[ "<s>", "static", "int", "cris_address_cost", "(", "rtx", "x", ")", "{", "if", "(", "BASE_OR_AUTOINCR_P", "(", "x", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "return", "(", "2", "+", "4", ")", "/", "2", ";", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "(", "2", "+", "4", ")", "/", "2", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "tem1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "tem2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "tem1", ")", "==", "MULT", "&&", "BIAP_INDEX_P", "(", "tem1", ")", ")", "||", "REG_P", "(", "tem1", ")", ")", "return", "2", "/", "2", ";", "if", "(", "GET_CODE", "(", "tem2", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "tem2", ")", "<", "128", "&&", "INTVAL", "(", "tem2", ")", ">=", "-", "128", ")", "return", "2", "/", "2", ";", "if", "(", "GET_CODE", "(", "tem2", ")", "==", "CONST_INT", "&&", "CONST_OK_FOR_LETTER_P", "(", "INTVAL", "(", "tem2", ")", ",", "'L'", ")", ")", "return", "(", "2", "+", "2", ")", "/", "2", ";", "if", "(", "CONSTANT_P", "(", "tem2", ")", ")", "return", "(", "2", "+", "2", "+", "2", ")", "/", "2", ";", "return", "(", "2", "+", "2", "+", "2", ")", "/", "2", ";", "}", "return", "10", ";", "}", "</s>" ]

[ "The", "ADDRESS_COST", "worker", "." ]

[ "cris", "0", "2", "4", "2", "2", "4", "2", "0", "1", "2", "2", "128", "128", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "10" ]

[]

[ "<s>", "MachineInstrBuilder", "buildLoad", "(", "const", "DstOp", "&", "Res", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "unsigned", "Alignment", "=", "inferAlignmentFromPtrInfo", "(", "MF", ",", "MPO", ")", ";", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Alignment", ")", ";", "return", "MIRBuilder", ".", "buildLoad", "(", "Res", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "a", "G_LOAD", "instruction", ",", "while", "constructing", "the", "MachineMemOperand", "." ]

[ "ARM" ]

[]

[ "<s>", "unsigned", "getPointerSize", "(", ")", "const", "{", "return", "4", ";", "}", "</s>" ]

[ "Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "." ]

[ "MBlaze", "4" ]

[]

[ "<s>", "static", "inline", "int", "avr_lookup_function_attribute1", "(", "const_tree", "func", ",", "const", "char", "*", "name", ")", "{", "if", "(", "FUNCTION_DECL", "==", "TREE_CODE", "(", "func", ")", ")", "{", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "name", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ")", "{", "return", "true", ";", "}", "func", "=", "TREE_TYPE", "(", "func", ")", ";", "}", "gcc_assert", "(", "TREE_CODE", "(", "func", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "func", ")", "==", "METHOD_TYPE", ")", ";", "return", "NULL_TREE", "!=", "lookup_attribute", "(", "name", ",", "TYPE_ATTRIBUTES", "(", "func", ")", ")", ";", "}", "</s>" ]

[ "A", "helper", "for", "the", "subsequent", "function", "attribute", "used", "to", "dig", "for", "attribute", "'name", "'", "in", "a", "FUNCTION_DECL", "or", "FUNCTION_TYPE" ]

[ "avr" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "TM", ".", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "MI", ",", "Err", ")", ")", "{", "errs", "(", ")", "<<", "\"Warning: Illegal instruction detected: \"", "<<", "Err", "<<", "\"\\n\"", ";", "MI", "->", "dump", "(", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "++", "I", ";", "while", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "EmitInstruction", "(", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "if", "(", "DisasmEnabled", ")", "{", "DisasmLines", ".", "resize", "(", "DisasmLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "DisasmLine", "=", "DisasmLines", ".", "back", "(", ")", ";", "raw_string_ostream", "DisasmStream", "(", "DisasmLine", ")", ";", "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "TM", ".", "getInstrInfo", "(", ")", ",", "*", "TM", ".", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ")", ";", "SmallVector", "<", "MCFixup", ",", "4", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "16", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "MCObjectStreamer", "&", "ObjStreamer", "=", "(", "MCObjectStreamer", "&", ")", "OutStreamer", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "EncodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "TM", ".", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "CodeStream", ".", "flush", "(", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", ".", "back", "(", ")", ";", "raw_string_ostream", "HexStream", "(", "HexLine", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CodeBytes", ".", "size", "(", ")", ";", "i", "+=", "4", ")", "{", "unsigned", "int", "CodeDWord", "=", "*", "(", "unsigned", "int", "*", ")", "&", "CodeBytes", "[", "i", "]", ";", "HexStream", "<<", "format", "(", "\"%s%08X\"", ",", "(", "i", ">", "0", "?", "\" \"", ":", "\"\"", ")", ",", "CodeDWord", ")", ";", "}", "DisasmStream", ".", "flush", "(", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLine", ".", "size", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "R600", "\"Warning: Illegal instruction detected: \"", "\"\\n\"", "1", "4", "16", "1", "0", "4", "\"%s%08X\"", "0", "\" \"", "\"\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "HexagonTargetLowering", "::", "findRepresentativeClass", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Subtarget", ".", "isHVXVectorType", "(", "VT", ",", "true", ")", ")", "{", "unsigned", "BitWidth", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "VecWidth", "=", "Subtarget", ".", "getVectorLength", "(", ")", "*", "8", ";", "if", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "&", "Hexagon", "::", "HvxQRRegClass", ",", "1", ")", ";", "if", "(", "BitWidth", "==", "VecWidth", ")", "return", "std", "::", "make_pair", "(", "&", "Hexagon", "::", "HvxVRRegClass", ",", "1", ")", ";", "assert", "(", "BitWidth", "==", "2", "*", "VecWidth", ")", ";", "return", "std", "::", "make_pair", "(", "&", "Hexagon", "::", "HvxWRRegClass", ",", "1", ")", ";", "}", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "TRI", ",", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "Hexagon", "Hexagon", "8", "MVT::i1", "Hexagon::HvxQRRegClass", "1", "Hexagon::HvxVRRegClass", "1", "2", "Hexagon::HvxWRRegClass", "1" ]

[]

[ "<s>", "bool", "NVVMReflect", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "NVVMReflectEnabled", ")", "return", "false", ";", "setVarMap", "(", ")", ";", "ReflectFunction", "=", "M", ".", "getFunction", "(", "NVVM_REFLECT_FUNCTION", ")", ";", "if", "(", "ReflectFunction", "==", "0", ")", "return", "false", ";", "assert", "(", "ReflectFunction", "->", "isDeclaration", "(", ")", "&&", "\"_reflect function should not have a body\"", ")", ";", "assert", "(", "ReflectFunction", "->", "getReturnType", "(", ")", "->", "isIntegerTy", "(", ")", "&&", "\"_reflect's return type should be integer\"", ")", ";", "std", "::", "vector", "<", "Instruction", "*", ">", "ToRemove", ";", "for", "(", "User", "*", "U", ":", "ReflectFunction", "->", "users", "(", ")", ")", "{", "assert", "(", "isa", "<", "CallInst", ">", "(", "U", ")", "&&", "\"Only a call instruction can use _reflect\"", ")", ";", "CallInst", "*", "Reflect", "=", "cast", "<", "CallInst", ">", "(", "U", ")", ";", "assert", "(", "(", "Reflect", "->", "getNumOperands", "(", ")", "==", "2", ")", "&&", "\"Only one operand expect for _reflect function\"", ")", ";", "const", "Value", "*", "conv", "=", "Reflect", "->", "getArgOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "CallInst", ">", "(", "conv", ")", "&&", "\"Expected a const-to-gen conversion\"", ")", ";", "const", "CallInst", "*", "ConvCall", "=", "cast", "<", "CallInst", ">", "(", "conv", ")", ";", "const", "Value", "*", "str", "=", "ConvCall", "->", "getArgOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "ConstantExpr", ">", "(", "str", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "ConstantExpr", "*", "GEP", "=", "cast", "<", "ConstantExpr", ">", "(", "str", ")", ";", "const", "Value", "*", "Sym", "=", "GEP", "->", "getOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "Constant", ">", "(", "Sym", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "Constant", "*", "SymStr", "=", "cast", "<", "Constant", ">", "(", "Sym", ")", ";", "assert", "(", "isa", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "assert", "(", "cast", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "->", "isCString", "(", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "std", "::", "string", "ReflectArg", "=", "cast", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "->", "getAsString", "(", ")", ";", "ReflectArg", "=", "ReflectArg", ".", "substr", "(", "0", ",", "ReflectArg", ".", "size", "(", ")", "-", "1", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg of _reflect : \"", "<<", "ReflectArg", "<<", "\"\\n\"", ")", ";", "int", "ReflectVal", "=", "0", ";", "if", "(", "VarMap", ".", "find", "(", "ReflectArg", ")", "!=", "VarMap", ".", "end", "(", ")", ")", "{", "ReflectVal", "=", "VarMap", "[", "ReflectArg", "]", ";", "}", "Reflect", "->", "replaceAllUsesWith", "(", "ConstantInt", "::", "get", "(", "Reflect", "->", "getType", "(", ")", ",", "ReflectVal", ")", ")", ";", "ToRemove", ".", "push_back", "(", "Reflect", ")", ";", "}", "if", "(", "ToRemove", ".", "size", "(", ")", "==", "0", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ToRemove", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "ToRemove", "[", "i", "]", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "NVPTX", "0", "\"_reflect function should not have a body\"", "\"_reflect's return type should be integer\"", "\"Only a call instruction can use _reflect\"", "2", "\"Only one operand expect for _reflect function\"", "0", "\"Expected a const-to-gen conversion\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "0", "1", "\"Arg of _reflect : \"", "\"\\n\"", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "getExplicitKernelArgOffset", "(", "const", "Function", "&", "F", ")", "const", "{", "switch", "(", "TargetTriple", ".", "getOS", "(", ")", ")", "{", "case", "Triple", "::", "AMDHSA", ":", "case", "Triple", "::", "AMDPAL", ":", "case", "Triple", "::", "Mesa3D", ":", "return", "0", ";", "case", "Triple", "::", "UnknownOS", ":", "default", ":", "return", "36", ";", "}", "llvm_unreachable", "(", "\"invalid triple OS\"", ")", ";", "}", "</s>" ]

[ "Returns", "the", "offset", "in", "bytes", "from", "the", "start", "of", "the", "input", "buffer", "of", "the", "first", "explicit", "kernel", "argument", "." ]

[ "AMDGPU", "0", "36", "\"invalid triple OS\"" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "Register", "FPReg", "=", "getFPReg", "(", ")", ";", "Register", "SPReg", "=", "getSPReg", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "MBBI", "->", "isTerminator", "(", ")", ")", "MBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "std", "::", "prev", "(", "MBBI", ")", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "--", "MBBI", ";", "}", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MF", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "auto", "LastFrameDestroy", "=", "MBBI", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", "+", "RVFI", "->", "getRVVPadding", "(", ")", ";", "uint64_t", "RealStackSize", "=", "StackSize", "+", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "uint64_t", "FPOffset", "=", "RealStackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "uint64_t", "RVVStackSize", "=", "RVFI", "->", "getRVVStackSize", "(", ")", ";", "if", "(", "RI", "->", "hasStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "FPOffset", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "else", "{", "if", "(", "RVVStackSize", ")", "adjustStackForRVV", "(", "MF", ",", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "RVVStackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "FirstSPAdjustAmount", ")", "{", "uint64_t", "SecondSPAdjustAmount", "=", "MFI", ".", "getStackSize", "(", ")", "-", "FirstSPAdjustAmount", ";", "assert", "(", "SecondSPAdjustAmount", ">", "0", "&&", "\"SecondSPAdjustAmount should be greater than zero\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "SecondSPAdjustAmount", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "FirstSPAdjustAmount", ")", "StackSize", "=", "FirstSPAdjustAmount", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "emitSCSEpilogue", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "\"frame pointer should not have been eliminated\"", "0", "\"SecondSPAdjustAmount should be greater than zero\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "X86TargetLowering", "::", "findRepresentativeClass", "(", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "nullptr", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "RRC", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "break", ";", "case", "MVT", "::", "x86mmx", ":", "RRC", "=", "&", "X86", "::", "VR64RegClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "RRC", "=", "&", "X86", "::", "VR128RegClass", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "X86", "X86", "1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::x86mmx", "X86::VR64RegClass", "MVT::f32", "MVT::f64", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "MVT::v32i8", "MVT::v8i32", "MVT::v4i64", "MVT::v8f32", "MVT::v4f64", "X86::VR128RegClass" ]

[]

[ "<s>", "unsigned", "R600InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "{", "return", "0", ";", "}", "--", "I", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AMDGPU", "::", "JUMP_COND", ":", "{", "MachineInstr", "*", "predSet", "=", "findFirstPredicateSetterFrom", "(", "MBB", ",", "I", ")", ";", "clearFlag", "(", "*", "predSet", ",", "0", ",", "MO_FLAG_PUSH", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "CfAlu", "=", "FindLastAluClause", "(", "MBB", ")", ";", "if", "(", "CfAlu", "==", "MBB", ".", "end", "(", ")", ")", "break", ";", "assert", "(", "CfAlu", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU_PUSH_BEFORE", ")", ";", "CfAlu", "->", "setDesc", "(", "get", "(", "AMDGPU", "::", "CF_ALU", ")", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "JUMP", ":", "I", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "{", "return", "1", ";", "}", "--", "I", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "1", ";", "case", "AMDGPU", "::", "JUMP_COND", ":", "{", "MachineInstr", "*", "predSet", "=", "findFirstPredicateSetterFrom", "(", "MBB", ",", "I", ")", ";", "clearFlag", "(", "*", "predSet", ",", "0", ",", "MO_FLAG_PUSH", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "CfAlu", "=", "FindLastAluClause", "(", "MBB", ")", ";", "if", "(", "CfAlu", "==", "MBB", ".", "end", "(", ")", ")", "break", ";", "assert", "(", "CfAlu", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU_PUSH_BEFORE", ")", ";", "CfAlu", "->", "setDesc", "(", "get", "(", "AMDGPU", "::", "CF_ALU", ")", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "JUMP", ":", "I", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "AMDGPU", "R600", "\"code size not handled\"", "0", "0", "AMDGPU::JUMP_COND", "0", "AMDGPU::CF_ALU_PUSH_BEFORE", "AMDGPU::CF_ALU", "AMDGPU::JUMP", "1", "1", "AMDGPU::JUMP_COND", "0", "AMDGPU::CF_ALU_PUSH_BEFORE", "AMDGPU::CF_ALU", "AMDGPU::JUMP", "2" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUAsmPrinter", "::", "getPassName", "(", ")", "const", "{", "return", "\"AMDGPU Assembly Printer\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"AMDGPU Assembly Printer\"" ]

[]

[ "<s>", "static", "bool", "ix86_dep_by_shift_count_body", "(", "const_rtx", "set_body", ",", "const_rtx", "use_body", ")", "{", "rtx", "set_dest", ";", "rtx", "shift_rtx", ";", "int", "i", ";", "switch", "(", "GET_CODE", "(", "set_body", ")", ")", "{", "case", "SET", ":", "set_dest", "=", "SET_DEST", "(", "set_body", ")", ";", "if", "(", "!", "set_dest", "||", "!", "REG_P", "(", "set_dest", ")", ")", "return", "false", ";", "break", ";", "case", "PARALLEL", ":", "for", "(", "i", "=", "XVECLEN", "(", "set_body", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "ix86_dep_by_shift_count_body", "(", "XVECEXP", "(", "set_body", ",", "0", ",", "i", ")", ",", "use_body", ")", ")", "return", "true", ";", "default", ":", "return", "false", ";", "}", "switch", "(", "GET_CODE", "(", "use_body", ")", ")", "{", "case", "SET", ":", "shift_rtx", "=", "XEXP", "(", "use_body", ",", "1", ")", ";", "break", ";", "case", "PARALLEL", ":", "for", "(", "i", "=", "XVECLEN", "(", "use_body", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "ix86_dep_by_shift_count_body", "(", "set_body", ",", "XVECEXP", "(", "use_body", ",", "0", ",", "i", ")", ")", ")", "return", "true", ";", "default", ":", "return", "false", ";", "}", "if", "(", "shift_rtx", "&&", "(", "GET_CODE", "(", "shift_rtx", ")", "==", "ASHIFT", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "LSHIFTRT", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "ASHIFTRT", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "ROTATE", "||", "GET_CODE", "(", "shift_rtx", ")", "==", "ROTATERT", ")", ")", "{", "rtx", "shift_count", "=", "XEXP", "(", "shift_rtx", ",", "1", ")", ";", "if", "(", "REG_P", "(", "shift_count", ")", ")", "{", "if", "(", "reload_completed", "&&", "true_regnum", "(", "set_dest", ")", "==", "true_regnum", "(", "shift_count", ")", ")", "return", "true", ";", "else", "if", "(", "REGNO", "(", "set_dest", ")", "==", "REGNO", "(", "shift_count", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "destination", "reg", "of", "SET_BODY", "is", "shift", "count", "of", "USE_BODY", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"GCN DPP Combine\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"GCN DPP Combine\"" ]

[]

[ "<s>", "unsigned", "reset", "(", "unsigned", "NewTop", ")", "{", "List", ".", "resize", "(", "NewTop", "+", "1", ")", ";", "return", "NewTop", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "Hexagon", "1" ]

[]

[ "<s>", "DecodeStatus", "AArch64Disassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "Size", "=", "0", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "return", "Fail", ";", "Size", "=", "4", ";", "uint32_t", "Insn", "=", "(", "Bytes", "[", "3", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "2", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "1", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "0", "]", "<<", "0", ")", ";", "const", "uint8_t", "*", "Tables", "[", "]", "=", "{", "DecoderTable32", ",", "DecoderTableFallback32", "}", ";", "for", "(", "auto", "Table", ":", "Tables", ")", "{", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "Table", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Desc", ".", "getNumOperands", "(", ")", ";", "i", "++", ")", "{", "if", "(", "Desc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "MCOI", "::", "OPERAND_REGISTER", ")", "{", "switch", "(", "Desc", ".", "OpInfo", "[", "i", "]", ".", "RegClass", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "MPRRegClassID", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "i", ",", "MCOperand", "::", "createReg", "(", "AArch64", "::", "ZA", ")", ")", ";", "break", ";", "case", "AArch64", "::", "MPR8RegClassID", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "i", ",", "MCOperand", "::", "createReg", "(", "AArch64", "::", "ZAB0", ")", ")", ";", "break", ";", "}", "}", "else", "if", "(", "Desc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "AArch64", "::", "OPERAND_IMPLICIT_IMM_0", ")", "{", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "i", ",", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "LDR_ZA", "||", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "STR_ZA", ")", "{", "const", "MCOperand", "&", "Imm4Op", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "assert", "(", "Imm4Op", ".", "isImm", "(", ")", "&&", "\"Unexpected operand type!\"", ")", ";", "MI", ".", "addOperand", "(", "Imm4Op", ")", ";", "}", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "AArch64", "AArch64", "0", "4", "4", "3", "24", "2", "16", "1", "8", "0", "0", "0", "AArch64::MPRRegClassID", "AArch64::ZA", "AArch64::MPR8RegClassID", "AArch64::ZAB0", "AArch64::OPERAND_IMPLICIT_IMM_0", "0", "AArch64::LDR_ZA", "AArch64::STR_ZA", "2", "\"Unexpected operand type!\"" ]

[]

[ "<s>", "static", "bool", "rs6000_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "0", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "type", ",", "true", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "false", ";", "}", "if", "(", "rs6000_discover_homogeneous_aggregate", "(", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "NULL", ",", "NULL", ")", ")", "return", "false", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", "<=", "16", ")", "return", "false", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "aix_struct_return", "||", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "8", ")", ")", "return", "true", ";", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_return_big_vectors", "=", "false", ";", "if", "(", "!", "warned_for_return_big_vectors", ")", "{", "warning", "(", "0", ",", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", ")", ";", "warned_for_return_big_vectors", "=", "true", ";", "}", "return", "true", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "FLOAT128_IEEE_P", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "a", "nonzero", "value", "to", "say", "to", "return", "the", "function", "value", "in", "memory", ",", "just", "as", "large", "structures", "are", "always", "returned", ".", "TYPE", "will", "be", "the", "data", "type", "of", "the", "value", ",", "and", "FNTYPE", "will", "be", "the", "type", "of", "the", "function", "doing", "the", "returning", ",", "or", "@", "code", "{", "NULL", "}", "for", "libcalls", ".", "The", "AIX", "ABI", "for", "the", "RS/6000", "specifies", "that", "all", "structures", "are", "returned", "in", "memory", ".", "The", "Darwin", "ABI", "does", "the", "same", ".", "The", "SVR4", "ABI", "specifies", "that", "structures", "<", "=", "8", "bytes", "are", "returned", "in", "r3/r4", ",", "but", "a", "draft", "put", "them", "in", "memory", ",", "and", "GCC", "used", "to", "implement", "the", "draft", "instead", "of", "the", "final", "standard", ".", "Therefore", ",", "aix_struct_return", "controls", "this", "instead", "of", "DEFAULT_ABI", ";", "V.4", "targets", "needing", "backward", "compatibility", "can", "change", "DRAFT_V4_STRUCT_RET", "to", "override", "the", "default", ",", "and", "-m", "switches", "get", "the", "final", "word", ".", "See", "rs6000_override_options", "for", "more", "details", ".", "The", "PPC32", "SVR4", "ABI", "uses", "IEEE", "double", "extended", "for", "long", "double", ",", "if", "128-bit", "long", "double", "support", "is", "enabled", ".", "These", "values", "are", "returned", "in", "memory", ".", "int_size_in_bytes", "returns", "-1", "for", "variable", "size", "objects", ",", "which", "go", "in", "memory", "always", ".", "The", "cast", "to", "unsigned", "makes", "-1", ">", "8", "." ]

[ "rs6000", "0", "0", "16", "8", "16", "8", "0", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"" ]

[]

[ "<s>", "void", "M68kInstrInfo", "::", "AddSExt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "Reg", ",", "MVT", "From", ",", "MVT", "To", ")", "const", "{", "if", "(", "From", "==", "MVT", "::", "i8", ")", "{", "unsigned", "R", "=", "Reg", ";", "if", "(", "To", "==", "MVT", "::", "i32", ")", "{", "R", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "M68k", "::", "MxSubRegIndex16Lo", ")", ";", "assert", "(", "R", "&&", "\"No viable SUB register available\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M68k", "::", "EXT16", ")", ",", "R", ")", ".", "addReg", "(", "R", ")", ";", "}", "if", "(", "To", "==", "MVT", "::", "i32", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M68k", "::", "EXT32", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Add", "appropriate", "SExt", "nodes", "." ]

[ "M68k", "M68k", "MVT::i8", "MVT::i32", "M68k::MxSubRegIndex16Lo", "\"No viable SUB register available\"", "M68k::EXT16", "MVT::i32", "M68k::EXT32" ]

[]

[ "<s>", "bool", "AArch64DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "assert", "(", "ConstraintCode", "==", "'m'", "&&", "\"unexpected asm memory constraint\"", ")", ";", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "AArch64", "AArch64", "\"unexpected asm memory constraint\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "L2_loadrb_io", ":", "case", "Hexagon", "::", "L2_loadrub_io", ":", "case", "Hexagon", "::", "L2_loadrh_io", ":", "case", "Hexagon", "::", "L2_loadruh_io", ":", "case", "Hexagon", "::", "L2_loadri_io", ":", "case", "Hexagon", "::", "L2_loadrd_io", ":", "case", "Hexagon", "::", "V6_vL32b_ai", ":", "case", "Hexagon", "::", "V6_vL32b_ai_128B", ":", "case", "Hexagon", "::", "V6_vL32Ub_ai", ":", "case", "Hexagon", "::", "V6_vL32Ub_ai_128B", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "case", "Hexagon", "::", "LDriw_mod", ":", "case", "Hexagon", "::", "PS_vloadrq_ai", ":", "case", "Hexagon", "::", "PS_vloadrw_ai", ":", "case", "Hexagon", "::", "PS_vloadrq_ai_128B", ":", "case", "Hexagon", "::", "PS_vloadrw_ai_128B", ":", "{", "const", "MachineOperand", "OpFI", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "OpOff", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "case", "Hexagon", "::", "L2_ploadrbt_io", ":", "case", "Hexagon", "::", "L2_ploadrbf_io", ":", "case", "Hexagon", "::", "L2_ploadrubt_io", ":", "case", "Hexagon", "::", "L2_ploadrubf_io", ":", "case", "Hexagon", "::", "L2_ploadrht_io", ":", "case", "Hexagon", "::", "L2_ploadrhf_io", ":", "case", "Hexagon", "::", "L2_ploadruht_io", ":", "case", "Hexagon", "::", "L2_ploadruhf_io", ":", "case", "Hexagon", "::", "L2_ploadrit_io", ":", "case", "Hexagon", "::", "L2_ploadrif_io", ":", "case", "Hexagon", "::", "L2_ploadrdt_io", ":", "case", "Hexagon", "::", "L2_ploadrdf_io", ":", "{", "const", "MachineOperand", "OpFI", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "OpOff", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Hexagon", "Hexagon", "Hexagon::L2_loadrb_io", "Hexagon::L2_loadrub_io", "Hexagon::L2_loadrh_io", "Hexagon::L2_loadruh_io", "Hexagon::L2_loadri_io", "Hexagon::L2_loadrd_io", "Hexagon::V6_vL32b_ai", "Hexagon::V6_vL32b_ai_128B", "Hexagon::V6_vL32Ub_ai", "Hexagon::V6_vL32Ub_ai_128B", "Hexagon::LDriw_pred", "Hexagon::LDriw_mod", "Hexagon::PS_vloadrq_ai", "Hexagon::PS_vloadrw_ai", "Hexagon::PS_vloadrq_ai_128B", "Hexagon::PS_vloadrw_ai_128B", "1", "0", "2", "0", "0", "0", "Hexagon::L2_ploadrbt_io", "Hexagon::L2_ploadrbf_io", "Hexagon::L2_ploadrubt_io", "Hexagon::L2_ploadrubf_io", "Hexagon::L2_ploadrht_io", "Hexagon::L2_ploadrhf_io", "Hexagon::L2_ploadruht_io", "Hexagon::L2_ploadruhf_io", "Hexagon::L2_ploadrit_io", "Hexagon::L2_ploadrif_io", "Hexagon::L2_ploadrdt_io", "Hexagon::L2_ploadrdf_io", "2", "0", "3", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "expand_block_set_1", "(", "rtx", "dst_reg", ",", "rtx", "value_rtx", ",", "rtx", "bytes_rtx", ")", "{", "const", "rtx", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__byt_memset\"", ")", ";", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "1", ")", ";", "emit_library_call", "(", "sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "set", "BYTES_RTX", "bytes", "at", "address", "DST_REG", "to", "VALUE_RTX", "in", "1-byte", "chunks", "." ]

[ "visium", "\"__byt_memset\"", "1", "3" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "LOAD_STACK_GUARD", ")", "{", "assert", "(", "getSubtarget", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", "&&", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", ")", ";", "expandLoadStackGuard", "(", "MI", ")", ";", "MI", ".", "getParent", "(", ")", "->", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MEMCPY", ")", "{", "expandMEMCPY", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "!", "MI", ".", "isCopy", "(", ")", "||", "Subtarget", ".", "dontWidenVMOVS", "(", ")", "||", "Subtarget", ".", "isFPOnlySP", "(", ")", ")", "return", "false", ";", "unsigned", "DstRegS", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcRegS", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DstRegS", ",", "SrcRegS", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "DstRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "DstRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "unsigned", "SrcRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DstRegD", "||", "!", "SrcRegD", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "definesRegister", "(", "DstRegD", ",", "TRI", ")", "||", "MI", ".", "readsRegister", "(", "DstRegD", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"widening: \"", "<<", "MI", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "int", "ImpDefIdx", "=", "MI", ".", "findRegisterDefOperandIdx", "(", "DstRegD", ")", ";", "if", "(", "ImpDefIdx", "!=", "-", "1", ")", "MI", ".", "RemoveOperand", "(", "ImpDefIdx", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "ARM", "::", "VMOVD", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DstRegD", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setReg", "(", "SrcRegD", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsUndef", "(", ")", ";", "MIB", ".", "addReg", "(", "SrcRegS", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "false", ")", ";", "MI", ".", "addRegisterKilled", "(", "SrcRegS", ",", "TRI", ",", "true", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"replaced by: \"", "<<", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "ARM", "ARM", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", "ARM::MEMCPY", "0", "1", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0", "\"widening: \"", "1", "ARM::VMOVD", "0", "1", "1", "1", "1", "\"replaced by: \"" ]

[]

[ "<s>", "int", "neon_immediate_valid_for_logic", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "inverse", ",", "rtx", "*", "modconst", ",", "int", "*", "elementwidth", ")", "{", "rtx", "tmpconst", ";", "int", "tmpwidth", ";", "int", "retval", "=", "neon_valid_immediate", "(", "op", ",", "mode", ",", "inverse", ",", "&", "tmpconst", ",", "&", "tmpwidth", ")", ";", "if", "(", "retval", "<", "0", "||", "retval", ">", "5", ")", "return", "0", ";", "if", "(", "modconst", ")", "*", "modconst", "=", "tmpconst", ";", "if", "(", "elementwidth", ")", "*", "elementwidth", "=", "tmpwidth", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "rtx", "X", "is", "legal", "for", "use", "in", "a", "VORR", "or", "VBIC", "instruction", ".", "If", "the", "immediate", "is", "valid", ",", "write", "a", "constant", "suitable", "for", "using", "as", "an", "operand", "to", "VORR/VBIC/VAND/VORN", "to", "*", "MODCONST", "and", "the", "corresponding", "element", "width", "to", "*", "ELEMENTWIDTH", ".", "See", "neon_valid_immediate", "for", "description", "of", "INVERSE", "." ]

[ "arm", "0", "5", "0", "1" ]

[]

[ "<s>", "static", "rtx", "epiphany_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "PASS_IN_REG_P", "(", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "ROUND_ADVANCE_CUM", "(", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "On", "the", "EPIPHANY", "the", "first", "MAX_EPIPHANY_PARM_REGS", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "." ]

[ "epiphany", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Name", "=", "parseMnemonicSuffix", "(", "Name", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "this", ",", "Name", ",", "NameLoc", ")", ")", ";", "bool", "IsMIMG", "=", "Name", ".", "startswith", "(", "\"image_\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "OperandMode", "Mode", "=", "OperandMode_Default", ";", "if", "(", "IsMIMG", "&&", "isGFX10", "(", ")", "&&", "Operands", ".", "size", "(", ")", "==", "2", ")", "Mode", "=", "OperandMode_NSA", ";", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ",", "Mode", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "break", ";", "case", "MatchOperand_ParseFail", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"failed parsing operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "case", "MatchOperand_NoMatch", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"not a valid operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "\"image_\"", "2", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "TargetFrameLowering", "::", "DwarfFrameBase", "WebAssemblyFrameLowering", "::", "getDwarfFrameBase", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "DwarfFrameBase", "Loc", ";", "Loc", ".", "Kind", "=", "DwarfFrameBase", "::", "WasmFrameBase", ";", "const", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "if", "(", "needsSP", "(", "MF", ")", "&&", "MFI", ".", "isFrameBaseVirtual", "(", ")", ")", "{", "unsigned", "LocalNum", "=", "MFI", ".", "getFrameBaseLocal", "(", ")", ";", "Loc", ".", "Location", ".", "WasmLoc", "=", "{", "WebAssembly", "::", "TI_LOCAL", ",", "LocalNum", "}", ";", "}", "else", "{", "Loc", ".", "Location", ".", "WasmLoc", "=", "{", "WebAssembly", "::", "TI_GLOBAL_RELOC", ",", "0", "}", ";", "}", "return", "Loc", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly::TI_LOCAL", "WebAssembly::TI_GLOBAL_RELOC", "0" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "KindTy", "::", "Register", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "RISCV" ]

[]

[ "<s>", "unsigned", "HexagonAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "HexagonOperand", "*", "Op", "=", "static_cast", "<", "HexagonOperand", "*", ">", "(", "&", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_0", ":", "{", "int64_t", "Value", ";", "return", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "Imm", ".", "Val", "->", "evaluateAsAbsolute", "(", "Value", ")", "&&", "Value", "==", "0", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "}", "case", "MCK_1", ":", "{", "int64_t", "Value", ";", "return", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "Imm", ".", "Val", "->", "evaluateAsAbsolute", "(", "Value", ")", "&&", "Value", "==", "1", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "}", "}", "if", "(", "Op", "->", "Kind", "==", "HexagonOperand", "::", "Token", "&&", "Kind", "!=", "InvalidMatchClass", ")", "{", "StringRef", "myStringRef", "=", "StringRef", "(", "Op", "->", "Tok", ".", "Data", ",", "Op", "->", "Tok", ".", "Length", ")", ";", "if", "(", "matchTokenString", "(", "myStringRef", ".", "lower", "(", ")", ")", "==", "(", "MatchClassKind", ")", "Kind", ")", "return", "Match_Success", ";", "if", "(", "matchTokenString", "(", "myStringRef", ".", "upper", "(", ")", ")", "==", "(", "MatchClassKind", ")", "Kind", ")", "return", "Match_Success", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unmatched Operand:\"", ")", ";", "LLVM_DEBUG", "(", "Op", "->", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "1", "Hexagon", "\"Unmatched Operand:\"", "\"\\n\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "M88kRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "M88k", "::", "GPRRCRegClass", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k::GPRRCRegClass" ]

[]

[ "<s>", "void", "TOYInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "TOY", "TOY" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "RISCV", "RISCV", "RISCV::X0", "RISCV::X1", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isPredicable", "(", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "STI", ".", "hasLoadStoreOnCond", "(", ")", "&&", "getConditionalMove", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "SystemZ", "::", "Return", "||", "Opcode", "==", "SystemZ", "::", "CallJG", "||", "Opcode", "==", "SystemZ", "::", "CallBR", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "SystemZ", "SystemZ", "SystemZ::Return", "SystemZ::CallJG", "SystemZ::CallBR" ]

[]

[ "<s>", "bool", "AArch64PromoteConstant", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "LocalChange", "=", "false", ";", "SmallPtrSet", "<", "Constant", "*", ",", "8", ">", "AlreadyChecked", ";", "for", "(", "Instruction", "&", "I", ":", "inst_range", "(", "&", "F", ")", ")", "{", "for", "(", "Value", "*", "Op", ":", "I", ".", "operand_values", "(", ")", ")", "{", "Constant", "*", "Cst", "=", "dyn_cast", "<", "Constant", ">", "(", "Op", ")", ";", "if", "(", "Cst", "&&", "!", "isa", "<", "GlobalValue", ">", "(", "Cst", ")", "&&", "!", "isa", "<", "ConstantExpr", ">", "(", "Cst", ")", "&&", "AlreadyChecked", ".", "insert", "(", "Cst", ")", ".", "second", ")", "LocalChange", "|=", "promoteConstant", "(", "Cst", ")", ";", "}", "}", "return", "LocalChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AArch64", "AArch64", "8" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "schedule", "(", ")", "{", "buildSchedGraph", "(", "AA", ")", ";", "if", "(", "AntiDepBreak", "!=", "NULL", ")", "{", "unsigned", "Broken", "=", "AntiDepBreak", "->", "BreakAntiDependencies", "(", "SUnits", ",", "RegionBegin", ",", "RegionEnd", ",", "EndIndex", ",", "DbgValues", ")", ";", "if", "(", "Broken", "!=", "0", ")", "{", "ScheduleDAG", "::", "clearDAG", "(", ")", ";", "buildSchedGraph", "(", "AA", ")", ";", "NumFixedAnti", "+=", "Broken", ";", "}", "}", "Topo", ".", "InitDAGTopologicalSorting", "(", ")", ";", "postprocessDAG", "(", ")", ";", "SchedImpl", "->", "postprocessDAG", "(", "this", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "TopRoots", ",", "BotRoots", ";", "findRootsAndBiasEdges", "(", "TopRoots", ",", "BotRoots", ")", ";", "SchedImpl", "->", "initialize", "(", "this", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** List Scheduling **********\\n\"", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "if", "(", "ViewPostRASchedDAGs", ")", "viewGraph", "(", ")", ";", "initQueues", "(", "TopRoots", ",", "BotRoots", ")", ";", "bool", "IsTopNode", "=", "false", ";", "bool", "IsBundled", "=", "false", ";", "SUnit", "*", "SU", ";", "while", "(", "SchedImpl", "->", "pickNode", "(", "SU", ",", "IsTopNode", ",", "IsBundled", ")", ")", "{", "scheduleMI", "(", "SU", ",", "IsTopNode", ",", "IsBundled", ")", ";", "if", "(", "SU", "&&", "SU", "->", "isScheduled", ")", "{", "SchedImpl", "->", "reschedNode", "(", "SU", ",", "IsTopNode", ",", "IsBundled", ")", ";", "NumRescheduled", "++", ";", "}", "else", "if", "(", "SU", ")", "{", "updateQueues", "(", "SU", ",", "IsTopNode", ",", "IsBundled", ")", ";", "SchedImpl", "->", "schedNode", "(", "SU", ",", "IsTopNode", ",", "IsBundled", ")", ";", "}", "else", "{", "SchedImpl", "->", "schedNoop", "(", "IsTopNode", ")", ";", "NumNoops", "++", ";", "}", "}", "finishTopBundle", "(", ")", ";", "finishBottomBundle", "(", ")", ";", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "SchedImpl", "->", "finalize", "(", "this", ")", ";", "placeDebugValues", "(", ")", ";", "DEBUG", "(", "{", "unsigned", "BBNum", "=", "begin", "(", ")", "->", "getParent", "(", ")", "->", "getNumber", "(", ")", ";", "dbgs", "(", ")", "<<", "\"*** Final schedule for BB#\"", "<<", "BBNum", "<<", "\" ***\\n\"", ";", "dumpSchedule", "(", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Patmos", "0", "8", "\"********** List Scheduling **********\\n\"", "0", "\"Nonempty unscheduled zone.\"", "\"*** Final schedule for BB#\"", "\" ***\\n\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "{", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "STRH", ":", "case", "ARM", "::", "STRBi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "t2STRi8", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VSTRS", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "tLDRspi", ":", "break", ";", "default", ":", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "8", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "FPOffset", "-=", "80", ";", "Offset", "=", "-", "Offset", ";", "Offset", "+=", "MFI", "->", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "unsigned", "StackAlign", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "!", "(", "(", "MFI", "->", "getLocalFrameMaxAlign", "(", ")", ">", "StackAlign", ")", "&&", "canRealignStack", "(", "MF", ")", ")", ")", "{", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "FPOffset", ")", ")", "return", "false", ";", "}", "if", "(", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARM::LDRi12", "ARM::LDRH", "ARM::LDRBi12", "ARM::STRi12", "ARM::STRH", "ARM::STRBi12", "ARM::t2LDRi12", "ARM::t2LDRi8", "ARM::t2STRi12", "ARM::t2STRi8", "ARM::VLDRS", "ARM::VLDRD", "ARM::VSTRS", "ARM::VSTRD", "ARM::tSTRspi", "ARM::tLDRspi", "ARM", "ARM", "8", "80", "128" ]

[]

[ "<s>", "const", "char", "*", "pa_output_millicode_call", "(", "rtx_insn", "*", "insn", ",", "rtx", "call_dest", ")", "{", "int", "attr_length", "=", "get_attr_length", "(", "insn", ")", ";", "int", "seq_length", "=", "dbr_sequence_length", "(", ")", ";", "rtx", "xoperands", "[", "4", "]", ";", "xoperands", "[", "0", "]", "=", "call_dest", ";", "if", "(", "!", "TARGET_LONG_CALLS", "&&", "(", "attr_length", "==", "8", "||", "(", "attr_length", "==", "28", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_SH_FUNC_ADRS", ")", ")", ")", "{", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "TARGET_64BIT", "?", "2", ":", "31", ")", ";", "output_asm_insn", "(", "\"{bl|b,l} %0,%1\"", ",", "xoperands", ")", ";", "}", "else", "{", "if", "(", "TARGET_64BIT", ")", "{", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "xoperands", "[", "2", "]", "=", "xoperands", "[", "1", "]", ";", "pa_output_pic_pcrel_sequence", "(", "xoperands", ")", ";", "output_asm_insn", "(", "\"bve,l (%%r1),%%r2\"", ",", "xoperands", ")", ";", "}", "else", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "{", "output_asm_insn", "(", "\"ldil L'%0,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0(%%r1),%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"{bl|b,l} .+8,%%r31\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"addi 8,%%r31,%%r31\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "if", "(", "!", "flag_pic", ")", "{", "output_asm_insn", "(", "\"ldil L'%0,%%r1\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_PA_20", ")", "output_asm_insn", "(", "\"be,l R'%0(%%sr4,%%r1),%%sr0,%%r31\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"ble R'%0(%%sr4,%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "{", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "31", ")", ";", "xoperands", "[", "2", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "pa_output_pic_pcrel_sequence", "(", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo {16|24}(%%r31),%%r31\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "}", "if", "(", "seq_length", "==", "0", ")", "output_asm_insn", "(", "\"nop\"", ",", "xoperands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "INSN", "is", "a", "function", "call", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "." ]

[ "pa", "4", "0", "8", "28", "1", "2", "31", "\"{bl|b,l} %0,%1\"", "1", "1", "2", "1", "\"bve,l (%%r1),%%r2\"", "\"ldil L'%0,%%r1\"", "\"ldo R'%0(%%r1),%%r1\"", "\"{bl|b,l} .+8,%%r31\"", "\"addi 8,%%r31,%%r31\"", "\"bv %%r0(%%r1)\"", "\"ldil L'%0,%%r1\"", "\"be,l R'%0(%%sr4,%%r1),%%sr0,%%r31\"", "\"ble R'%0(%%sr4,%%r1)\"", "1", "31", "2", "1", "\"ldo {16|24}(%%r31),%%r31\"", "\"bv %%r0(%%r1)\"", "0", "\"nop\"", "\"\"" ]

[]

[ "<s>", "bool", "M68kCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "M68kTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "I", "=", "0", ";", "for", "(", "const", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "I", "]", ",", "Arg", ".", "getType", "(", ")", ",", "I", "}", ";", "setArgFlags", "(", "OrigArg", ",", "I", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "I", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "getCCAssignFn", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "IncomingValueAssigner", "ArgAssigner", "(", "AssignFn", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ")", ";", "return", "determineAndHandleAssignments", "(", "ArgHandler", ",", "ArgAssigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "M68k", "M68k", "M68k", "8", "0" ]

[]

[ "<s>", "const", "unsigned", "*", "MSP430RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntr", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "if", "(", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "MSP430", "MSP430", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430", "MSP430" ]

[]

[ "<s>", "static", "tree", "aarch64_builtin_decl", "(", "unsigned", "int", "code", ",", "bool", "initialize_p", ")", "{", "unsigned", "int", "subcode", "=", "code", ">>", "AARCH64_BUILTIN_SHIFT", ";", "switch", "(", "code", "&", "AARCH64_BUILTIN_CLASS", ")", "{", "case", "AARCH64_BUILTIN_GENERAL", ":", "return", "aarch64_general_builtin_decl", "(", "subcode", ",", "initialize_p", ")", ";", "case", "AARCH64_BUILTIN_SVE", ":", "return", "aarch64_sve", "::", "builtin_decl", "(", "subcode", ",", "initialize_p", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "." ]

[ "aarch64", "aarch64_sve::builtin_decl" ]

[]

[ "<s>", "static", "rtx", "sparc_struct_value_rtx", "(", "tree", "fndecl", ",", "int", "incoming", ")", "{", "if", "(", "TARGET_ARCH64", ")", "return", "NULL_RTX", ";", "else", "{", "rtx", "mem", ";", "if", "(", "incoming", ")", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "STRUCT_VALUE_OFFSET", ")", ")", ";", "else", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "STRUCT_VALUE_OFFSET", ")", ")", ";", "if", "(", "incoming", "==", "2", "&&", "sparc_std_struct_return", "&&", "TYPE_SIZE_UNIT", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE_UNIT", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", "==", "INTEGER_CST", ")", "{", "rtx", "ret_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "scratch", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "endlab", "=", "gen_label_rtx", "(", ")", ";", "tree", "size", "=", "TYPE_SIZE_UNIT", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "rtx", "size_rtx", "=", "GEN_INT", "(", "TREE_INT_CST_LOW", "(", "size", ")", "&", "0xfff", ")", ";", "rtx", "temp_val", "=", "assign_stack_local", "(", "Pmode", ",", "TREE_INT_CST_LOW", "(", "size", ")", ",", "0", ")", ";", "emit_move_insn", "(", "scratch", ",", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "ret_reg", ",", "8", ")", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "ret_reg", ",", "ret_reg", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "scratch", ",", "size_rtx", ",", "EQ", ",", "const0_rtx", ",", "SImode", ",", "0", ",", "endlab", ")", ";", "emit_insn", "(", "gen_sub3_insn", "(", "ret_reg", ",", "ret_reg", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "XEXP", "(", "temp_val", ",", "0", ")", ")", ";", "emit_label", "(", "endlab", ")", ";", "}", "return", "mem", ";", "}", "}", "</s>" ]

[ "Handle", "the", "TARGET_STRUCT_VALUE", "target", "hook", ".", "Return", "where", "to", "find", "the", "structure", "return", "value", "address", "." ]

[ "sparc", "2", "0xfff", "0", "8", "4", "0", "4", "0" ]

[]

[ "<s>", "bool", "AArch64ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]