Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "DataLayout", "&", "DL", ")", "const", "override", "{", "return", "Ty", "->", "isArrayTy", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "an", "argument", "of", "type", "Ty", "needs", "to", "be", "passed", "in", "a", "contiguous", "block", "of", "registers", "in", "calling", "convention", "CallConv", "." ]

[ "PowerPC" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "ARMInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "ARMII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_GOT", ",", "\"arm-got\"", "}", ",", "{", "MO_SBREL", ",", "\"arm-sbrel\"", "}", ",", "{", "MO_DLLIMPORT", ",", "\"arm-dllimport\"", "}", ",", "{", "MO_SECREL", ",", "\"arm-secrel\"", "}", ",", "{", "MO_NONLAZY", ",", "\"arm-nonlazy\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "ARM", "ARM", "ARM", "\"arm-got\"", "\"arm-sbrel\"", "\"arm-dllimport\"", "\"arm-secrel\"", "\"arm-nonlazy\"" ]

[]

[ "<s>", "virtual", "bool", "addPostRegAlloc", "(", ")", "{", "if", "(", "PatmosSinglePathInfo", "::", "isEnabled", "(", ")", ")", "{", "addPass", "(", "createPatmosSPMarkPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosSinglePathInfoPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosSPPreparePass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

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

[]

[ "<s>", "void", "WasmPEI", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "StackProtector", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "MipsHazardSchedule", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "MipsSubtarget", "*", "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", "->", "hasMips32r6", "(", ")", "||", "STI", "->", "inMicroMipsMode", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "const", "MipsInstrInfo", "*", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "MF", ".", "begin", "(", ")", ";", "FI", "!=", "MF", ".", "end", "(", ")", ";", "++", "FI", ")", "{", "for", "(", "Iter", "I", "=", "FI", "->", "begin", "(", ")", ";", "I", "!=", "FI", "->", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "TII", "->", "HasForbiddenSlot", "(", "*", "I", ")", ")", "continue", ";", "Iter", "Inst", ";", "bool", "LastInstInFunction", "=", "std", "::", "next", "(", "I", ")", "==", "FI", "->", "end", "(", ")", "&&", "std", "::", "next", "(", "FI", ")", "==", "MF", ".", "end", "(", ")", ";", "if", "(", "!", "LastInstInFunction", ")", "{", "std", "::", "pair", "<", "Iter", ",", "bool", ">", "Res", "=", "getNextMachineInstr", "(", "std", "::", "next", "(", "I", ")", ",", "&", "*", "FI", ")", ";", "LastInstInFunction", "|=", "Res", ".", "second", ";", "Inst", "=", "Res", ".", "first", ";", "}", "if", "(", "LastInstInFunction", "||", "!", "TII", "->", "SafeInForbiddenSlot", "(", "*", "Inst", ")", ")", "{", "Changed", "=", "true", ";", "MIBundleBuilder", "(", "&", "*", "I", ")", ".", "append", "(", "BuildMI", "(", "MF", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Mips", "::", "NOP", ")", ")", ")", ";", "NumInsertedNops", "++", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::NOP" ]

[]

[ "<s>", "static", "bool", "arm_cxx_key_method_may_be_inline", "(", "void", ")", "{", "return", "!", "TARGET_AAPCS_BASED", ";", "}", "</s>" ]

[ "The", "EABI", "says", "that", "an", "inline", "function", "may", "never", "be", "the", "key", "method", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "*", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "if", "(", "convertAddSubFlagsOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "ARM", "ARM", "\"Pseudo flag setting opcodes only exist in Selection DAG\"" ]

[]

[ "<s>", "void", "TOYInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "TOY", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::STR", "0" ]

[]

[ "<s>", "bool", "AArch64LoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "expand_csky_stack_adjust", "(", "int", "offset", ")", "{", "rtx", "set", ";", "rtx_insn", "*", "insn", ";", "int", "size", "=", "(", "offset", ">", "0", "?", "offset", ":", "-", "offset", ")", ";", "if", "(", "offset", "==", "0", ")", "return", ";", "if", "(", "size", ">", "CSKY_MAX_SP_ADJUST", "*", "2", ")", "{", "rtx", "tmp", ",", "dwarf", ";", "gcc_assert", "(", "cfun", "->", "machine", "->", "reg_size", "!=", "0", "&&", "(", "cfun", "->", "machine", "->", "reg_mask", "&", "(", "1", "<<", "CSKY_STACKADJUST_REGNUM", ")", ")", ")", ";", "if", "(", "!", "flag_sched_prolog", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "CSKY_STACKADJUST_REGNUM", ")", ";", "emit_move_insn", "(", "tmp", ",", "GEN_INT", "(", "size", ")", ")", ";", "if", "(", "offset", ">", "0", ")", "set", "=", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ";", "else", "set", "=", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ";", "insn", "=", "emit_insn", "(", "set", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "dwarf", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "if", "(", "!", "flag_sched_prolog", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "else", "while", "(", "size", ")", "{", "int", "delta", "=", "(", "size", ">", "CSKY_MAX_SP_ADJUST", "?", "CSKY_MAX_SP_ADJUST", ":", "size", ")", ";", "if", "(", "offset", ">", "0", ")", "set", "=", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "delta", ")", ")", ";", "else", "set", "=", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "delta", ")", ")", ";", "insn", "=", "emit_insn", "(", "set", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "size", "-=", "delta", ";", "}", "}", "</s>" ]

[ "Adjust", "the", "stack", "pointer", "by", "OFFSET", "bytes", ".", "OFFSET", "is", "negative", "if", "this", "is", "in", "the", "prologue", ",", "positive", "if", "in", "the", "epilogue", ".", "This", "may", "require", "multiple", "instructions", "and/or", "use", "of", "CSKY_STACKADJUST_REGNUM", "as", "a", "scratch", "register", ".", "Emit", "CFA", "notes", "as", "appropriate", "." ]

[ "csky", "0", "0", "2", "0", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "smul_with_overflow", ":", "case", "Intrinsic", "::", "umul_with_overflow", ":", "if", "(", "Idx", "==", "1", ")", "{", "unsigned", "NumConstants", "=", "(", "BitSize", "+", "63", ")", "/", "64", ";", "unsigned", "Cost", "=", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "return", "(", "Cost", "<=", "NumConstants", "*", "TTI", "::", "TCC_Basic", ")", "?", "static_cast", "<", "unsigned", ">", "(", "TTI", "::", "TCC_Free", ")", ":", "Cost", ";", "}", "break", ";", "case", "Intrinsic", "::", "experimental_stackmap", ":", "if", "(", "(", "Idx", "<", "2", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_patchpoint_void", ":", "case", "Intrinsic", "::", "experimental_patchpoint_i64", ":", "if", "(", "(", "Idx", "<", "4", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "}", "return", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "AArch64", "AArch64", "Intrinsic::ID", "0", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::smul_with_overflow", "Intrinsic::umul_with_overflow", "1", "63", "64", "AArch64", "Intrinsic::experimental_stackmap", "2", "64", "64", "Intrinsic::experimental_patchpoint_void", "Intrinsic::experimental_patchpoint_i64", "4", "64", "64", "AArch64" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "XNACK_MASK", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "LDS_DIRECT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP12_TTMP13", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP14_TTMP15", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "unsigned", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::XNACK_MASK", "AMDGPU::LDS_DIRECT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::TTMP12_TTMP13", "AMDGPU::TTMP14_TTMP15", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "Value", "*", "PPCTargetLowering", "::", "emitMaskedAtomicCmpXchgIntrinsic", "(", "IRBuilderBase", "&", "Builder", ",", "AtomicCmpXchgInst", "*", "CI", ",", "Value", "*", "AlignedAddr", ",", "Value", "*", "CmpVal", ",", "Value", "*", "NewVal", ",", "Value", "*", "Mask", ",", "AtomicOrdering", "Ord", ")", "const", "{", "assert", "(", "EnableQuadwordAtomics", "&&", "Subtarget", ".", "hasQuadwordAtomics", "(", ")", "&&", "\"Only support quadword now\"", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "CmpVal", "->", "getType", "(", ")", ";", "assert", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", ";", "Function", "*", "IntCmpXchg", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "ppc_cmpxchg_i128", ")", ";", "Type", "*", "Int64Ty", "=", "Type", "::", "getInt64Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "CmpLo", "=", "Builder", ".", "CreateTrunc", "(", "CmpVal", ",", "Int64Ty", ",", "\"cmp_lo\"", ")", ";", "Value", "*", "CmpHi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "CmpVal", ",", "64", ")", ",", "Int64Ty", ",", "\"cmp_hi\"", ")", ";", "Value", "*", "NewLo", "=", "Builder", ".", "CreateTrunc", "(", "NewVal", ",", "Int64Ty", ",", "\"new_lo\"", ")", ";", "Value", "*", "NewHi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "NewVal", ",", "64", ")", ",", "Int64Ty", ",", "\"new_hi\"", ")", ";", "Value", "*", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "AlignedAddr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "emitLeadingFence", "(", "Builder", ",", "CI", ",", "Ord", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "IntCmpXchg", ",", "{", "Addr", ",", "CmpLo", ",", "CmpHi", ",", "NewLo", ",", "NewHi", "}", ")", ";", "emitTrailingFence", "(", "Builder", ",", "CI", ",", "Ord", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "</s>" ]

[ "Perform", "a", "masked", "cmpxchg", "using", "a", "target-specific", "intrinsic", "." ]

[ "PowerPC", "PPC", "\"Only support quadword now\"", "128", "Intrinsic::getDeclaration", "Intrinsic::ppc_cmpxchg_i128", "\"cmp_lo\"", "64", "\"cmp_hi\"", "\"new_lo\"", "64", "\"new_hi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "printAndVerify", "(", "\"After ARM load / store optimizer\"", ")", ";", "}", "if", "(", "(", "DisableA15SDOptimization", "||", "!", "getARMSubtarget", "(", ")", ".", "isCortexA15", "(", ")", ")", "&&", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"After ARM load / store optimizer\"", "ARM", "ARM", "ARM::DPRRegClass", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createARMISelDag", "(", "getARMTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MSP430FrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "FPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "llvm", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::FPW", "MSP430::MOV16rr", "MSP430::FPW", "MSP430::SPW", "MSP430::FPW", "MSP430", "MSP430::PUSH16r", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "static", "rtx", "arm_gen_store_multiple_1", "(", "int", "count", ",", "int", "*", "regs", ",", "rtx", "*", "mems", ",", "rtx", "basereg", ",", "HOST_WIDE_INT", "wback_offset", ")", "{", "int", "i", "=", "0", ",", "j", ";", "rtx", "result", ";", "if", "(", "GET_CODE", "(", "basereg", ")", "==", "PLUS", ")", "basereg", "=", "XEXP", "(", "basereg", ",", "0", ")", ";", "if", "(", "!", "multiple_operation_profitable_p", "(", "false", ",", "count", ",", "0", ")", ")", "{", "rtx", "seq", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "emit_move_insn", "(", "mems", "[", "i", "]", ",", "gen_rtx_REG", "(", "SImode", ",", "regs", "[", "i", "]", ")", ")", ";", "if", "(", "wback_offset", "!=", "0", ")", "emit_move_insn", "(", "basereg", ",", "plus_constant", "(", "Pmode", ",", "basereg", ",", "wback_offset", ")", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "seq", ";", "}", "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "(", "wback_offset", "!=", "0", "?", "1", ":", "0", ")", ")", ")", ";", "if", "(", "wback_offset", "!=", "0", ")", "{", "XVECEXP", "(", "result", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "basereg", ",", "plus_constant", "(", "Pmode", ",", "basereg", ",", "wback_offset", ")", ")", ";", "i", "=", "1", ";", "count", "++", ";", "}", "for", "(", "j", "=", "0", ";", "i", "<", "count", ";", "i", "++", ",", "j", "++", ")", "XVECEXP", "(", "result", ",", "0", ",", "i", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "mems", "[", "j", "]", ",", "gen_rtx_REG", "(", "SImode", ",", "regs", "[", "j", "]", ")", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Generate", "a", "store-multiple", "instruction", ".", "COUNT", "is", "the", "number", "of", "stores", "in", "the", "instruction", ";", "REGS", "and", "MEMS", "are", "arrays", "containing", "the", "operands", ".", "BASEREG", "is", "the", "base", "register", "to", "be", "used", "in", "addressing", "the", "memory", "operands", ".", "WBACK_OFFSET", "is", "nonzero", "if", "the", "instruction", "should", "update", "the", "base", "register", "." ]

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

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getCacheLineSize", "(", ")", "{", "if", "(", "CacheLineSize", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "return", "CacheLineSize", ";", "unsigned", "Mcpu", "=", "ST", "->", "getMcpu", "(", ")", ";", "if", "(", "Mcpu", "==", "PPC", "::", "MCPU_PWR7", "||", "Mcpu", "==", "PPC", "::", "MCPU_PWR8", "||", "Mcpu", "==", "PPC", "::", "MCPU_PWR9", ")", "return", "128", ";", "return", "64", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "PowerPC", "PPC", "0", "PPC::MCPU_PWR7", "PPC::MCPU_PWR8", "PPC::MCPU_PWR9", "128", "64" ]

[]

[ "<s>", "void", "RISCVAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Kind", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "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", "." ]

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

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "reservedPrivateSegmentBufferReg", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "hasSGPRInitBug", "(", ")", ")", "{", "unsigned", "BaseIdx", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "4", "-", "4", ";", "unsigned", "BaseReg", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "BaseIdx", ")", ")", ";", "return", "getMatchingSuperReg", "(", "BaseReg", ",", "AMDGPU", "::", "sub0", ",", "&", "AMDGPU", "::", "SReg_128RegClass", ")", ";", "}", "if", "(", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "return", "AMDGPU", "::", "SGPR92_SGPR93_SGPR94_SGPR95", ";", "}", "return", "AMDGPU", "::", "SGPR96_SGPR97_SGPR98_SGPR99", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "rs6000_expand_atomic_exchange", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "retval", ",", "mem", ",", "val", ",", "cond", ";", "machine_mode", "mode", ";", "enum", "memmodel", "model", ";", "rtx", "label", ",", "x", ",", "mask", ",", "shift", ";", "retval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "model", "=", "memmodel_base", "(", "INTVAL", "(", "operands", "[", "3", "]", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "mask", "=", "shift", "=", "NULL_RTX", ";", "if", "(", "!", "TARGET_SYNC_HI_QI", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", ")", "{", "mem", "=", "rs6000_adjust_atomic_subword", "(", "mem", ",", "&", "shift", ",", "&", "mask", ")", ";", "val", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "val", ",", "1", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "val", ",", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "retval", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mode", "=", "SImode", ";", "}", "mem", "=", "rs6000_pre_atomic_barrier", "(", "mem", ",", "model", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "val", ";", "if", "(", "mask", ")", "x", "=", "rs6000_mask_atomic_subword", "(", "retval", ",", "val", ",", "mask", ")", ";", "cond", "=", "gen_reg_rtx", "(", "CCmode", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "x", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "rs6000_post_atomic_barrier", "(", "model", ")", ";", "if", "(", "shift", ")", "rs6000_finish_atomic_subword", "(", "operands", "[", "0", "]", ",", "retval", ",", "shift", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "exchange", "operation", "." ]

[ "rs6000", "0", "1", "2", "3", "1", "1", "0", "0" ]

[]

[ "<s>", "void", "BTFDebug", "::", "endModule", "(", ")", "{", "const", "Module", "*", "M", "=", "MMI", "->", "getModule", "(", ")", ";", "for", "(", "const", "DICompileUnit", "*", "CUNode", ":", "M", "->", "debug_compile_units", "(", ")", ")", "{", "for", "(", "const", "auto", "*", "GVE", ":", "CUNode", "->", "getGlobalVariables", "(", ")", ")", "{", "DIGlobalVariable", "*", "GV", "=", "GVE", "->", "getVariable", "(", ")", ";", "visitTypeEntry", "(", "GV", "->", "getType", "(", ")", ".", "resolve", "(", ")", ")", ";", "}", "}", "for", "(", "const", "auto", "&", "TypeEntry", ":", "TypeEntries", ")", "TypeEntry", "->", "completeType", "(", "*", "this", ")", ";", "emitBTFSection", "(", ")", ";", "emitBTFExtSection", "(", ")", ";", "}", "</s>" ]

[ "Emit", "all", "exception", "information", "that", "should", "come", "after", "the", "content", "." ]

[ "BPF" ]

[]

[ "<s>", "void", "AMDGPUInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "!", "\"Not Implemented\"", ")", ";", "}", "</s>" ]

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

[ "R600", "\"Not Implemented\"" ]

[]

[ "<s>", "static", "void", "rs6000_debug_target_options", "(", "tree", "args", ",", "const", "char", "*", "prefix", ")", "{", "if", "(", "args", "==", "NULL_TREE", ")", "fprintf", "(", "stderr", ",", "\"%s<NULL>\"", ",", "prefix", ")", ";", "else", "if", "(", "TREE_CODE", "(", "args", ")", "==", "STRING_CST", ")", "{", "char", "*", "p", "=", "ASTRDUP", "(", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "char", "*", "q", ";", "while", "(", "(", "q", "=", "strtok", "(", "p", ",", "\",\"", ")", ")", "!=", "NULL", ")", "{", "p", "=", "NULL", ";", "fprintf", "(", "stderr", ",", "\"%s\\\"%s\\\"\"", ",", "prefix", ",", "q", ")", ";", "prefix", "=", "\", \"", ";", "}", "}", "else", "if", "(", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", ")", "{", "do", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "value", ")", "{", "rs6000_debug_target_options", "(", "value", ",", "prefix", ")", ";", "prefix", "=", "\", \"", ";", "}", "args", "=", "TREE_CHAIN", "(", "args", ")", ";", "}", "while", "(", "args", "!=", "NULL_TREE", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", ";", "}", "</s>" ]

[ "Print", "out", "the", "target", "options", "as", "a", "list", "for", "-mdebug=target", "." ]

[ "powerpcspe", "\"%s<NULL>\"", "\",\"", "\"%s\\\"%s\\\"\"", "\", \"", "\", \"" ]

[]

[ "<s>", "static", "void", "insert_wic_for_ilb_runout", "(", "rtx_insn", "*", "first", ")", "{", "rtx_insn", "*", "insn", ";", "rtx_insn", "*", "before_4", "=", "0", ";", "rtx_insn", "*", "before_16", "=", "0", ";", "int", "addr_offset", "=", "0", ";", "int", "length", ";", "int", "wic_addr0", "=", "128", "*", "4", ";", "int", "wic_addr1", "=", "128", "*", "4", ";", "int", "first_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "first", ")", ")", ";", "for", "(", "insn", "=", "first", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "addr_offset", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "-", "first_addr", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "before_4", "==", "0", "&&", "addr_offset", "+", "length", ">=", "4", "*", "4", ")", "before_4", "=", "insn", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "return", ";", "if", "(", "before_16", "==", "0", "&&", "addr_offset", "+", "length", ">=", "14", "*", "4", ")", "before_16", "=", "insn", ";", "if", "(", "CALL_P", "(", "insn", ")", "||", "tablejump_p", "(", "insn", ",", "0", ",", "0", ")", ")", "return", ";", "if", "(", "addr_offset", "+", "length", ">=", "32", "*", "4", ")", "{", "gcc_assert", "(", "before_4", "&&", "before_16", ")", ";", "if", "(", "wic_addr0", ">", "4", "*", "4", ")", "{", "insn", "=", "emit_insn_before", "(", "gen_iprefetch", "(", "gen_int_mode", "(", "addr_offset", ",", "SImode", ")", ")", ",", "before_4", ")", ";", "recog_memoized", "(", "insn", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "INSN_LOCATION", "(", "before_4", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "before_4", ")", ")", ")", ";", "return", ";", "}", "}", "}", "}", "</s>" ]

[ "Heuristics", "to", "identify", "where", "to", "insert", "at", "the", "fall", "through", "path", "of", "the", "caller", "function", ".", "If", "there", "is", "a", "call", "after", "the", "caller", "branch", "delay", "slot", "then", "we", "dont", "generate", "the", "instruction", "prefetch", "instruction", ".", "Scan", "up", "to", "32", "instructions", "after", "the", "call", "and", "checks", "for", "the", "JUMP", "and", "call", "instruction", ".", "If", "there", "is", "a", "call", "or", "JUMP", "instruction", "in", "the", "range", "of", "32", "instruction", "``", "wic", "''", "instruction", "wont", "be", "generated", ".", "Otherwise", "insert", "the", "``", "wic", "''", "instruction", "in", "the", "fall", "through", "of", "the", "call", "instruction", "four", "instruction", "after", "the", "call", ".", "before_4", "is", "used", "for", "the", "position", "to", "insert", "``", "wic", "''", "instructions", ".", "before_16", "is", "used", "to", "check", "for", "call", "and", "JUMP", "instruction", "for", "first", "15", "insns", "." ]

[ "microblaze", "0", "0", "0", "128", "4", "128", "4", "0", "4", "4", "0", "14", "4", "0", "0", "32", "4", "4", "4" ]

[]

[ "<s>", "StringRef", "MipsInstPrinter", "::", "getOpcodeName", "(", "unsigned", "Opcode", ")", "const", "{", "return", "getInstructionName", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "representation", "for", "an", "opcode", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"TVM Argument Move\"", ";", "}", "</s>" ]

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

[ "TVM", "\"TVM Argument Move\"" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin_movtf", "(", "enum", "mips_builtin_type", "type", ",", "enum", "insn_code", "icode", ",", "enum", "mips_fp_condition", "cond", ",", "rtx", "target", ",", "tree", "arglist", ")", "{", "rtx", "cmp_result", ",", "op0", ",", "op1", ";", "cmp_result", "=", "mips_prepare_builtin_target", "(", "icode", ",", "0", ",", "0", ")", ";", "op0", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "1", ",", "&", "arglist", ")", ";", "op1", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "2", ",", "&", "arglist", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "cmp_result", ",", "op0", ",", "op1", ",", "GEN_INT", "(", "cond", ")", ")", ")", ";", "icode", "=", "CODE_FOR_mips_cond_move_tf_ps", ";", "target", "=", "mips_prepare_builtin_target", "(", "icode", ",", "0", ",", "target", ")", ";", "if", "(", "type", "==", "MIPS_BUILTIN_MOVT", ")", "{", "op1", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "2", ",", "&", "arglist", ")", ";", "op0", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "1", ",", "&", "arglist", ")", ";", "}", "else", "{", "op0", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "1", ",", "&", "arglist", ")", ";", "op1", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "2", ",", "&", "arglist", ")", ";", "}", "emit_insn", "(", "gen_mips_cond_move_tf_ps", "(", "target", ",", "op0", ",", "op1", ",", "cmp_result", ")", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "__builtin_mips_movt_", "*", "_ps", "(", ")", "or", "__builtin_mips_movf_", "*", "_ps", "(", ")", "function", "(", "TYPE", "says", "which", ")", ".", "ARGLIST", "is", "the", "list", "of", "arguments", "to", "the", "function", ",", "ICODE", "is", "the", "instruction", "that", "should", "be", "used", "to", "compare", "the", "first", "two", "arguments", ",", "and", "COND", "is", "the", "condition", "it", "should", "test", ".", "TARGET", ",", "if", "nonnull", ",", "suggests", "a", "good", "place", "to", "put", "the", "result", "." ]

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

[]

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

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "X86", "0", "0", "0", "MVT::i1", "MVT::i1", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "i386_pe_strip_name_encoding", "(", "const", "char", "*", "str", ")", "{", "if", "(", "strncmp", "(", "str", ",", "DLL_IMPORT_PREFIX", ",", "strlen", "(", "DLL_IMPORT_PREFIX", ")", ")", "==", "0", ")", "str", "+=", "strlen", "(", "DLL_IMPORT_PREFIX", ")", ";", "else", "if", "(", "strncmp", "(", "str", ",", "DLL_EXPORT_PREFIX", ",", "strlen", "(", "DLL_EXPORT_PREFIX", ")", ")", "==", "0", ")", "str", "+=", "strlen", "(", "DLL_EXPORT_PREFIX", ")", ";", "if", "(", "*", "str", "==", "'*'", ")", "str", "+=", "1", ";", "return", "str", ";", "}", "</s>" ]

[ "Strip", "only", "the", "leading", "encoding", ",", "leaving", "the", "stdcall", "suffix", "and", "fastcall", "prefix", "if", "it", "exists", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_pac_insn_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "INSN_P", "(", "x", ")", ")", "return", "x", ";", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "PATTERN", "(", "x", ")", ",", "ALL", ")", "{", "rtx", "sub", "=", "*", "iter", ";", "if", "(", "sub", "&&", "GET_CODE", "(", "sub", ")", "==", "UNSPEC", ")", "{", "int", "unspec_val", "=", "XINT", "(", "sub", ",", "1", ")", ";", "switch", "(", "unspec_val", ")", "{", "case", "UNSPEC_PACISP", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "X", "(", "or", "any", "sub-rtx", "of", "X", ")", "is", "a", "PACIASP/PACIBSP", "instruction", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "int", "scalar_chain", "::", "convert", "(", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "int", "converted_insns", "=", "0", ";", "if", "(", "!", "dbg_cnt", "(", "stv_conversion", ")", ")", "return", "0", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Converting chain #%d...\\n\"", ",", "chain_id", ")", ";", "convert_registers", "(", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "insns", ",", "0", ",", "id", ",", "bi", ")", "{", "convert_insn", "(", "DF_INSN_UID_GET", "(", "id", ")", "->", "insn", ")", ";", "converted_insns", "++", ";", "}", "return", "converted_insns", ";", "}", "</s>" ]

[ "Convert", "whole", "chain", "creating", "required", "register", "conversions", "and", "copies", "." ]

[ "i386", "0", "0", "\"Converting chain #%d...\\n\"", "0" ]

[]

[ "<s>", "static", "bool", "msp430_no_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "int", "i", ";", "if", "(", "msp430_hwmult_type", "==", "MSP430_HWMULT_NONE", ")", "return", "true", ";", "if", "(", "msp430_hwmult_type", "!=", "MSP430_HWMULT_AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "NULL", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "msp430_mcu_data", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "target_mcu", ",", "msp430_mcu_data", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "cached_result", "=", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", "==", "0", ";", "return", "cached_result", "=", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "does", "not", "have", "a", "hardware", "multiplier", "of", "any", "kind", "." ]

[ "msp430", "0", "0" ]

[]

[ "<s>", "static", "bool", "isImm", "(", "const", "MachineOperand", "&", "MO", ",", "MachineRegisterInfo", "*", "MRI", ")", "{", "assert", "(", "MO", ".", "isReg", "(", ")", ")", ";", "const", "SPIRVType", "*", "TypeInst", "=", "MRI", "->", "getVRegDef", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "TypeInst", "->", "getOpcode", "(", ")", "!=", "SPIRV", "::", "ASSIGN_TYPE", ")", "return", "false", ";", "assert", "(", "TypeInst", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", ";", "MachineInstr", "*", "ImmInst", "=", "MRI", "->", "getVRegDef", "(", "TypeInst", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "return", "ImmInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_CONSTANT", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "SPIRV", "SPIRV", "SPIRV::ASSIGN_TYPE", "1", "1" ]

[]

[ "<s>", "void", "visium_expand_int_cstore", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "0", "]", ",", "op1", "=", "operands", "[", "2", "]", ",", "op2", "=", "operands", "[", "3", "]", ",", "sltu", ";", "bool", "reverse", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "force_reg", "(", "mode", ",", "gen_rtx_XOR", "(", "mode", ",", "op1", ",", "op2", ")", ")", ";", "op1", "=", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ";", "op2", "=", "constm1_rtx", ";", "if", "(", "code", "==", "EQ", ")", "reverse", "=", "true", ";", "break", ";", "case", "LEU", ":", "case", "GEU", ":", "code", "=", "reverse_condition", "(", "code", ")", ";", "reverse", "=", "true", ";", "case", "LTU", ":", "case", "GTU", ":", "if", "(", "code", "==", "GTU", ")", "{", "rtx", "tmp", "=", "op1", ";", "op1", "=", "op2", ";", "op2", "=", "tmp", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sltu", "=", "gen_rtx_LTU", "(", "SImode", ",", "op1", ",", "op2", ")", ";", "if", "(", "reverse", ")", "{", "rtx", "tmp", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_rtx_NEG", "(", "SImode", ",", "sltu", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "op0", ",", "tmp", ",", "const1_rtx", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "sltu", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "cstore", "of", "OPERANDS", "in", "MODE", "for", "EQ/NE/LTU/GTU/GEU/LEU", ".", "We", "generate", "the", "result", "in", "the", "C", "flag", "and", "use", "the", "ADC/SUBC", "instructions", "to", "write", "it", "into", "the", "destination", "register", ".", "It", "would", "also", "be", "possible", "to", "implement", "support", "for", "LT/GT/LE/GE", "by", "means", "of", "the", "RFLAG", "instruction", "followed", "by", "some", "shifts", ",", "but", "this", "can", "pessimize", "the", "generated", "code", "." ]

[ "visium", "1", "0", "2", "3" ]

[]

[ "<s>", "static", "reg_class_t", "visium_secondary_reload", "(", "bool", "in_p", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "reg_class_t", "rclass", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "secondary_reload_info", "*", "sri", "ATTRIBUTE_UNUSED", ")", "{", "int", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "regno", "==", "-", "1", "&&", "(", "rclass", "==", "MDB", "||", "rclass", "==", "MDC", "||", "rclass", "==", "FP_REGS", ")", ")", "return", "GENERAL_REGS", ";", "else", "if", "(", "(", "(", "regno", "==", "R_MDB", "||", "regno", "==", "R_MDC", ")", "&&", "rclass", "==", "FP_REGS", ")", "||", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "rclass", "==", "MDB", "||", "rclass", "==", "MDC", ")", ")", ")", "return", "GENERAL_REGS", ";", "else", "if", "(", "(", "regno", "==", "R_MDB", "&&", "rclass", "==", "MDC", ")", "||", "(", "rclass", "==", "MDB", "&&", "regno", "==", "R_MDC", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "required", "for", "an", "intermediate", "register", "used", "to", "copy", "a", "register", "of", "RCLASS", "from/to", "X", ".", "If", "no", "such", "intermediate", "register", "is", "required", ",", "return", "NO_REGS", ".", "If", "more", "than", "one", "such", "intermediate", "register", "is", "required", ",", "describe", "the", "one", "that", "is", "closest", "in", "the", "copy", "chain", "to", "the", "reload", "register", "." ]

[ "visium", "1" ]

[]

[ "<s>", "bool", "AMDGPUAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "OS", ".", "write_zeros", "(", "Count", "%", "4", ")", ";", "Count", "/=", "4", ";", "const", "uint32_t", "Encoded_S_NOP_0", "=", "0xbf800000", ";", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "!=", "Count", ";", "++", "I", ")", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Encoded_S_NOP_0", ",", "Endian", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "4", "4", "0xbf800000", "0", "support::endian" ]

[]

[ "<s>", "static", "inline", "const", "MachineInstrBuilder", "&", "addMemOperand", "(", "const", "MachineInstrBuilder", "&", "MIB", ",", "int", "FI", ",", "int", "Offset", "=", "0", ")", "{", "MachineInstr", "*", "MI", "=", "MIB", ";", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "auto", "Flags", "=", "MachineMemOperand", "::", "MONone", ";", "if", "(", "MCID", ".", "mayLoad", "(", ")", ")", "Flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "if", "(", "MCID", ".", "mayStore", "(", ")", ")", "Flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ",", "Offset", ")", ",", "Flags", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "return", "MIB", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Add", "a", "MachineMemOperand", "to", "the", "machine", "instruction", "." ]

[ "M680x0", "0" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "RISCVFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "size_t", "Reg", "=", "0", ";", "Reg", "<", "getNumRegs", "(", ")", ";", "Reg", "++", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCVABI", "::", "getBPReg", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VL", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VTYPE", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VXSAT", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VXRM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FRM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FFLAGS", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FCSR", ")", ";", "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", "0", "RISCV", "RISCV::X0", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8", "RISCVABI::getBPReg", "RISCV::VL", "RISCV::VTYPE", "RISCV::VXSAT", "RISCV::VXRM", "RISCV::FRM", "RISCV::FFLAGS", "RISCV::FCSR" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "Subtarget", "->", "isABI_O32", "(", ")", ",", "Subtarget", "->", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", "->", "abiUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "Subtarget", "->", "isABI_N64", "(", ")", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "Mips", "Mips", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0_64", "Mips::V0", "1", "0", "MipsISD::Ret", "MVT::Other" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Register Coloring\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Register Coloring\"" ]

[]

[ "<s>", "void", "BlackfinFrameInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "BlackfinRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "BlackfinRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "BlackfinInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "BlackfinInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "assert", "(", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "\"FP elimination on a non-leaf function is not supported\"", ")", ";", "RegInfo", "->", "adjustRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "FrameSize", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "UNLINK", ")", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "4", "0", "\"Misaligned frame size\"", "\"FP elimination on a non-leaf function is not supported\"", "BF::SP", "BF::P1", "BF::UNLINK" ]

[]

[ "<s>", "static", "rtx", "mips_pic_call_symbol_from_set", "(", "df_ref", "def", ",", "rtx", "reg", ",", "bool", "recurse_p", ")", "{", "rtx_insn", "*", "def_insn", ";", "rtx", "set", ";", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "def", ")", ")", "return", "NULL_RTX", ";", "def_insn", "=", "DF_REF_INSN", "(", "def", ")", ";", "set", "=", "single_set", "(", "def_insn", ")", ";", "if", "(", "set", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "set", ")", ",", "reg", ")", ")", "{", "rtx", "note", ",", "src", ",", "symbol", ";", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "SYMBOL_REF", ")", "return", "src", ";", "symbol", "=", "mips_strip_unspec_call", "(", "src", ")", ";", "if", "(", "symbol", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "symbol", ")", "==", "SYMBOL_REF", ")", ";", "return", "symbol", ";", "}", "note", "=", "find_reg_equal_equiv_note", "(", "def_insn", ")", ";", "if", "(", "note", "&&", "GET_CODE", "(", "XEXP", "(", "note", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "return", "XEXP", "(", "note", ",", "0", ")", ";", "if", "(", "recurse_p", "&&", "REG_P", "(", "src", ")", ")", "return", "mips_find_pic_call_symbol", "(", "def_insn", ",", "src", ",", "false", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "REG", "is", "set", "in", "DEF", ".", "See", "if", "the", "definition", "is", "one", "of", "the", "ways", "we", "load", "a", "register", "with", "a", "symbol", "address", "for", "a", "mips_use_pic_fn_addr_reg_p", "call", ".", "If", "it", "is", ",", "return", "the", "symbol", "reference", "of", "the", "function", ",", "otherwise", "return", "NULL_RTX", ".", "If", "RECURSE_P", "is", "true", ",", "use", "mips_find_pic_call_symbol", "to", "interpret", "the", "values", "of", "source", "registers", ",", "otherwise", "treat", "such", "registers", "as", "having", "an", "unknown", "value", "." ]

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

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "LEG", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_leg_mov_hi16_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_leg_mov_lo16_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "{", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "}", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "LEG", "LEG::NumTargetFixupKinds", "\"fixup_leg_mov_hi16_pcrel\"", "0", "32", "\"fixup_leg_mov_lo16_pcrel\"", "0", "32", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "rtx", "sh_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "BASE_RETURN_VALUE_REG", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_LIBCALL_VALUE", "." ]

[ "sh" ]

[]

[ "<s>", "static", "rtx", "rs6000_mixed_function_arg", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "int", "align_words", ")", "{", "int", "n_units", ";", "int", "i", ",", "k", ";", "rtx", "rvec", "[", "GP_ARG_NUM_REG", "+", "1", "]", ";", "if", "(", "align_words", ">=", "GP_ARG_NUM_REG", ")", "return", "NULL_RTX", ";", "n_units", "=", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "n_units", "==", "0", "||", "(", "n_units", "==", "1", "&&", "mode", "!=", "BLKmode", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "k", "=", "0", ";", "if", "(", "align_words", "+", "n_units", ">", "GP_ARG_NUM_REG", ")", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "i", "=", "0", ";", "do", "{", "rtx", "r", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "rtx", "off", "=", "GEN_INT", "(", "i", "++", "*", "4", ")", ";", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "r", ",", "off", ")", ";", "}", "while", "(", "++", "align_words", "<", "GP_ARG_NUM_REG", "&&", "--", "n_units", "!=", "0", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "k", ",", "rvec", ")", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "place", "an", "argument", "in", "64-bit", "mode", "with", "32-bit", "ABI", "." ]

[ "rs6000", "1", "0", "1", "0", "0", "4", "0" ]

[]

[ "<s>", "bool", "AVRTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "const", "SDNode", "*", "Op", ";", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "const", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Op", "=", "LD", "->", "getBasePtr", "(", ")", ".", "getNode", "(", ")", ";", "if", "(", "LD", "->", "getExtensionType", "(", ")", "!=", "ISD", "::", "NON_EXTLOAD", ")", "return", "false", ";", "if", "(", "AVR", "::", "isProgramMemoryAccess", "(", "LD", ")", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "const", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Op", "=", "ST", "->", "getBasePtr", "(", ")", ".", "getNode", "(", ")", ";", "if", "(", "AVR", "::", "isProgramMemoryAccess", "(", "ST", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "return", "false", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i16", ")", "{", "return", "false", ";", "}", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", "&&", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SUB", ")", "{", "return", "false", ";", "}", "if", "(", "const", "ConstantSDNode", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "{", "int", "RHSC", "=", "RHS", "->", "getSExtValue", "(", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", ")", "RHSC", "=", "-", "RHSC", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i16", "&&", "RHSC", "!=", "-", "2", ")", "||", "(", "VT", "==", "MVT", "::", "i8", "&&", "RHSC", "!=", "-", "1", ")", ")", "{", "return", "false", ";", "}", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "DL", ",", "MVT", "::", "i8", ")", ";", "AM", "=", "ISD", "::", "PRE_DEC", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "AVR", "AVR", "ISD::MemIndexedMode", "ISD::NON_EXTLOAD", "AVR::isProgramMemoryAccess", "AVR::isProgramMemoryAccess", "MVT::i8", "MVT::i16", "ISD::ADD", "ISD::SUB", "1", "ISD::SUB", "MVT::i16", "2", "MVT::i8", "1", "0", "MVT::i8", "ISD::PRE_DEC" ]

[]

[ "<s>", "static", "bool", "mt_interrupt_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "a", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "true", "if", "FUNC", "is", "a", "function", "with", "the", "'interrupt", "'", "attribute", "." ]

[ "mt", "\"interrupt\"" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "if", "(", "Res", ")", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

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

[]

[ "<s>", "void", "WebAssemblyAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "const", "MCFixupKindInfo", "&", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "unsigned", "NumBytes", "=", "RoundUpToAlignment", "(", "Info", ".", "TargetSize", ",", "8", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"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", "." ]

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "ModulePass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "TPCHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "PacketNum", "++", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" *HR* AdvanceCycle(\"", "<<", "PacketNum", "<<", "\")\\n\"", ")", ";", "dumpCurPacket", "(", ")", ";", "clearResources", "(", ")", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "TPC", "TPC", "\" *HR* AdvanceCycle(\"", "\")\\n\"" ]

[]

[ "<s>", "rtx", "gen_acc2", "(", "void", ")", "{", "return", "gen_rtx_REG", "(", "SImode", ",", "TARGET_BIG_ENDIAN", "?", "57", ":", "56", ")", ";", "}", "</s>" ]

[ "Return", "a", "REG", "rtx", "for", "acc2", ".", "N.B", ".", "the", "gcc-internal", "representation", "may", "differ", "from", "the", "hardware", "register", "number", "in", "order", "to", "allow", "the", "generic", "code", "to", "correctly", "split", "the", "concatenation", "of", "acc1", "and", "acc2", "." ]

[ "arc", "57", "56" ]

[]

[ "<s>", "static", "void", "moxie_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "fprintf", "(", "f", ",", "\"\\tpush $sp, $r0\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tldi.l $r0, 0x0\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tsto.l 0x8($fp), $r0\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tpop $sp, $r0\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tjmpa 0x0\\n\"", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_ASM_TRAMPOLINE_TEMPLATE", "." ]

[ "moxie", "\"\\tpush $sp, $r0\\n\"", "\"\\tldi.l $r0, 0x0\\n\"", "\"\\tsto.l 0x8($fp), $r0\\n\"", "\"\\tpop $sp, $r0\\n\"", "\"\\tjmpa 0x0\\n\"" ]

[]

[ "<s>", "static", "bool", "pa_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "PA_HARD_REGNO_MODE_OK", "(", "regno", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "pa" ]

[]

[ "<s>", "static", "int", "tilepro_multiply_get_num_ops", "(", "const", "struct", "tilepro_multiply_insn_seq", "*", "seq", ")", "{", "int", "i", ";", "for", "(", "i", "=", "tilepro_multiply_insn_seq_MAX_OPERATIONS", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "tilepro_multiply_get_opcode", "(", "&", "seq", "->", "op", "[", "i", "]", ")", "!=", "CODE_FOR_nothing", ")", "return", "i", "+", "1", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "length", "of", "the", "'op", "'", "array", "." ]

[ "tilepro", "1", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "M68kTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "case", "'d'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i8", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "M68k", "::", "DR8RegClass", ")", ";", "case", "MVT", "::", "i16", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "M68k", "::", "DR16RegClass", ")", ";", "case", "MVT", "::", "i32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "M68k", "::", "DR32RegClass", ")", ";", "default", ":", "break", ";", "}", "break", ";", "case", "'a'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i16", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "M68k", "::", "AR16RegClass", ")", ";", "case", "MVT", "::", "i32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "M68k", "::", "AR32RegClass", ")", ";", "default", ":", "break", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "1", "0", "MVT::i8", "0U", "M68k::DR8RegClass", "MVT::i16", "0U", "M68k::DR16RegClass", "MVT::i32", "0U", "M68k::DR32RegClass", "MVT::i16", "0U", "M68k::AR16RegClass", "MVT::i32", "0U", "M68k::AR32RegClass" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "shouldRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "return", "false", ";", "return", "TargetRegisterInfo", "::", "shouldRealignStack", "(", "MF", ")", ";", "}", "</s>" ]

[ "True", "if", "storage", "within", "the", "function", "requires", "the", "stack", "pointer", "to", "be", "aligned", "more", "than", "the", "normal", "calling", "convention", "calls", "for", "." ]

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "getTargetMachine", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "return", "false", ";", "if", "(", "isVarArg", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "if", "(", "CalleeCC", "==", "CallingConv", "::", "Fast", "&&", "CallerCC", "==", "CalleeCC", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Ins", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Ins", "[", "i", "]", ".", "Flags", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "}", "if", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "true", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "return", "G", "->", "getGlobal", "(", ")", "->", "hasHiddenVisibility", "(", ")", "||", "G", "->", "getGlobal", "(", ")", "->", "hasProtectedVisibility", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "PowerPC", "PPC", "ISD::InputArg", "0", "ISD::ArgFlagsTy" ]

[]

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

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "s390_extzv_shift_ok", "(", "int", "bitsize", ",", "int", "rotl", ",", "unsigned", "HOST_WIDE_INT", "contig", ")", "{", "int", "pos", ",", "len", ";", "bool", "ok", ";", "ok", "=", "s390_contiguous_bitmask_p", "(", "contig", ",", "bitsize", ",", "&", "pos", ",", "&", "len", ")", ";", "gcc_assert", "(", "ok", ")", ";", "return", "(", "(", "rotl", ">=", "0", "&&", "rotl", "<=", "pos", ")", "||", "(", "rotl", "<", "0", "&&", "-", "rotl", "<=", "bitsize", "-", "len", "-", "pos", ")", ")", ";", "}", "</s>" ]

[ "Check", "whether", "a", "rotate", "of", "ROTL", "followed", "by", "an", "AND", "of", "CONTIG", "is", "equivalent", "to", "a", "shift", "followed", "by", "the", "AND", ".", "In", "particular", ",", "CONTIG", "should", "not", "overlap", "the", "(", "rotated", ")", "bit", "0/bit", "63", "gap", ".", "Negative", "values", "for", "ROTL", "indicate", "a", "rotate", "to", "the", "right", "." ]

[ "s390", "0", "0" ]

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BRANCH", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "BranchPredicate", "Pred", "=", "getBranchPredicate", "(", "I", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "Pred", "==", "INVALID_BR", ")", "return", "true", ";", "MachineBasicBlock", "*", "CondBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Pred", ")", ")", ";", "++", "I", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "{", "TBB", "=", "CondBB", ";", "return", "false", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BRANCH", ")", "{", "TBB", "=", "CondBB", ";", "FBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::S_BRANCH", "0", "0", "AMDGPU::S_BRANCH", "0" ]

[]

[ "<s>", "bool", "s390_expand_insv", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "src", ")", "{", "int", "bitsize", "=", "INTVAL", "(", "op1", ")", ";", "int", "bitpos", "=", "INTVAL", "(", "op2", ")", ";", "if", "(", "bitsize", "%", "BITS_PER_UNIT", ")", "return", "false", ";", "if", "(", "bitpos", "==", "0", "&&", "memory_operand", "(", "dest", ",", "VOIDmode", ")", "&&", "(", "register_operand", "(", "src", ",", "word_mode", ")", "||", "const_int_operand", "(", "src", ",", "VOIDmode", ")", ")", ")", "{", "enum", "machine_mode", "mode", "=", "smallest_mode_for_size", "(", "bitsize", ",", "MODE_INT", ")", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "bitsize", ")", "emit_move_insn", "(", "adjust_address", "(", "dest", ",", "mode", ",", "0", ")", ",", "gen_lowpart", "(", "mode", ",", "src", ")", ")", ";", "else", "if", "(", "const_int_operand", "(", "src", ",", "VOIDmode", ")", ")", "{", "int", "size", "=", "bitsize", "/", "BITS_PER_UNIT", ";", "rtx", "src_mem", "=", "adjust_address", "(", "force_const_mem", "(", "word_mode", ",", "src", ")", ",", "BLKmode", ",", "GET_MODE_SIZE", "(", "word_mode", ")", "-", "size", ")", ";", "dest", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "0", ")", ";", "set_mem_size", "(", "dest", ",", "GEN_INT", "(", "size", ")", ")", ";", "s390_expand_movmem", "(", "dest", ",", "src_mem", ",", "GEN_INT", "(", "size", ")", ")", ";", "}", "else", "if", "(", "register_operand", "(", "src", ",", "word_mode", ")", ")", "{", "if", "(", "bitsize", "<=", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", "emit_move_insn", "(", "gen_rtx_ZERO_EXTRACT", "(", "word_mode", ",", "dest", ",", "op1", ",", "const0_rtx", ")", ",", "src", ")", ";", "else", "{", "int", "stcmh_width", "=", "bitsize", "-", "GET_MODE_BITSIZE", "(", "SImode", ")", ";", "int", "size", "=", "stcmh_width", "/", "BITS_PER_UNIT", ";", "emit_move_insn", "(", "adjust_address", "(", "dest", ",", "SImode", ",", "size", ")", ",", "gen_lowpart", "(", "SImode", ",", "src", ")", ")", ";", "set_mem_size", "(", "dest", ",", "GEN_INT", "(", "size", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_ZERO_EXTRACT", "(", "word_mode", ",", "dest", ",", "GEN_INT", "(", "stcmh_width", ")", ",", "const0_rtx", ")", ",", "gen_rtx_LSHIFTRT", "(", "word_mode", ",", "src", ",", "GEN_INT", "(", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ")", ")", ";", "}", "}", "else", "return", "false", ";", "return", "true", ";", "}", "if", "(", "TARGET_ZARCH", "&&", "register_operand", "(", "dest", ",", "word_mode", ")", "&&", "(", "bitpos", "%", "16", ")", "==", "0", "&&", "(", "bitsize", "%", "16", ")", "==", "0", "&&", "const_int_operand", "(", "src", ",", "VOIDmode", ")", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "src", ")", ";", "int", "regpos", "=", "bitpos", "+", "bitsize", ";", "while", "(", "regpos", ">", "bitpos", ")", "{", "enum", "machine_mode", "putmode", ";", "int", "putsize", ";", "if", "(", "TARGET_EXTIMM", "&&", "(", "regpos", "%", "32", "==", "0", ")", "&&", "(", "regpos", ">=", "bitpos", "+", "32", ")", ")", "putmode", "=", "SImode", ";", "else", "putmode", "=", "HImode", ";", "putsize", "=", "GET_MODE_BITSIZE", "(", "putmode", ")", ";", "regpos", "-=", "putsize", ";", "emit_move_insn", "(", "gen_rtx_ZERO_EXTRACT", "(", "word_mode", ",", "dest", ",", "GEN_INT", "(", "putsize", ")", ",", "GEN_INT", "(", "regpos", ")", ")", ",", "gen_int_mode", "(", "val", ",", "putmode", ")", ")", ";", "val", ">>=", "putsize", ";", "}", "gcc_assert", "(", "regpos", "==", "bitpos", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "code", "for", "the", "insv", "template", ".", "Return", "true", "if", "successful", ",", "false", "else", "." ]

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

[]

[ "<s>", "const", "LegalizerInfo", "*", "X86Subtarget", "::", "getLegalizerInfo", "(", ")", "const", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getLegalizerInfo", "(", ")", ";", "}", "</s>" ]

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

[ "X86", "X86", "\"Access to GlobalISel APIs not set\"" ]

[]

[ "<s>", "virtual", "bool", "runOnFunction", "(", "Function", "&", "Fn", ")", "{", "if", "(", "Fn", ".", "hasAvailableExternallyLinkage", "(", ")", ")", "return", "false", ";", "GlobalBaseReg", "=", "0", ";", "SelectionDAGISel", "::", "runOnFunction", "(", "Fn", ")", ";", "InsertVRSaveCode", "(", "Fn", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "0" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_reg_using_mov", "(", "machine_mode", "mode", ",", "unsigned", "int", "regno", ",", "HOST_WIDE_INT", "cfa_offset", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rtx", "mem", ",", "addr", ",", "base", ",", "insn", ";", "unsigned", "int", "align", ";", "addr", "=", "choose_baseaddr", "(", "cfa_offset", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "addr", ")", ";", "align", "=", "MIN", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", ",", "INCOMING_STACK_BOUNDARY", ")", ";", "set_mem_align", "(", "mem", ",", "align", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "base", "=", "addr", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "gcc_checking_assert", "(", "REG_P", "(", "base", ")", ")", ";", "if", "(", "m", "->", "fs", ".", "realigned", ")", "{", "gcc_checking_assert", "(", "stack_realign_drap", ")", ";", "if", "(", "regno", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", "{", "gcc_checking_assert", "(", "cfun", "->", "machine", "->", "fs", ".", "fp_valid", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "cfun", "->", "machine", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "mem", ")", ";", "}", "else", "{", "gcc_checking_assert", "(", "cfun", "->", "machine", "->", "fs", ".", "fp_valid", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "cfun", "->", "machine", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_EXPRESSION", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "}", "else", "if", "(", "base", "!=", "m", "->", "fs", ".", "cfa_reg", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "m", "->", "fs", ".", "cfa_reg", ",", "m", "->", "fs", ".", "cfa_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "single", "register", "save", "at", "CFA", "-", "CFA_OFFSET", "." ]

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

[]

[ "<s>", "void", "frv_split_double_load", "(", "rtx", "dest", ",", "rtx", "source", ")", "{", "int", "regno", "=", "REGNO", "(", "dest", ")", ";", "rtx", "dest1", "=", "gen_highpart", "(", "SImode", ",", "dest", ")", ";", "rtx", "dest2", "=", "gen_lowpart", "(", "SImode", ",", "dest", ")", ";", "rtx", "address", "=", "XEXP", "(", "source", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "address", ")", "==", "PRE_MODIFY", "||", "!", "refers_to_regno_p", "(", "regno", ",", "address", ")", ")", "{", "emit_move_insn", "(", "dest1", ",", "change_address", "(", "source", ",", "SImode", ",", "NULL", ")", ")", ";", "emit_move_insn", "(", "dest2", ",", "frv_index_memory", "(", "source", ",", "SImode", ",", "1", ")", ")", ";", "}", "else", "{", "emit_move_insn", "(", "dest2", ",", "frv_index_memory", "(", "source", ",", "SImode", ",", "1", ")", ")", ";", "emit_move_insn", "(", "dest1", ",", "change_address", "(", "source", ",", "SImode", ",", "NULL", ")", ")", ";", "}", "}", "</s>" ]

[ "Split", "(", "set", "DEST", "SOURCE", ")", ",", "where", "DEST", "is", "a", "double", "register", "and", "SOURCE", "is", "a", "memory", "location", "that", "is", "not", "known", "to", "be", "dword-aligned", "." ]

[ "frv", "0", "1", "1" ]

[]

[ "<s>", "bool", "MSP430AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "(", "Count", "%", "2", ")", "!=", "0", ")", "return", "false", ";", "uint64_t", "NopCount", "=", "Count", "/", "2", ";", "while", "(", "NopCount", "--", ")", "OS", ".", "write", "(", "\"\\x03\\x43\"", ",", "2", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "2", "0", "2", "\"\\x03\\x43\"", "2" ]

[]

[ "<s>", "void", "m32r_expand_prologue", "(", "void", ")", "{", "int", "regno", ";", "int", "frame_size", ";", "unsigned", "int", "gmask", ";", "int", "pic_reg_used", "=", "flag_pic", "&&", "(", "crtl", "->", "uses_pic_offset_table", "|", "crtl", "->", "profile", ")", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "m32r_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "current_frame_info", ".", "total_size", ";", "gmask", "=", "current_frame_info", ".", "gmask", ";", "gcc_assert", "(", "current_frame_info", ".", "total_size", "||", "!", "gmask", ")", ";", "if", "(", "current_frame_info", ".", "pretend_size", "!=", "0", ")", "{", "HOST_WIDE_INT", "pretend_size", "=", "current_frame_info", ".", "pretend_size", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "pretend_size", ")", ")", ")", ";", "}", "if", "(", "current_frame_info", ".", "save_fp", ")", "emit_insn", "(", "gen_movsi_push", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ")", ";", "gmask", "&=", "~", "(", "FRAME_POINTER_MASK", "|", "RETURN_ADDR_MASK", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "M32R_MAX_INT_REGS", ";", "++", "regno", ")", "{", "if", "(", "(", "gmask", "&", "(", "1", "<<", "regno", ")", ")", "!=", "0", ")", "emit_insn", "(", "gen_movsi_push", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ")", ";", "}", "if", "(", "current_frame_info", ".", "save_lr", ")", "emit_insn", "(", "gen_movsi_push", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ")", ";", "frame_size", "=", "(", "current_frame_info", ".", "total_size", "-", "(", "current_frame_info", ".", "pretend_size", "+", "current_frame_info", ".", "reg_size", ")", ")", ";", "if", "(", "frame_size", "==", "0", ")", ";", "else", "if", "(", "frame_size", "<=", "32768", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "frame_size", ")", ")", ")", ";", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "GEN_INT", "(", "frame_size", ")", ")", ")", ";", "emit_insn", "(", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "gen_movsi", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "crtl", "->", "profile", ")", "emit_insn", "(", "gen_movsi_push", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ")", ";", "if", "(", "pic_reg_used", ")", "{", "m32r_load_pic_register", "(", ")", ";", "m32r_reload_lr", "(", "stack_pointer_rtx", ",", "(", "crtl", "->", "profile", "?", "0", ":", "frame_size", ")", ")", ";", "}", "if", "(", "crtl", "->", "profile", "&&", "!", "pic_reg_used", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "m32r", "prologue", "as", "a", "series", "of", "insns", "." ]

[ "m32r", "0", "0", "1", "0", "0", "32768", "0" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", "&&", "EnableLowerKernelArguments", ")", "addPass", "(", "createAMDGPULowerKernelArgumentsPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "if", "(", "EnableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

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

[]

[ "<s>", "void", "executePostLayoutBinding", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ")", "override", "{", "}", "</s>" ]

[ "Perform", "any", "late", "binding", "of", "symbols", "(", "for", "example", ",", "to", "assign", "symbol", "indices", "for", "use", "when", "generating", "relocations", ")", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", "->", "isAggregateType", "(", ")", ")", "{", "DiagnosticInfoUnsupported", "Err", "(", "DL", ",", "*", "MF", ".", "getFunction", "(", ")", ",", "\"only integer returns supported\"", ",", "SDValue", "(", ")", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "Err", ")", ";", "}", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_BPF64", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "BPFISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "BPF", "BPF", "ISD::OutputArg", "16", "\"only integer returns supported\"", "BPF", "4", "1", "0", "\"Can only return in registers!\"", "1", "BPFISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "assert", "(", "!", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "&&", "hasFP", "(", "MF", ")", "&&", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", "&&", "needsSPWriteback", "(", "MF", ",", "*", "MF", ".", "getFrameInfo", "(", ")", ")", ")", "{", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "writeSPToMemory", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "I", ",", "DL", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", "WebAssembly", "WebAssembly::SP32" ]

[]

[ "<s>", "bool", "HexagonMCInst", "::", "isExtended", "(", "void", ")", "const", "{", "const", "uint64_t", "F", "=", "MCID", "->", "TSFlags", ";", "return", "(", "F", ">>", "HexagonII", "::", "ExtendedPos", ")", "&", "HexagonII", "::", "ExtendedMask", ";", "}", "</s>" ]

[ "Test", "if", "the", "given", "EVT", "is", "extended", "(", "as", "opposed", "to", "being", "simple", ")", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtendedPos", "HexagonII::ExtendedMask" ]

[]

[ "<s>", "bool", "SILowerControlFlowPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "HaveKill", "=", "false", ";", "unsigned", "Depth", "=", "0", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "++", "Depth", ";", "If", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "Else", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "Break", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "IfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "ElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "++", "Depth", ";", "Loop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "if", "(", "--", "Depth", "==", "0", "&&", "HaveKill", ")", "{", "SkipIfDead", "(", "MI", ")", ";", "HaveKill", "=", "false", ";", "}", "EndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_KILL", ":", "if", "(", "Depth", "==", "0", ")", "SkipIfDead", "(", "MI", ")", ";", "else", "HaveKill", "=", "true", ";", "Kill", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "Branch", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_SRC", ":", "IndirectSrc", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V2", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V4", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V8", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V16", ":", "IndirectDst", "(", "MI", ")", ";", "break", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "SI", "0", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "0", "SI", "0", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "const", "Cpu0InstrInfo", "*", "Cpu0InstrInfo", "::", "create", "(", "Cpu0Subtarget", "&", "STI", ")", "{", "return", "llvm", "::", "createCpu0SEInstrInfo", "(", "STI", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "bool", "WasForced", ")", "const", "{", "if", "(", "!", "Resolved", "&&", "!", "WasForced", ")", "return", "true", ";", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", ";", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "RISCV", "::", "fixup_riscv_rvc_branch", ":", "return", "Offset", ">", "254", "||", "Offset", "<", "-", "256", ";", "case", "RISCV", "::", "fixup_riscv_rvc_jump", ":", "return", "Offset", ">", "2046", "||", "Offset", "<", "-", "2048", ";", "}", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "RISCV", "RISCV", "RISCV::fixup_riscv_rvc_branch", "254", "256", "RISCV::fixup_riscv_rvc_jump", "2046", "2048" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "assert", "(", "dag", "->", "hasVRegLiveness", "(", ")", "&&", "\"R600SchedStrategy needs vreg liveness\"", ")", ";", "DAG", "=", "static_cast", "<", "ScheduleDAGMILive", "*", ">", "(", "dag", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "DAG", "->", "TII", ")", ";", "TRI", "=", "static_cast", "<", "const", "R600RegisterInfo", "*", ">", "(", "DAG", "->", "TRI", ")", ";", "VLIW5", "=", "!", "ST", ".", "hasCaymanISA", "(", ")", ";", "MRI", "=", "&", "DAG", "->", "MRI", ";", "CurInstKind", "=", "IDOther", ";", "CurEmitted", "=", "0", ";", "OccupedSlotsMask", "=", "31", ";", "InstKindLimit", "[", "IDAlu", "]", "=", "TII", "->", "getMaxAlusPerClause", "(", ")", ";", "InstKindLimit", "[", "IDOther", "]", "=", "32", ";", "InstKindLimit", "[", "IDFetch", "]", "=", "ST", ".", "getTexVTXClauseSize", "(", ")", ";", "AluInstCount", "=", "0", ";", "FetchInstCount", "=", "0", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "AMDGPU", "R600", "\"R600SchedStrategy needs vreg liveness\"", "AMDGPU", "AMDGPU", "R600", "R600", "0", "31", "32", "0", "0" ]

[]

[ "<s>", "bool", "rs6000_opaque_type_invalid_use_p", "(", "gimple", "*", "stmt", ")", "{", "if", "(", "TARGET_MMA", ")", "return", "false", ";", "auto", "check_and_error_invalid_use", "=", "[", "]", "(", "tree", "type", ")", "{", "tree", "mv", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "mv", "==", "vector_quad_type_node", ")", "{", "error", "(", "\"type %<__vector_quad%> requires the %qs option\"", ",", "\"-mmma\"", ")", ";", "return", "true", ";", "}", "else", "if", "(", "mv", "==", "vector_pair_type_node", ")", "{", "error", "(", "\"type %<__vector_pair%> requires the %qs option\"", ",", "\"-mmma\"", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "if", "(", "stmt", ")", "{", "if", "(", "gassign", "*", "ga", "=", "dyn_cast", "<", "gassign", "*", ">", "(", "stmt", ")", ")", "{", "tree", "lhs", "=", "gimple_assign_lhs", "(", "ga", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "lhs", ")", ";", "if", "(", "check_and_error_invalid_use", "(", "type", ")", ")", "return", "true", ";", "}", "else", "if", "(", "gasm", "*", "gs", "=", "dyn_cast", "<", "gasm", "*", ">", "(", "stmt", ")", ")", "{", "unsigned", "ninputs", "=", "gimple_asm_ninputs", "(", "gs", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "ninputs", ";", "i", "++", ")", "{", "tree", "op", "=", "gimple_asm_input_op", "(", "gs", ",", "i", ")", ";", "tree", "val", "=", "TREE_VALUE", "(", "op", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "val", ")", ";", "if", "(", "check_and_error_invalid_use", "(", "type", ")", ")", "return", "true", ";", "}", "unsigned", "noutputs", "=", "gimple_asm_noutputs", "(", "gs", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "noutputs", ";", "i", "++", ")", "{", "tree", "op", "=", "gimple_asm_output_op", "(", "gs", ",", "i", ")", ";", "tree", "val", "=", "TREE_VALUE", "(", "op", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "val", ")", ";", "if", "(", "check_and_error_invalid_use", "(", "type", ")", ")", "return", "true", ";", "}", "}", "else", "if", "(", "gcall", "*", "gc", "=", "dyn_cast", "<", "gcall", "*", ">", "(", "stmt", ")", ")", "{", "unsigned", "nargs", "=", "gimple_call_num_args", "(", "gc", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "nargs", ";", "i", "++", ")", "{", "tree", "arg", "=", "gimple_call_arg", "(", "gc", ",", "i", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "arg", ")", ";", "if", "(", "check_and_error_invalid_use", "(", "type", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Now", "we", "have", "only", "two", "opaque", "types", ",", "they", "are", "__vector_quad", "and", "__vector_pair", "built-in", "types", ".", "They", "are", "target", "specific", "and", "only", "available", "when", "MMA", "is", "supported", ".", "With", "MMA", "supported", ",", "it", "simply", "returns", "true", ",", "otherwise", "it", "checks", "if", "the", "given", "gimple", "STMT", "is", "an", "assignment", ",", "asm", "or", "call", "stmt", "and", "uses", "either", "of", "these", "two", "opaque", "types", "unexpectedly", ",", "if", "yes", ",", "it", "would", "raise", "an", "error", "message", "and", "returns", "true", ",", "otherwise", "it", "returns", "false", "." ]

[ "rs6000", "\"type %<__vector_quad%> requires the %qs option\"", "\"-mmma\"", "\"type %<__vector_pair%> requires the %qs option\"", "\"-mmma\"", "0", "0", "0" ]

[]

[ "<s>", "void", "WebAssemblyTargetWasmStreamer", "::", "emitLocal", "(", "ArrayRef", "<", "wasm", "::", "ValType", ">", "Types", ")", "{", "SmallVector", "<", "std", "::", "pair", "<", "wasm", "::", "ValType", ",", "uint32_t", ">", ",", "4", ">", "Grouped", ";", "for", "(", "auto", "Type", ":", "Types", ")", "{", "if", "(", "Grouped", ".", "empty", "(", ")", "||", "Grouped", ".", "back", "(", ")", ".", "first", "!=", "Type", ")", "Grouped", ".", "push_back", "(", "std", "::", "make_pair", "(", "Type", ",", "1", ")", ")", ";", "else", "++", "Grouped", ".", "back", "(", ")", ".", "second", ";", "}", "Streamer", ".", "emitULEB128IntValue", "(", "Grouped", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "Pair", ":", "Grouped", ")", "{", "Streamer", ".", "emitULEB128IntValue", "(", "Pair", ".", "second", ")", ";", "emitValueType", "(", "Pair", ".", "first", ")", ";", "}", "}", "</s>" ]

[ ".local" ]

[ "WebAssembly", "WebAssembly", "wasm::ValType", "wasm::ValType", "4", "1" ]

[]

[ "<s>", "static", "int", "distance_non_agu_define_in_bb", "(", "unsigned", "int", "regno1", ",", "unsigned", "int", "regno2", ",", "rtx_insn", "*", "insn", ",", "int", "distance", ",", "rtx_insn", "*", "start", ",", "bool", "*", "found", ")", "{", "basic_block", "bb", "=", "start", "?", "BLOCK_FOR_INSN", "(", "start", ")", ":", "NULL", ";", "rtx_insn", "*", "prev", "=", "start", ";", "rtx_insn", "*", "next", "=", "NULL", ";", "*", "found", "=", "false", ";", "while", "(", "prev", "&&", "prev", "!=", "insn", "&&", "distance", "<", "LEA_SEARCH_THRESHOLD", ")", "{", "if", "(", "NONDEBUG_INSN_P", "(", "prev", ")", "&&", "NONJUMP_INSN_P", "(", "prev", ")", ")", "{", "distance", "=", "increase_distance", "(", "prev", ",", "next", ",", "distance", ")", ";", "if", "(", "insn_defines_reg", "(", "regno1", ",", "regno2", ",", "prev", ")", ")", "{", "if", "(", "recog_memoized", "(", "prev", ")", "<", "0", "||", "get_attr_type", "(", "prev", ")", "!=", "TYPE_LEA", ")", "{", "*", "found", "=", "true", ";", "return", "distance", ";", "}", "}", "next", "=", "prev", ";", "}", "if", "(", "prev", "==", "BB_HEAD", "(", "bb", ")", ")", "break", ";", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "}", "return", "distance", ";", "}", "</s>" ]

[ "Search", "backward", "for", "non-agu", "definition", "of", "register", "number", "REGNO1", "or", "register", "number", "REGNO2", "in", "basic", "block", "starting", "from", "instruction", "START", "up", "to", "head", "of", "basic", "block", "or", "instruction", "INSN", ".", "Function", "puts", "true", "value", "into", "*", "FOUND", "var", "if", "definition", "was", "found", "and", "false", "otherwise", ".", "Distance", "in", "half-cycles", "between", "START", "and", "found", "instruction", "or", "head", "of", "BB", "is", "added", "to", "DISTANCE", "and", "returned", "." ]

[ "i386", "0" ]

[]

[ "<s>", "static", "void", "ix86_emit_leave", "(", "rtx_insn", "*", "insn", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "if", "(", "!", "insn", ")", "insn", "=", "emit_insn", "(", "ix86_gen_leave", "(", ")", ")", ";", "ix86_add_queued_cfa_restore_notes", "(", "insn", ")", ";", "gcc_assert", "(", "m", "->", "fs", ".", "fp_valid", ")", ";", "m", "->", "fs", ".", "sp_valid", "=", "true", ";", "m", "->", "fs", ".", "sp_realigned", "=", "false", ";", "m", "->", "fs", ".", "sp_offset", "=", "m", "->", "fs", ".", "fp_offset", "-", "UNITS_PER_WORD", ";", "m", "->", "fs", ".", "fp_valid", "=", "false", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "hard_frame_pointer_rtx", ")", "{", "m", "->", "fs", ".", "cfa_reg", "=", "stack_pointer_rtx", ";", "m", "->", "fs", ".", "cfa_offset", "=", "m", "->", "fs", ".", "sp_offset", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "m", "->", "fs", ".", "sp_offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "ix86_add_cfa_restore_note", "(", "insn", ",", "hard_frame_pointer_rtx", ",", "m", "->", "fs", ".", "fp_offset", ")", ";", "}", "</s>" ]

[ "Emit", "code", "and", "notes", "for", "the", "LEAVE", "instruction", "." ]

[ "i386", "1" ]

[]

[ "<s>", "tree", "memory_scalar_type", "(", "const", "function_instance", "&", "fi", ")", "const", "OVERRIDE", "{", "type_class_index", "tclass", "=", "fi", ".", "type_suffix", "(", "0", ")", ".", "tclass", ";", "unsigned", "int", "element_bits", "=", "GET_MODE_BITSIZE", "(", "m_to_mode", ")", ";", "type_suffix_index", "suffix", "=", "find_type_suffix", "(", "tclass", ",", "element_bits", ")", ";", "return", "scalar_types", "[", "type_suffixes", "[", "suffix", "]", ".", "vector_type", "]", ";", "}", "</s>" ]

[ "If", "the", "function", "addresses", "memory", ",", "return", "the", "type", "of", "a", "single", "scalar", "memory", "element", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "rest_of_insert_bti", "(", "void", ")", "{", "timevar_push", "(", "TV_MACH_DEP", ")", ";", "rtx", "bti_insn", ";", "rtx_insn", "*", "insn", ";", "basic_block", "bb", ";", "bb", "=", "0", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "for", "(", "insn", "=", "BB_HEAD", "(", "bb", ")", ";", "insn", "!=", "NEXT_INSN", "(", "BB_END", "(", "bb", ")", ")", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "LABEL_P", "(", "insn", ")", "&&", "(", "LABEL_PRESERVE_P", "(", "insn", ")", "||", "bb", "->", "flags", "&", "BB_NON_LOCAL_GOTO_TARGET", ")", ")", "{", "bti_insn", "=", "aarch_gen_bti_j", "(", ")", ";", "emit_insn_after", "(", "bti_insn", ",", "insn", ")", ";", "continue", ";", "}", "if", "(", "JUMP_P", "(", "insn", ")", ")", "{", "rtx_jump_table_data", "*", "table", ";", "if", "(", "tablejump_p", "(", "insn", ",", "NULL", ",", "&", "table", ")", ")", "{", "rtvec", "vec", "=", "table", "->", "get_labels", "(", ")", ";", "int", "j", ";", "rtx_insn", "*", "label", ";", "for", "(", "j", "=", "GET_NUM_ELEM", "(", "vec", ")", "-", "1", ";", "j", ">=", "0", ";", "--", "j", ")", "{", "label", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XEXP", "(", "RTVEC_ELT", "(", "vec", ",", "j", ")", ",", "0", ")", ")", ";", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "aarch_bti_j_insn_p", "(", "next", ")", ")", "continue", ";", "bti_insn", "=", "aarch_gen_bti_j", "(", ")", ";", "emit_insn_after", "(", "bti_insn", ",", "label", ")", ";", "}", "}", "}", "if", "(", "CALL_P", "(", "insn", ")", "&&", "(", "find_reg_note", "(", "insn", ",", "REG_SETJMP", ",", "NULL", ")", ")", ")", "{", "bti_insn", "=", "aarch_gen_bti_j", "(", ")", ";", "emit_insn_after", "(", "bti_insn", ",", "insn", ")", ";", "continue", ";", "}", "}", "}", "if", "(", "!", "cgraph_node", "::", "get", "(", "cfun", "->", "decl", ")", "->", "only_called_directly_p", "(", ")", ")", "{", "bb", "=", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "next_bb", ";", "insn", "=", "BB_HEAD", "(", "bb", ")", ";", "if", "(", "!", "aarch_pac_insn_p", "(", "get_first_nonnote_insn", "(", ")", ")", ")", "{", "bti_insn", "=", "aarch_gen_bti_c", "(", ")", ";", "emit_insn_before", "(", "bti_insn", ",", "insn", ")", ";", "}", "}", "timevar_pop", "(", "TV_MACH_DEP", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "is", "implemented", "as", "a", "late", "RTL", "pass", "that", "runs", "before", "branch", "shortening", "and", "does", "the", "following", "." ]

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

[]

[ "<s>", "HOST_WIDE_INT", "microblaze_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "0", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "if", "(", "to", "==", "STACK_POINTER_REGNUM", "||", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "=", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "RETURN_ADDRESS_POINTER_REGNUM", ":", "if", "(", "crtl", "->", "is_leaf", ")", "offset", "=", "0", ";", "else", "offset", "=", "current_frame_info", ".", "gp_offset", "+", "(", "(", "UNITS_PER_WORD", "-", "(", "POINTER_SIZE", "/", "BITS_PER_UNIT", ")", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", ".", "FROM", "is", "either", "the", "frame", "pointer", "or", "argument", "pointer", "or", "the", "return", "address", "pointer", ".", "TO", "is", "either", "the", "stack", "pointer", "or", "hard", "frame", "pointer", "." ]

[ "microblaze", "0", "0" ]

[]

[ "<s>", "void", "SPUFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "SPUInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SPUInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "int", "LinkSlotOffset", "=", "SPUFrameLowering", "::", "stackSlotSize", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SPU", "::", "RET", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "assert", "(", "(", "FrameSize", "&", "0xf", ")", "==", "0", "&&", "\"FrameSize not aligned\"", ")", ";", "if", "(", "FrameSize", ">", "16", "||", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "FrameSize", "=", "FrameSize", "+", "SPUFrameLowering", "::", "minStackSize", "(", ")", ";", "if", "(", "isInt", "<", "10", ">", "(", "FrameSize", "+", "LinkSlotOffset", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQDr128", ")", ",", "SPU", "::", "R0", ")", ".", "addImm", "(", "FrameSize", "+", "LinkSlotOffset", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "AIr32", ")", ",", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "if", "(", "FrameSize", "<=", "(", "1", "<<", "16", ")", "-", "1", "&&", "FrameSize", ">=", "-", "(", "1", "<<", "16", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "STQDr128", ")", ",", "SPU", "::", "R2", ")", ".", "addImm", "(", "16", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "ILr32", ")", ",", "SPU", "::", "R2", ")", ".", "addImm", "(", "FrameSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "Ar32", ")", ",", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQDr128", ")", ",", "SPU", "::", "R0", ")", ".", "addImm", "(", "16", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "SFIr32", ")", ",", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ".", "addImm", "(", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQXr128", ")", ",", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "}", "else", "{", "report_fatal_error", "(", "\"Unhandled frame size: \"", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU", "SPU", "SPU::RET", "\"Can only insert epilog into returning blocks\"", "0xf", "0", "\"FrameSize not aligned\"", "16", "SPU", "10", "SPU::LQDr128", "SPU::R0", "SPU::R1", "SPU::AIr32", "SPU::R1", "SPU::R1", "1", "16", "1", "1", "16", "SPU::STQDr128", "SPU::R2", "16", "SPU::R1", "SPU::ILr32", "SPU::R2", "SPU::Ar32", "SPU::R1", "SPU::R1", "SPU::R2", "SPU::LQDr128", "SPU::R0", "16", "SPU::R1", "SPU::SFIr32", "SPU::R2", "SPU::R2", "16", "SPU::LQXr128", "SPU::R2", "SPU::R2", "SPU::R1", "\"Unhandled frame size: \"" ]

[]

[ "<s>", "int", "ix86_compare_version_priority", "(", "tree", "decl1", ",", "tree", "decl2", ")", "{", "unsigned", "int", "priority1", "=", "get_builtin_code_for_version", "(", "decl1", ",", "NULL", ")", ";", "unsigned", "int", "priority2", "=", "get_builtin_code_for_version", "(", "decl2", ",", "NULL", ")", ";", "return", "(", "int", ")", "priority1", "-", "(", "int", ")", "priority2", ";", "}", "</s>" ]

[ "This", "compares", "the", "priority", "of", "target", "features", "in", "function", "DECL1", "and", "DECL2", ".", "It", "returns", "positive", "value", "if", "DECL1", "is", "higher", "priority", ",", "negative", "value", "if", "DECL2", "is", "higher", "priority", "and", "0", "if", "they", "are", "the", "same", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "ix86_function_specific_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ")", "{", "ptr", "->", "arch", "=", "ix86_arch", ";", "ptr", "->", "schedule", "=", "ix86_schedule", ";", "ptr", "->", "prefetch_sse", "=", "x86_prefetch_sse", ";", "ptr", "->", "tune", "=", "ix86_tune", ";", "ptr", "->", "branch_cost", "=", "ix86_branch_cost", ";", "ptr", "->", "tune_defaulted", "=", "ix86_tune_defaulted", ";", "ptr", "->", "arch_specified", "=", "ix86_arch_specified", ";", "ptr", "->", "x_ix86_isa_flags_explicit", "=", "opts", "->", "x_ix86_isa_flags_explicit", ";", "ptr", "->", "x_ix86_isa_flags2_explicit", "=", "opts", "->", "x_ix86_isa_flags2_explicit", ";", "ptr", "->", "x_recip_mask_explicit", "=", "opts", "->", "x_recip_mask_explicit", ";", "ptr", "->", "x_ix86_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "ptr", "->", "x_ix86_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "ptr", "->", "x_ix86_cmodel", "=", "opts", "->", "x_ix86_cmodel", ";", "ptr", "->", "x_ix86_abi", "=", "opts", "->", "x_ix86_abi", ";", "ptr", "->", "x_ix86_asm_dialect", "=", "opts", "->", "x_ix86_asm_dialect", ";", "ptr", "->", "x_ix86_branch_cost", "=", "opts", "->", "x_ix86_branch_cost", ";", "ptr", "->", "x_ix86_dump_tunes", "=", "opts", "->", "x_ix86_dump_tunes", ";", "ptr", "->", "x_ix86_force_align_arg_pointer", "=", "opts", "->", "x_ix86_force_align_arg_pointer", ";", "ptr", "->", "x_ix86_force_drap", "=", "opts", "->", "x_ix86_force_drap", ";", "ptr", "->", "x_ix86_incoming_stack_boundary_arg", "=", "opts", "->", "x_ix86_incoming_stack_boundary_arg", ";", "ptr", "->", "x_ix86_pmode", "=", "opts", "->", "x_ix86_pmode", ";", "ptr", "->", "x_ix86_preferred_stack_boundary_arg", "=", "opts", "->", "x_ix86_preferred_stack_boundary_arg", ";", "ptr", "->", "x_ix86_recip_name", "=", "opts", "->", "x_ix86_recip_name", ";", "ptr", "->", "x_ix86_regparm", "=", "opts", "->", "x_ix86_regparm", ";", "ptr", "->", "x_ix86_section_threshold", "=", "opts", "->", "x_ix86_section_threshold", ";", "ptr", "->", "x_ix86_sse2avx", "=", "opts", "->", "x_ix86_sse2avx", ";", "ptr", "->", "x_ix86_stack_protector_guard", "=", "opts", "->", "x_ix86_stack_protector_guard", ";", "ptr", "->", "x_ix86_stringop_alg", "=", "opts", "->", "x_ix86_stringop_alg", ";", "ptr", "->", "x_ix86_tls_dialect", "=", "opts", "->", "x_ix86_tls_dialect", ";", "ptr", "->", "x_ix86_tune_ctrl_string", "=", "opts", "->", "x_ix86_tune_ctrl_string", ";", "ptr", "->", "x_ix86_tune_memcpy_strategy", "=", "opts", "->", "x_ix86_tune_memcpy_strategy", ";", "ptr", "->", "x_ix86_tune_memset_strategy", "=", "opts", "->", "x_ix86_tune_memset_strategy", ";", "ptr", "->", "x_ix86_tune_no_default", "=", "opts", "->", "x_ix86_tune_no_default", ";", "ptr", "->", "x_ix86_veclibabi_type", "=", "opts", "->", "x_ix86_veclibabi_type", ";", "gcc_assert", "(", "ptr", "->", "arch", "==", "ix86_arch", ")", ";", "gcc_assert", "(", "ptr", "->", "schedule", "==", "ix86_schedule", ")", ";", "gcc_assert", "(", "ptr", "->", "tune", "==", "ix86_tune", ")", ";", "gcc_assert", "(", "ptr", "->", "branch_cost", "==", "ix86_branch_cost", ")", ";", "}", "</s>" ]

[ "Save", "the", "current", "options" ]

[ "i386" ]

[]

[ "<s>", "NodeId", "getSibling", "(", ")", "const", "{", "return", "Ref", ".", "Sib", ";", "}", "</s>" ]

[ "Get", "the", "sibling", "of", "this", "DIE", "object", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "LM32AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "assert", "(", "(", "&", "(", "MF", "->", "getContext", "(", ")", ")", "==", "&", "(", "AsmPrinter", "::", "OutContext", ")", ")", "&&", "\"we are treating these as the same in LM32MCInstLower\"", ")", ";", "if", "(", "MI", "->", "isPseudo", "(", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "</s>" ]

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

[ "LM32", "LM32", "\"we are treating these as the same in LM32MCInstLower\"", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "void", "SystemZTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "bool", "HasCall", "=", "false", ";", "InstructionCost", "NumStores", "=", "0", ";", "for", "(", "auto", "&", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "&", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "HasCall", "=", "true", ";", "if", "(", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memcpy", "||", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memset", ")", "NumStores", "++", ";", "}", "else", "{", "HasCall", "=", "true", ";", "}", "}", "if", "(", "isa", "<", "StoreInst", ">", "(", "&", "I", ")", ")", "{", "Type", "*", "MemAccessTy", "=", "I", ".", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "NumStores", "+=", "getMemoryOpCost", "(", "Instruction", "::", "Store", ",", "MemAccessTy", ",", "None", ",", "0", ",", "TTI", "::", "TCK_RecipThroughput", ")", ";", "}", "}", "unsigned", "const", "NumStoresVal", "=", "*", "NumStores", ".", "getValue", "(", ")", ";", "unsigned", "const", "Max", "=", "(", "NumStoresVal", "?", "(", "12", "/", "NumStoresVal", ")", ":", "UINT_MAX", ")", ";", "if", "(", "HasCall", ")", "{", "UP", ".", "FullUnrollMaxCount", "=", "Max", ";", "UP", ".", "MaxCount", "=", "1", ";", "return", ";", "}", "UP", ".", "MaxCount", "=", "Max", ";", "if", "(", "UP", ".", "MaxCount", "<=", "1", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "75", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "Intrinsic::memcpy", "Intrinsic::memset", "0", "0", "12", "1", "1", "75", "4" ]

[]

[ "<s>", "unsigned", "int", "arc_compute_frame_size", "(", "int", "size", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ",", "reg_offset", ";", "unsigned", "int", "gmask", ";", "enum", "arc_function_type", "fn_type", ";", "int", "interrupt_p", ";", "struct", "arc_frame_info", "*", "frame_info", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "size", "=", "ARC_STACK_ALIGN", "(", "size", ")", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "interrupt_p", "=", "ARC_INTERRUPT_P", "(", "fn_type", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ",", "interrupt_p", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "}", "frame_info", "->", "save_return_addr", "=", "(", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", ")", ";", "if", "(", "optimize_size", "&&", "!", "TARGET_NO_MILLICODE_THUNK_SET", ")", "{", "if", "(", "arc_compute_millicode_save_restore_regs", "(", "gmask", ",", "frame_info", ")", ")", "frame_info", "->", "save_return_addr", "=", "true", ";", "}", "extra_size", "=", "0", ";", "if", "(", "MUST_SAVE_RETURN_ADDR", ")", "extra_size", "=", "4", ";", "if", "(", "frame_pointer_needed", ")", "extra_size", "+=", "4", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "{", "unsigned", "int", "extra_plus_reg_size", ";", "unsigned", "int", "extra_plus_reg_size_aligned", ";", "extra_plus_reg_size", "=", "extra_size", "+", "reg_size", ";", "extra_plus_reg_size_aligned", "=", "ARC_STACK_ALIGN", "(", "extra_plus_reg_size", ")", ";", "reg_size", "=", "extra_plus_reg_size_aligned", "-", "extra_size", ";", "}", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", "+", "pretend_size", "+", "reg_size", ";", "total_size", "=", "ARC_STACK_ALIGN", "(", "total_size", ")", ";", "reg_offset", "=", "(", "total_size", "-", "(", "pretend_size", "+", "reg_size", "+", "extra_size", ")", "+", "(", "frame_pointer_needed", "?", "4", ":", "0", ")", ")", ";", "frame_info", "->", "total_size", "=", "total_size", ";", "frame_info", "->", "extra_size", "=", "extra_size", ";", "frame_info", "->", "pretend_size", "=", "pretend_size", ";", "frame_info", "->", "var_size", "=", "var_size", ";", "frame_info", "->", "args_size", "=", "args_size", ";", "frame_info", "->", "reg_size", "=", "reg_size", ";", "frame_info", "->", "reg_offset", "=", "reg_offset", ";", "frame_info", "->", "gmask", "=", "gmask", ";", "frame_info", "->", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "." ]

[ "arc", "0", "0", "0", "31", "1", "0", "4", "4", "4", "0" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "!", "FBB", "&&", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "4", ";", "return", "1", ";", "}", "if", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "Cond", "[", "0", "]", ".", "isReg", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "SI_NON_UNIFORM_BRCOND_PSEUDO", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "TBB", "&&", "Cond", "[", "0", "]", ".", "isImm", "(", ")", ")", ";", "unsigned", "Opcode", "=", "getBranchOpcode", "(", "static_cast", "<", "BranchPredicate", ">", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "if", "(", "!", "FBB", ")", "{", "Cond", "[", "1", "]", ".", "isUndef", "(", ")", ";", "MachineInstr", "*", "CondBr", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "preserveCondRegFlags", "(", "CondBr", "->", "getOperand", "(", "1", ")", ",", "Cond", "[", "1", "]", ")", ";", "fixImplicitOperands", "(", "*", "CondBr", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "4", ";", "return", "1", ";", "}", "assert", "(", "TBB", "&&", "FBB", ")", ";", "MachineInstr", "*", "CondBr", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "MachineOperand", "&", "CondReg", "=", "CondBr", "->", "getOperand", "(", "1", ")", ";", "CondReg", ".", "setIsUndef", "(", "Cond", "[", "1", "]", ".", "isUndef", "(", ")", ")", ";", "CondReg", ".", "setIsKill", "(", "Cond", "[", "1", "]", ".", "isKill", "(", ")", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "8", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_BRANCH", "4", "1", "1", "0", "AMDGPU::SI_NON_UNIFORM_BRCOND_PSEUDO", "0", "1", "0", "0", "1", "1", "1", "4", "1", "AMDGPU::S_BRANCH", "1", "1", "1", "8", "2" ]

[]

[ "<s>", "bool", "Tile64PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createTile64ISelDag", "(", "getTile64TargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Tile64" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isFCmpOrdCheaperThanFCmpZero", "(", "Type", "*", "Ty", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "faster", "to", "check", "if", "a", "floating-point", "value", "is", "NaN", "(", "or", "not-NaN", ")", "versus", "a", "comparison", "against", "a", "constant", "FP", "zero", "value", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "SICABIInfo", "Unknown", "(", ")", "{", "return", "SICABIInfo", "(", "ABI", "::", "Unknown", ")", ";", "}", "</s>" ]

[ "The", "kind", "of", "location", "description", "being", "produced", ".", "More", "..." ]

[ "SIC", "SIC", "SIC", "ABI::Unknown" ]

[]

[ "<s>", "static", "const", "char", "*", "mcore_strip_name_encoding", "(", "const", "char", "*", "str", ")", "{", "return", "str", "+", "(", "str", "[", "0", "]", "==", "'@'", "?", "3", ":", "0", ")", ";", "}", "</s>" ]

[ "Undo", "the", "effects", "of", "the", "above", "." ]

[ "mcore", "0", "3", "0" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "emitRawBytes", "(", "StringRef", "Data", ")", "{", "const", "MCAsmInfo", "*", "MAI", "=", "Streamer", ".", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", ";", "const", "char", "*", "Directive", "=", "MAI", "->", "getData8bitsDirective", "(", ")", ";", "unsigned", "NumElements", "=", "Data", ".", "size", "(", ")", ";", "const", "unsigned", "MaxLen", "=", "40", ";", "unsigned", "NumChunks", "=", "1", "+", "(", "(", "NumElements", "-", "1", ")", "/", "MaxLen", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "NumChunks", ";", "++", "I", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "const", "char", "*", "Label", "=", "Directive", ";", "for", "(", "auto", "It", "=", "std", "::", "next", "(", "Data", ".", "bytes_begin", "(", ")", ",", "I", "*", "MaxLen", ")", ",", "End", "=", "(", "I", "==", "NumChunks", "-", "1", ")", "?", "Data", ".", "bytes_end", "(", ")", ":", "std", "::", "next", "(", "Data", ".", "bytes_begin", "(", ")", ",", "(", "I", "+", "1", ")", "*", "MaxLen", ")", ";", "It", "!=", "End", ";", "++", "It", ")", "{", "OS", "<<", "Label", "<<", "(", "unsigned", ")", "*", "It", ";", "if", "(", "Label", "==", "Directive", ")", "Label", "=", "\",\"", ";", "}", "Streamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "NVPTX", "NVPTX", "40", "1", "1", "0", "128", "1", "1", "\",\"" ]

[]