Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "SimplifyCFGOptions", "(", ")", ".", "hoistCommonInsts", "(", "true", ")", ".", "sinkCommonInsts", "(", "true", ")", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createMVEGatherScatterLoweringPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "addPass", "(", "createARMParallelDSPPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "getConstValDefinedInReg", "(", "const", "MachineInstr", "&", "MI", ",", "const", "Register", "Reg", ",", "int64_t", "&", "ImmVal", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "X86", "::", "MOV32ri", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "X86", "::", "MOV64ri", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "||", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "!=", "Reg", ")", "return", "false", ";", "ImmVal", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "MI", "is", "an", "instruction", "that", "defines", "Reg", "to", "have", "a", "constant", "value", "and", "the", "value", "is", "recorded", "in", "ImmVal", "." ]

[ "X86", "X86", "X86::MOV32ri", "X86::MOV64ri", "1", "0", "1" ]

[]

[ "<s>", "const", "LoongArchSubtarget", "&", "getSubtarget", "(", ")", "const", "{", "return", "Subtarget", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "LoongArch", "LoongArch" ]

[]

[ "<s>", "MachineBasicBlock", "*", "AMDGPUCFGStructurizer", "::", "clone", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "MachineFunction", "*", "Func", "=", "MBB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "NewMBB", "=", "Func", "->", "CreateMachineBasicBlock", "(", ")", ";", "Func", "->", "push_back", "(", "NewMBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "It", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineInstr", "*", "MI", "=", "Func", "->", "CloneMachineInstr", "(", "It", ")", ";", "NewMBB", "->", "push_back", "(", "MI", ")", ";", "}", "return", "NewMBB", ";", "}", "</s>" ]

[ "Make", "a", "functionally", "equivalent", "copy", "of", "this", "MachineFunctionInfo", "in", "MF", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "AVRTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "if", "(", "CallConv", "==", "CallingConv", "::", "AVR_BUILTIN", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_AVR_BUILTIN", ")", ";", "}", "unsigned", "TotalBytes", "=", "getTotalArgumentsSizeInBytes", "(", "Outs", ")", ";", "return", "TotalBytes", "<=", "8", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "AVR", "AVR", "ISD::OutputArg", "AVR", "16", "AVR", "8" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "readlaneVGPRToSGPR", "(", "unsigned", "SrcReg", ",", "MachineInstr", "&", "UseMI", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "const", "TargetRegisterClass", "*", "VRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "const", "TargetRegisterClass", "*", "SRC", "=", "RI", ".", "getEquivalentSGPRClass", "(", "VRC", ")", ";", "unsigned", "DstReg", "=", "MRI", ".", "createVirtualRegister", "(", "SRC", ")", ";", "unsigned", "SubRegs", "=", "VRC", "->", "getSize", "(", ")", "/", "4", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "SRegs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SubRegs", ";", "++", "i", ")", "{", "unsigned", "SGPR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "SGPR", ")", ".", "addReg", "(", "SrcReg", ",", "0", ",", "RI", ".", "getSubRegFromChannel", "(", "i", ")", ")", ";", "SRegs", ".", "push_back", "(", "SGPR", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "REG_SEQUENCE", ")", ",", "DstReg", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SubRegs", ";", "++", "i", ")", "{", "MIB", ".", "addReg", "(", "SRegs", "[", "i", "]", ")", ";", "MIB", ".", "addImm", "(", "RI", ".", "getSubRegFromChannel", "(", "i", ")", ")", ";", "}", "return", "DstReg", ";", "}", "</s>" ]

[ "Copy", "a", "value", "from", "a", "VGPR", "(", "SrcReg", ")", "to", "SGPR", "." ]

[ "AMDGPU", "SI", "4", "8", "0", "AMDGPU::SGPR_32RegClass", "AMDGPU::V_READFIRSTLANE_B32", "0", "AMDGPU::REG_SEQUENCE", "0" ]

[]

[ "<s>", "static", "void", "emit_pred_op", "(", "unsigned", "icode", ",", "rtx", "mask", ",", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "len", ",", "machine_mode", "mask_mode", ",", "bool", "vlmax_p", ")", "{", "insn_expander", "<", "8", ">", "e", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "e", ".", "add_output_operand", "(", "dest", ",", "mode", ")", ";", "if", "(", "mask", ")", "e", ".", "add_input_operand", "(", "mask", ",", "GET_MODE", "(", "mask", ")", ")", ";", "else", "e", ".", "add_all_one_mask_operand", "(", "mask_mode", ")", ";", "e", ".", "add_vundef_operand", "(", "mode", ")", ";", "e", ".", "add_input_operand", "(", "src", ",", "GET_MODE", "(", "src", ")", ")", ";", "if", "(", "len", ")", "e", ".", "add_input_operand", "(", "len", ",", "Pmode", ")", ";", "else", "{", "rtx", "vlmax", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_vlmax_vsetvl", "(", "mode", ",", "vlmax", ")", ";", "e", ".", "add_input_operand", "(", "vlmax", ",", "Pmode", ")", ";", "}", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_BOOL", ")", "e", ".", "add_policy_operand", "(", "get_prefer_tail_policy", "(", ")", ",", "get_prefer_mask_policy", "(", ")", ")", ";", "if", "(", "vlmax_p", ")", "e", ".", "add_avl_type_operand", "(", "avl_type", "::", "VLMAX", ")", ";", "else", "e", ".", "add_avl_type_operand", "(", "avl_type", "::", "NONVLMAX", ")", ";", "e", ".", "expand", "(", "(", "enum", "insn_code", ")", "icode", ",", "MEM_P", "(", "dest", ")", "||", "MEM_P", "(", "src", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "RVV", "unmask", "&", "&", "vl", "mov", "from", "SRC", "to", "DEST", "." ]

[ "riscv", "8" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "{", "if", "(", "SDValue", "Res", "=", "lowerINSERT_VECTOR_ELT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "{", "if", "(", "SDValue", "Res", "=", "lowerEXTRACT_VECTOR_ELT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "default", ":", "break", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "ISD::INSERT_VECTOR_ELT", "0", "ISD::EXTRACT_VECTOR_ELT", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_RegMask", ":", "CSR_Win64_RegCall_NoSSE_RegMask", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_RegMask", ":", "CSR_SysV64_RegCall_NoSSE_RegMask", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_RegMask", ":", "CSR_32_RegCall_NoSSE_RegMask", ")", ";", "}", "case", "CallingConv", "::", "CFGuard_Check", ":", "assert", "(", "!", "Is64Bit", "&&", "\"CFGuard check mechanism only used on 32-bit X86\"", ")", ";", "return", "(", "HasSSE", "?", "CSR_Win32_CFGuard_Check_RegMask", ":", "CSR_Win32_CFGuard_Check_NoSSE_RegMask", ")", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "SwiftTail", ":", "return", "IsWin64", "?", "CSR_Win64_SwiftTail_RegMask", ":", "CSR_64_SwiftTail_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_64_AllRegs_RegMask", ";", "return", "CSR_64_AllRegs_NoSSE_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "IsSwiftCC", "=", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ";", "if", "(", "IsSwiftCC", ")", "return", "IsWin64", "?", "CSR_Win64_SwiftError_RegMask", ":", "CSR_64_SwiftError_RegMask", ";", "return", "IsWin64", "?", "CSR_Win64_RegMask", ":", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "X86", "X86", "X86", "X86", "X86", "\"CFGuard check mechanism only used on 32-bit X86\"", "X86", "X86" ]

[]

[ "<s>", "static", "void", "bounds_check", "(", "rtx", "operand", ",", "HOST_WIDE_INT", "low", ",", "HOST_WIDE_INT", "high", ",", "const_tree", "exp", ",", "const", "char", "*", "desc", ")", "{", "HOST_WIDE_INT", "lane", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operand", ")", ")", ";", "lane", "=", "INTVAL", "(", "operand", ")", ";", "if", "(", "lane", "<", "low", "||", "lane", ">=", "high", ")", "{", "if", "(", "exp", ")", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"%s %wd out of range %wd - %wd\"", ",", "desc", ",", "lane", ",", "low", ",", "high", "-", "1", ")", ";", "else", "error", "(", "\"%s %wd out of range %wd - %wd\"", ",", "desc", ",", "lane", ",", "low", ",", "high", "-", "1", ")", ";", "}", "}", "</s>" ]

[ "Ensure", "OPERAND", "lies", "between", "LOW", "(", "inclusive", ")", "and", "HIGH", "(", "exclusive", ")", ".", "Raise", "ERR", "if", "it", "does", "n't", ".", "FIXME", ":", "NEON", "bounds", "checks", "occur", "late", "in", "compilation", ",", "so", "reported", "source", "locations", "are", "bogus", "." ]

[ "arm", "\"%s %wd out of range %wd - %wd\"", "1", "\"%s %wd out of range %wd - %wd\"", "1" ]

[]

[ "<s>", "static", "bool", "need_to_save_reg", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "flag_pic", "&&", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "||", "regno", "==", "TILEPRO_PIC_TEXT_LABEL_REGNUM", ")", "&&", "(", "crtl", "->", "uses_pic_offset_table", "||", "crtl", "->", "saves_all_registers", ")", ")", "return", "true", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "i", ";", "for", "(", "i", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "i", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "{", "if", "(", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "REGNO", "needs", "to", "be", "saved", "in", "the", "stack", "frame", "." ]

[ "tilepro", "0" ]

[]

[ "<s>", "void", "X86AsmParser", "::", "emitInstruction", "(", "MCInst", "&", "Inst", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "arc_ccfsm_record_branch_deleted", "(", ")", "{", "arc_ccfsm_state", "+=", "2", ";", "current_insn_set_cc_p", "=", "last_insn_set_cc_p", ";", "}", "</s>" ]

[ "Record", "a", "branch", "is", "n't", "output", "because", "subsequent", "insns", "can", "be", "conditionalized", "." ]

[ "arc", "2" ]

[]

[ "<s>", "void", "HexagonShuffler", "::", "append", "(", "MCInst", "const", "*", "ID", ",", "MCInst", "const", "*", "Extender", ",", "unsigned", "S", ",", "bool", "X", ")", "{", "HexagonInstr", "PI", "(", "&", "TUL", ",", "MCII", ",", "ID", ",", "Extender", ",", "S", ",", "X", ")", ";", "Packet", ".", "push_back", "(", "PI", ")", ";", "}", "</s>" ]

[ "Append", "from", "a", "list", "of", "StringRefs", "." ]

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

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "ZERO", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "FP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "BP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwinABI", "(", ")", "||", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "const", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "||", "FuncInfo", "->", "usesTOCBasePtr", "(", ")", "||", "MF", ".", "hasInlineAsm", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "if", "(", "TFI", "->", "needsFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R31", ")", ";", "bool", "IsPositionIndependent", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "TM", ".", "isPPC64", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R29", ")", ";", "else", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "TM", ".", "isPPC64", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "markSuperRegs", "(", "Reserved", ",", "*", "I", ")", ";", "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", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::FP", "PPC::BP", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC", "PPC", "PPC", "PPC::R2", "PPC::R13", "PPC", "PPC::R13", "PPC::R31", "PPC", "PPC::R29", "PPC::R30", "PPC", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "void", "reset", "(", "unsigned", "RequiredSize", ")", "{", "RequiredShadowSize", "=", "RequiredSize", ";", "CurrentShadowSize", "=", "0", ";", "InShadow", "=", "true", ";", "}", "</s>" ]

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

[ "X86", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isDuplexPair", "(", "const", "MachineInstr", "*", "MIa", ",", "const", "MachineInstr", "*", "MIb", ")", "const", "{", "HexagonII", "::", "SubInstructionGroup", "MIaG", "=", "getDuplexCandidateGroup", "(", "MIa", ")", ";", "HexagonII", "::", "SubInstructionGroup", "MIbG", "=", "getDuplexCandidateGroup", "(", "MIb", ")", ";", "return", "(", "isDuplexPairMatch", "(", "MIaG", ",", "MIbG", ")", "||", "isDuplexPairMatch", "(", "MIbG", ",", "MIaG", ")", ")", ";", "}", "</s>" ]

[ "Symmetrical", ".", "See", "if", "these", "two", "instructions", "are", "fit", "for", "duplex", "pair", "." ]

[ "Hexagon", "Hexagon", "HexagonII::SubInstructionGroup", "HexagonII::SubInstructionGroup" ]

[]

[ "<s>", "static", "bool", "mips_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "GP_RETURN", "||", "regno", "==", "FP_RETURN", "||", "(", "FP_RETURN", "!=", "GP_RETURN", "&&", "regno", "==", "FP_RETURN", "+", "2", ")", ")", "return", "true", ";", "if", "(", "(", "mips_abi", "==", "ABI_32", "&&", "TARGET_FLOAT32", ")", "&&", "FP_RETURN", "!=", "GP_RETURN", "&&", "(", "regno", "==", "FP_RETURN", "+", "1", "||", "regno", "==", "FP_RETURN", "+", "3", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE_REGNO_P", ".", "On", "the", "MIPS", ",", "R2", "R3", "and", "F0", "F2", "are", "the", "only", "register", "thus", "used", "." ]

[ "mips", "2", "1", "3" ]

[]

[ "<s>", "SDValue", "XNCMTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_XNCM", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "XNCM", "XNCM", "ISD::InputArg", "16", "XNCM", "0", "1", "2", "0" ]

[]

[ "<s>", "BitVector", "MSP430RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGW", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "MSP430", "::", "FPW", ")", ";", "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", "." ]

[ "MSP430", "MSP430", "MSP430::PCW", "MSP430::SPW", "MSP430::SRW", "MSP430::CGW", "MSP430::FPW" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "MCInstrDesc", "&", "MCID", "=", "getInstDesc", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "ThumbArithFlagSetting", ")", "{", "assert", "(", "MCID", ".", "hasOptionalDef", "(", ")", "&&", "\"optionally flag setting instruction missing optional def operand\"", ")", ";", "assert", "(", "MCID", ".", "NumOperands", "==", "Inst", ".", "getNumOperands", "(", ")", "&&", "\"operand count mismatch!\"", ")", ";", "unsigned", "OpNo", ";", "for", "(", "OpNo", "=", "0", ";", "!", "MCID", ".", "OpInfo", "[", "OpNo", "]", ".", "isOptionalDef", "(", ")", "&&", "OpNo", "<", "MCID", ".", "NumOperands", ";", "++", "OpNo", ")", ";", "if", "(", "isThumbOne", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "Match_MnemonicFail", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", "&&", "!", "inITBlock", "(", ")", ")", "return", "Match_RequiresITBlock", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "inITBlock", "(", ")", ")", "return", "Match_RequiresNotITBlock", ";", "}", "else", "if", "(", "Opc", "==", "ARM", "::", "tADDhirr", "&&", "isThumbOne", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresThumb2", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "tMOVr", "&&", "isThumbOne", "(", ")", "&&", "!", "hasV6Ops", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresV6", ";", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "ARM", "ARM", "ARMII::ThumbArithFlagSetting", "\"optionally flag setting instruction missing optional def operand\"", "\"operand count mismatch!\"", "0", "ARM::CPSR", "ARM::CPSR", "ARM::CPSR", "ARM::tADDhirr", "ARM", "1", "ARM", "2", "ARM::tMOVr", "ARM", "0", "ARM", "1" ]

[]

[ "<s>", "rtx", "frv_return_addr_rtx", "(", "int", "count", ",", "rtx", "frame", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "cfun", "->", "machine", "->", "frame_needed", "=", "1", ";", "return", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "frame", ",", "8", ")", ")", ";", "}", "</s>" ]

[ "A", "C", "expression", "whose", "value", "is", "RTL", "representing", "the", "value", "of", "the", "return", "address", "for", "the", "frame", "COUNT", "steps", "up", "from", "the", "current", "frame", ",", "after", "the", "prologue", ".", "FRAMEADDR", "is", "the", "frame", "pointer", "of", "the", "COUNT", "frame", ",", "or", "the", "frame", "pointer", "of", "the", "COUNT", "-", "1", "frame", "if", "`", "RETURN_ADDR_IN_PREVIOUS_FRAME", "'", "is", "defined", ".", "The", "value", "of", "the", "expression", "must", "always", "be", "the", "correct", "address", "when", "COUNT", "is", "zero", ",", "but", "may", "be", "`", "NULL_RTX", "'", "if", "there", "is", "not", "way", "to", "determine", "the", "return", "address", "of", "other", "frames", "." ]

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

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getSystemZTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "hasLoadStoreOnCond", "(", ")", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "inline", "set_of_reg", "sh_find_set_of_reg", "(", "rtx", "reg", ",", "rtx_insn", "*", "insn", ",", "F", "stepfunc", ",", "bool", "ignore_reg_reg_copies", "=", "false", ")", "{", "set_of_reg", "result", ";", "result", ".", "insn", "=", "insn", ";", "result", ".", "set_rtx", "=", "NULL_RTX", ";", "result", ".", "set_src", "=", "NULL_RTX", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "insn", "==", "NULL_RTX", ")", "return", "result", ";", "for", "(", "rtx_insn", "*", "i", "=", "stepfunc", "(", "insn", ")", ";", "i", "!=", "NULL_RTX", ";", "i", "=", "stepfunc", "(", "i", ")", ")", "{", "if", "(", "BARRIER_P", "(", "i", ")", ")", "break", ";", "if", "(", "!", "INSN_P", "(", "i", ")", "||", "DEBUG_INSN_P", "(", "i", ")", ")", "continue", ";", "if", "(", "reg_set_p", "(", "reg", ",", "i", ")", ")", "{", "if", "(", "CALL_P", "(", "i", ")", ")", "break", ";", "result", ".", "insn", "=", "i", ";", "result", ".", "set_rtx", "=", "set_of", "(", "reg", ",", "i", ")", ";", "if", "(", "result", ".", "set_rtx", "==", "NULL_RTX", "||", "GET_CODE", "(", "result", ".", "set_rtx", ")", "!=", "SET", ")", "break", ";", "result", ".", "set_src", "=", "XEXP", "(", "result", ".", "set_rtx", ",", "1", ")", ";", "if", "(", "ignore_reg_reg_copies", "&&", "REG_P", "(", "result", ".", "set_src", ")", ")", "{", "reg", "=", "result", ".", "set_src", ";", "continue", ";", "}", "if", "(", "ignore_reg_reg_copies", "&&", "SUBREG_P", "(", "result", ".", "set_src", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "result", ".", "set_src", ")", ")", ")", "{", "reg", "=", "SUBREG_REG", "(", "result", ".", "set_src", ")", ";", "continue", ";", "}", "break", ";", "}", "}", "if", "(", "result", ".", "set_src", "!=", "NULL", ")", "gcc_assert", "(", "result", ".", "insn", "!=", "NULL", "&&", "result", ".", "set_rtx", "!=", "NULL", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Given", "a", "reg", "rtx", "and", "a", "start", "insn", ",", "try", "to", "find", "the", "insn", "that", "sets", "the", "specified", "reg", "by", "using", "the", "specified", "insn", "stepping", "function", ",", "such", "as", "'prev_nonnote_insn_bb", "'", ".", "When", "the", "insn", "is", "found", ",", "try", "to", "extract", "the", "rtx", "of", "the", "reg", "set", "." ]

[ "sh", "1" ]

[]

[ "<s>", "void", "ExportClustering", "::", "apply", "(", "ScheduleDAGInstrs", "*", "DAG", ")", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "DAG", "->", "TII", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "Chain", ";", "unsigned", "PosCount", "=", "0", ";", "for", "(", "SUnit", "&", "SU", ":", "DAG", "->", "SUnits", ")", "{", "if", "(", "!", "isExport", "(", "SU", ")", ")", "continue", ";", "Chain", ".", "push_back", "(", "&", "SU", ")", ";", "if", "(", "isPositionExport", "(", "TII", ",", "&", "SU", ")", ")", "PosCount", "++", ";", "removeExportDependencies", "(", "DAG", ",", "SU", ")", ";", "SmallVector", "<", "SDep", ",", "4", ">", "Succs", "(", "SU", ".", "Succs", ")", ";", "for", "(", "SDep", "Succ", ":", "Succs", ")", "removeExportDependencies", "(", "DAG", ",", "*", "Succ", ".", "getSUnit", "(", ")", ")", ";", "}", "if", "(", "Chain", ".", "size", "(", ")", ">", "1", ")", "{", "sortChain", "(", "TII", ",", "Chain", ",", "PosCount", ")", ";", "buildCluster", "(", "Chain", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AMDGPU", "SI", "SI", "8", "0", "4", "1" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "HasDebugInfo", "=", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ";", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "Module", "::", "GlobalListType", "&", "global_list", "=", "M", ".", "getGlobalList", "(", ")", ";", "int", "i", ",", "n", "=", "global_list", ".", "size", "(", ")", ";", "GlobalVariable", "*", "*", "gv_array", "=", "new", "GlobalVariable", "*", "[", "n", "]", ";", "i", "=", "0", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "global_list", ".", "begin", "(", ")", ",", "E", "=", "global_list", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "gv_array", "[", "i", "++", "]", "=", "&", "*", "I", ";", "while", "(", "!", "global_list", ".", "empty", "(", ")", ")", "global_list", ".", "remove", "(", "global_list", ".", "begin", "(", ")", ")", ";", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "global_list", ".", "insert", "(", "global_list", ".", "end", "(", ")", ",", "gv_array", "[", "i", "]", ")", ";", "clearAnnotationCache", "(", "&", "M", ")", ";", "delete", "[", "]", "gv_array", ";", "if", "(", "HasDebugInfo", ")", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", "->", "closeLastSection", "(", ")", ";", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", "->", "outputDwarfFileDirectives", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "RISCVInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Res", "=", "false", ";", "const", "MCInst", "*", "NewMI", "=", "MI", ";", "MCInst", "UncompressedMI", ";", "if", "(", "!", "NoAliases", ")", "Res", "=", "uncompressInst", "(", "UncompressedMI", ",", "*", "MI", ",", "MRI", ",", "STI", ")", ";", "if", "(", "Res", ")", "NewMI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "&", "UncompressedMI", ")", ";", "if", "(", "NoAliases", "||", "!", "printAliasInstr", "(", "NewMI", ",", "Address", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "NewMI", ",", "Address", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "SDValue", "BPFSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "bool", "MustPreserveCheriCapabilities", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "unsigned", "CopyLen", "=", "ConstantSize", "->", "getZExtValue", "(", ")", ";", "unsigned", "StoresNumEstimate", "=", "alignTo", "(", "CopyLen", ",", "Alignment", ")", ">>", "Log2", "(", "Alignment", ")", ";", "if", "(", "StoresNumEstimate", ">", "getCommonMaxStoresPerMemFunc", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "Dst", "=", "DAG", ".", "getNode", "(", "BPFISD", "::", "MEMCPY", ",", "dl", ",", "VTs", ",", "Chain", ",", "Dst", ",", "Src", ",", "DAG", ".", "getConstant", "(", "CopyLen", ",", "dl", ",", "MVT", "::", "i64", ")", ",", "DAG", ".", "getConstant", "(", "Alignment", ".", "value", "(", ")", ",", "dl", ",", "MVT", "::", "i64", ")", ")", ";", "return", "Dst", ".", "getValue", "(", "0", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "BPF", "BPF", "MVT::Other", "MVT::Glue", "BPFISD::MEMCPY", "MVT::i64", "MVT::i64", "0" ]

[]

[ "<s>", "static", "bool", "mem_shadd_or_shadd_rtx_p", "(", "rtx", "x", ")", "{", "return", "(", "(", "GET_CODE", "(", "x", ")", "==", "ASHIFT", "||", "GET_CODE", "(", "x", ")", "==", "MULT", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "(", "GET_CODE", "(", "x", ")", "==", "ASHIFT", "&&", "pa_shadd_constant_p", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "MULT", "&&", "pa_mem_shadd_constant_p", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Helper", "for", "hppa_legitimize_address", ".", "Given", "X", ",", "return", "true", "if", "it", "is", "a", "left", "shift", "by", "1", ",", "2", "or", "3", "positions", "or", "a", "multiply", "by", "2", ",", "4", "or", "8", ".", "This", "respectively", "represent", "canonical", "shift-add", "rtxs", "or", "scaled", "memory", "addresses", "." ]

[ "pa", "1", "1", "1" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "AllSGPRSpilledToVGPRs", "=", "false", ";", "if", "(", "TRI", ".", "spillSGPRToVGPR", "(", ")", "&&", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", "{", "AllSGPRSpilledToVGPRs", "=", "true", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "{", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "SIStackID", "::", "SGPR_SPILL", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "bool", "Spilled", "=", "TRI", ".", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "RS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "\"failed to spill SGPR to VGPR when allocated\"", ")", ";", "}", "else", "AllSGPRSpilledToVGPRs", "=", "false", ";", "}", "}", "}", "}", "FuncInfo", "->", "removeSGPRToVGPRFrameIndices", "(", "MFI", ")", ";", "if", "(", "FuncInfo", "->", "hasNonSpillStackObjects", "(", ")", "||", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "||", "!", "AllSGPRSpilledToVGPRs", "||", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "0", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "else", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateStackObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "TRI", ".", "getSpillAlignment", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::OpName", "SIStackID::SGPR_SPILL", "\"failed to spill SGPR to VGPR when allocated\"", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "0", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "unsigned", "TL45MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "return", "getTL45RegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "TL45", "TL45", "TL45", "0" ]

[]

[ "<s>", "static", "void", "tilepro_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", "ATTRIBUTE_UNUSED", ")", "{", "tree", "f_args", ",", "f_skip", ";", "tree", "args", ",", "skip", ",", "t", ";", "f_args", "=", "TYPE_FIELDS", "(", "TREE_TYPE", "(", "valist", ")", ")", ";", "f_skip", "=", "TREE_CHAIN", "(", "f_args", ")", ";", "args", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_args", ")", ",", "valist", ",", "f_args", ",", "NULL_TREE", ")", ";", "skip", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_skip", ")", ",", "valist", ",", "f_skip", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "args", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "UNITS_PER_WORD", "*", "(", "crtl", "->", "args", ".", "info", "-", "TILEPRO_NUM_ARG_REGS", ")", ")", ";", "if", "(", "crtl", "->", "args", ".", "pretend_args_size", ">", "0", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "STACK_POINTER_OFFSET", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "args", ")", ",", "args", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "skip", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "STACK_POINTER_OFFSET", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "skip", ")", ",", "skip", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN_VA_START", "." ]

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

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_emit_savres_rtx", "(", "rs6000_stack_t", "*", "info", ",", "rtx", "frame_reg_rtx", ",", "int", "save_area_offset", ",", "int", "lr_offset", ",", "machine_mode", "reg_mode", ",", "int", "sel", ")", "{", "int", "i", ";", "int", "offset", ",", "start_reg", ",", "end_reg", ",", "n_regs", ",", "use_reg", ";", "int", "reg_size", "=", "GET_MODE_SIZE", "(", "reg_mode", ")", ";", "rtx", "sym", ";", "rtvec", "p", ";", "rtx", "par", ";", "rtx_insn", "*", "insn", ";", "offset", "=", "0", ";", "start_reg", "=", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", "?", "info", "->", "first_gp_reg_save", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "info", "->", "first_fp_reg_save", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "info", "->", "first_altivec_reg_save", ":", "-", "1", ")", ";", "end_reg", "=", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", "?", "32", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "64", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "LAST_ALTIVEC_REGNO", "+", "1", ":", "-", "1", ")", ";", "n_regs", "=", "end_reg", "-", "start_reg", ";", "p", "=", "rtvec_alloc", "(", "3", "+", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "1", ":", "0", ")", "+", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "1", ":", "0", ")", "+", "n_regs", ")", ";", "if", "(", "!", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "ret_rtx", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_hard_reg_clobber", "(", "Pmode", ",", "LR_REGNO", ")", ";", "sym", "=", "rs6000_savres_routine_sym", "(", "info", ",", "sel", ")", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "sym", ")", ";", "use_reg", "=", "ptr_regno_for_savres", "(", "sel", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "{", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_hard_reg_clobber", "(", "Pmode", ",", "use_reg", ")", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ")", ";", "}", "else", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "use_reg", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "end_reg", "-", "start_reg", ";", "i", "++", ")", "RTVEC_ELT", "(", "p", ",", "i", "+", "offset", ")", "=", "gen_frame_set", "(", "gen_rtx_REG", "(", "reg_mode", ",", "start_reg", "+", "i", ")", ",", "frame_reg_rtx", ",", "save_area_offset", "+", "reg_size", "*", "i", ",", "(", "sel", "&", "SAVRES_SAVE", ")", "!=", "0", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "RTVEC_ELT", "(", "p", ",", "i", "+", "offset", ")", "=", "gen_frame_store", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "frame_reg_rtx", ",", "lr_offset", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ";", "if", "(", "!", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "{", "insn", "=", "emit_jump_insn", "(", "par", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "ret_rtx", ";", "}", "else", "insn", "=", "emit_insn", "(", "par", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Construct", "a", "parallel", "rtx", "describing", "the", "effect", "of", "a", "call", "to", "an", "out-of-line", "register", "save/restore", "routine", ",", "and", "emit", "the", "insn", "or", "jump_insn", "as", "appropriate", "." ]

[ "rs6000", "0", "1", "32", "64", "1", "1", "3", "1", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "MVEVPTBlock", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", "||", "!", "STI", ".", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "RDA", "=", "&", "getAnalysis", "<", "ReachingDefAnalysis", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM MVE VPT BLOCKS **********\\n\"", "<<", "\"********** Function: \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "InsertVPTBlocks", "(", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"********** ARM MVE VPT BLOCKS **********\\n\"", "\"********** Function: \"", "\"**************************************\\n\"" ]

[]

[ "<s>", "static", "bool", "use_32bit_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "known_32bit_mult_mcus", "[", "]", "=", "{", "\"msp430f4783\"", ",", "\"msp430f4793\"", ",", "\"msp430f4784\"", ",", "\"msp430f4794\"", ",", "\"msp430f47126\"", ",", "\"msp430f47127\"", ",", "\"msp430f47163\"", ",", "\"msp430f47173\"", ",", "\"msp430f47183\"", ",", "\"msp430f47193\"", ",", "\"msp430f47166\"", ",", "\"msp430f47176\"", ",", "\"msp430f47186\"", ",", "\"msp430f47196\"", ",", "\"msp430f47167\"", ",", "\"msp430f47177\"", ",", "\"msp430f47187\"", ",", "\"msp430f47197\"", "}", ";", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "int", "i", ";", "if", "(", "msp430_hwmult_type", "==", "LARGE", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "NULL", "||", "msp430_hwmult_type", "!=", "AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "known_32bit_mult_mcus", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "target_mcu", ",", "known_32bit_mult_mcus", "[", "i", "]", ")", "==", "0", ")", "return", "cached_result", "=", "true", ";", "return", "cached_result", "=", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "has", "a", "second", "generation", "32-bit", "hardware", "multiplier", "." ]

[ "msp430", "\"msp430f4783\"", "\"msp430f4793\"", "\"msp430f4784\"", "\"msp430f4794\"", "\"msp430f47126\"", "\"msp430f47127\"", "\"msp430f47163\"", "\"msp430f47173\"", "\"msp430f47183\"", "\"msp430f47193\"", "\"msp430f47166\"", "\"msp430f47176\"", "\"msp430f47186\"", "\"msp430f47196\"", "\"msp430f47167\"", "\"msp430f47177\"", "\"msp430f47187\"", "\"msp430f47197\"", "0" ]

[]

[ "<s>", "bool", "isValid", "(", ")", "{", "return", "isFIBase", "(", ")", "||", "(", "isRegBase", "(", ")", "&&", "getReg", "(", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "ARM64", "0" ]

[]

[ "<s>", "MCSymbol", "*", "MSP430MCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "MSP430", "MSP430", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "static", "void", "arm_init_neon_builtins", "(", "void", ")", "{", "unsigned", "int", "i", ",", "fcode", "=", "ARM_BUILTIN_NEON_PATTERN_START", ";", "arm_init_simd_builtin_types", "(", ")", ";", "arm_init_simd_builtin_scalar_types", "(", ")", ";", "tree", "lane_check_fpr", "=", "build_function_type_list", "(", "void_type_node", ",", "intSI_type_node", ",", "intSI_type_node", ",", "NULL", ")", ";", "arm_builtin_decls", "[", "ARM_BUILTIN_NEON_LANE_CHECK", "]", "=", "add_builtin_function", "(", "\"__builtin_arm_lane_check\"", ",", "lane_check_fpr", ",", "ARM_BUILTIN_NEON_LANE_CHECK", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "neon_builtin_data", ")", ";", "i", "++", ",", "fcode", "++", ")", "{", "arm_builtin_datum", "*", "d", "=", "&", "neon_builtin_data", "[", "i", "]", ";", "arm_init_builtin", "(", "fcode", ",", "d", ",", "\"__builtin_neon\"", ")", ";", "}", "}", "</s>" ]

[ "Set", "up", "all", "the", "NEON", "builtins", ",", "even", "builtins", "for", "instructions", "that", "are", "not", "in", "the", "current", "target", "ISA", "to", "allow", "the", "user", "to", "compile", "particular", "modules", "with", "different", "target", "specific", "options", "that", "differ", "from", "the", "command", "line", "options", ".", "Such", "builtins", "will", "be", "rejected", "in", "arm_expand_builtin", "." ]

[ "arm", "\"__builtin_arm_lane_check\"", "0", "\"__builtin_neon\"" ]

[]

[ "<s>", "void", "RISCVDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "SelectionDAG", "::", "allnodes_iterator", "Position", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "Position", "!=", "CurDAG", "->", "allnodes_begin", "(", ")", ")", "{", "SDNode", "*", "N", "=", "&", "*", "--", "Position", ";", "if", "(", "N", "->", "use_empty", "(", ")", "||", "!", "N", "->", "isMachineOpcode", "(", ")", ")", "continue", ";", "MadeChange", "|=", "doPeepholeSExtW", "(", "N", ")", ";", "MadeChange", "|=", "doPeepholeLoadStoreADDI", "(", "N", ")", ";", "}", "if", "(", "MadeChange", ")", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "tree", "rx_handle_func_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Check", "``", "fast_interrupt", "''", ",", "``", "interrupt", "''", "and", "``", "naked", "''", "attributes", "." ]

[ "rx", "\"%qE attribute only applies to functions\"" ]

[]

[ "<s>", "unsigned", "HSAILInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "!", "MCID", ".", "mayLoad", "(", ")", "||", "!", "MI", "->", "hasOneMemOperand", "(", ")", ")", "return", "HSAIL", "::", "NoRegister", ";", "const", "MachineOperand", "*", "Segment", "=", "getNamedOperand", "(", "*", "MI", ",", "HSAIL", "::", "OpName", "::", "segment", ")", ";", "if", "(", "!", "Segment", "||", "Segment", "->", "getImm", "(", ")", "!=", "HSAILAS", "::", "SPILL_ADDRESS", ")", "return", "HSAIL", "::", "NoRegister", ";", "int", "AddressIdx", "=", "HSAIL", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "HSAIL", "::", "OpName", "::", "address", ")", ";", "const", "MachineOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "AddressIdx", "+", "HSAILADDRESS", "::", "BASE", ")", ";", "if", "(", "Base", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "Base", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "HSAIL", "::", "NoRegister", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "HSAIL::NoRegister", "HSAIL::OpName", "HSAILAS::SPILL_ADDRESS", "HSAIL::NoRegister", "HSAIL::getNamedOperandIdx", "HSAIL::OpName", "HSAILADDRESS::BASE", "0", "HSAIL::NoRegister" ]

[]

[ "<s>", "int", "ARMBaseInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "SDNode", "*", "Node", ")", "const", "{", "if", "(", "!", "Node", "->", "isMachineOpcode", "(", ")", ")", "return", "1", ";", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "1", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "ItinData", "->", "getStageLatency", "(", "get", "(", "Opcode", ")", ".", "getSchedClass", "(", ")", ")", ";", "case", "ARM", "::", "VLDMQIA", ":", "case", "ARM", "::", "VLDMQDB", ":", "case", "ARM", "::", "VSTMQIA", ":", "case", "ARM", "::", "VSTMQDB", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "ARM", "ARM", "1", "1", "ARM::VLDMQIA", "ARM::VLDMQDB", "ARM::VSTMQIA", "ARM::VSTMQDB", "2" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "JIT", ",", "RM", ")", ",", "getEffectiveX86CodeModel", "(", "CM", ",", "JIT", ",", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", "{", "if", "(", "TT", ".", "isPS4", "(", ")", "||", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "TT", ".", "isOSBinFormatMachO", "(", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDebugEntryValues", "(", "true", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "*", "MipsSETargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "MipsTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "BPOSGE32_PSEUDO", ":", "return", "emitBPOSGE32", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "SNZ_B_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_B", ")", ";", "case", "Mips", "::", "SNZ_H_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_H", ")", ";", "case", "Mips", "::", "SNZ_W_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_W", ")", ";", "case", "Mips", "::", "SNZ_D_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_D", ")", ";", "case", "Mips", "::", "SNZ_V_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_V", ")", ";", "case", "Mips", "::", "SZ_B_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_B", ")", ";", "case", "Mips", "::", "SZ_H_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_H", ")", ";", "case", "Mips", "::", "SZ_W_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_W", ")", ";", "case", "Mips", "::", "SZ_D_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_D", ")", ";", "case", "Mips", "::", "SZ_V_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_V", ")", ";", "case", "Mips", "::", "COPY_FW_PSEUDO", ":", "return", "emitCOPY_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "COPY_FD_PSEUDO", ":", "return", "emitCOPY_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_FW_PSEUDO", ":", "return", "emitINSERT_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_FD_PSEUDO", ":", "return", "emitINSERT_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_B_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_B_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "1", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_H_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_H_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "2", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_W_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_W_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "4", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_D_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_D_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "8", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_FW_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_FW_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "4", ",", "true", ")", ";", "case", "Mips", "::", "INSERT_FD_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_FD_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "8", ",", "true", ")", ";", "case", "Mips", "::", "FILL_FW_PSEUDO", ":", "return", "emitFILL_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FILL_FD_PSEUDO", ":", "return", "emitFILL_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FEXP2_W_1_PSEUDO", ":", "return", "emitFEXP2_W_1", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FEXP2_D_1_PSEUDO", ":", "return", "emitFEXP2_D_1", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Mips", "Mips", "Mips", "Mips::BPOSGE32_PSEUDO", "Mips::SNZ_B_PSEUDO", "Mips::BNZ_B", "Mips::SNZ_H_PSEUDO", "Mips::BNZ_H", "Mips::SNZ_W_PSEUDO", "Mips::BNZ_W", "Mips::SNZ_D_PSEUDO", "Mips::BNZ_D", "Mips::SNZ_V_PSEUDO", "Mips::BNZ_V", "Mips::SZ_B_PSEUDO", "Mips::BZ_B", "Mips::SZ_H_PSEUDO", "Mips::BZ_H", "Mips::SZ_W_PSEUDO", "Mips::BZ_W", "Mips::SZ_D_PSEUDO", "Mips::BZ_D", "Mips::SZ_V_PSEUDO", "Mips::BZ_V", "Mips::COPY_FW_PSEUDO", "Mips::COPY_FD_PSEUDO", "Mips::INSERT_FW_PSEUDO", "Mips::INSERT_FD_PSEUDO", "Mips::INSERT_B_VIDX_PSEUDO", "Mips::INSERT_B_VIDX64_PSEUDO", "1", "Mips::INSERT_H_VIDX_PSEUDO", "Mips::INSERT_H_VIDX64_PSEUDO", "2", "Mips::INSERT_W_VIDX_PSEUDO", "Mips::INSERT_W_VIDX64_PSEUDO", "4", "Mips::INSERT_D_VIDX_PSEUDO", "Mips::INSERT_D_VIDX64_PSEUDO", "8", "Mips::INSERT_FW_VIDX_PSEUDO", "Mips::INSERT_FW_VIDX64_PSEUDO", "4", "Mips::INSERT_FD_VIDX_PSEUDO", "Mips::INSERT_FD_VIDX64_PSEUDO", "8", "Mips::FILL_FW_PSEUDO", "Mips::FILL_FD_PSEUDO", "Mips::FEXP2_W_1_PSEUDO", "Mips::FEXP2_D_1_PSEUDO" ]

[]

[ "<s>", "rtx", "extract_shift_reg", "(", "rtx", "alu_shift_rtx", ")", "{", "alu_shift_rtx", "=", "extract_pattern_from_insn", "(", "alu_shift_rtx", ")", ";", "rtx", "alu_rtx", "=", "SET_SRC", "(", "alu_shift_rtx", ")", ";", "rtx", "shift_rtx", ";", "if", "(", "REG_P", "(", "XEXP", "(", "alu_rtx", ",", "0", ")", ")", ")", "shift_rtx", "=", "XEXP", "(", "alu_rtx", ",", "1", ")", ";", "else", "shift_rtx", "=", "XEXP", "(", "alu_rtx", ",", "0", ")", ";", "return", "XEXP", "(", "shift_rtx", ",", "0", ")", ";", "}", "</s>" ]

[ "Extract", "the", "register", "of", "the", "shift", "operand", "from", "an", "ALU_SHIFT", "rtx", "." ]

[ "nds32", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "GCNMaxOccupancySchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "DAG", ")", "{", "GenericScheduler", "::", "initialize", "(", "DAG", ")", ";", "const", "SIRegisterInfo", "*", "SRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "TRI", ")", ";", "MF", "=", "&", "DAG", "->", "MF", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "int", "ErrorMargin", "=", "3", ";", "SGPRExcessLimit", "=", "Context", "->", "RegClassInfo", "->", "getNumAllocatableRegs", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", "-", "ErrorMargin", ";", "VGPRExcessLimit", "=", "Context", "->", "RegClassInfo", "->", "getNumAllocatableRegs", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", "-", "ErrorMargin", ";", "if", "(", "TargetOccupancy", ")", "{", "SGPRCriticalLimit", "=", "ST", ".", "getMaxNumSGPRs", "(", "TargetOccupancy", ",", "true", ")", ";", "VGPRCriticalLimit", "=", "ST", ".", "getMaxNumVGPRs", "(", "TargetOccupancy", ")", ";", "}", "else", "{", "SGPRCriticalLimit", "=", "SRI", "->", "getRegPressureSetLimit", "(", "DAG", "->", "MF", ",", "SRI", "->", "getSGPRPressureSet", "(", ")", ")", ";", "VGPRCriticalLimit", "=", "SRI", "->", "getRegPressureSetLimit", "(", "DAG", "->", "MF", ",", "SRI", "->", "getVGPRPressureSet", "(", ")", ")", ";", "}", "SGPRCriticalLimit", "-=", "ErrorMargin", ";", "VGPRCriticalLimit", "-=", "ErrorMargin", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "3", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "mips_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Allocate", "a", "chunk", "of", "memory", "for", "per-function", "machine-dependent", "data", "." ]

[ "mips" ]

[]

[ "<s>", "rtx", "function_arg", "(", "CUMULATIVE_ARGS", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_assert", "(", "!", "COMPLEX_MODE_P", "(", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "alpha_arg_info_reg_val", "(", "cum", ")", ";", "num_args", "=", "cum", ".", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "{", "int", "size", ";", "if", "(", "mode", "==", "VOIDmode", ")", "{", "int", "i", ";", "HOST_WIDE_INT", "lo", ";", "HOST_WIDE_INT", "hi", ";", "rtx", "ciw", ";", "lo", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "cum", ".", "num_reg_words", "&&", "i", "<", "5", ";", "i", "++", ")", "if", "(", "cum", ".", "reg_args_type", "[", "i", "]", ")", "lo", "|=", "(", "1", "<<", "(", "7", "-", "i", ")", ")", ";", "if", "(", "cum", ".", "num_reg_words", "==", "6", "&&", "cum", ".", "reg_args_type", "[", "5", "]", ")", "lo", "|=", "7", ";", "else", "lo", "|=", "cum", ".", "num_reg_words", ";", "hi", "=", "(", "cum", ".", "num_args", "<<", "20", ")", "|", "cum", ".", "num_arg_words", ";", "lo", "=", "lo", "|", "(", "(", "HOST_WIDE_INT", ")", "cum", ".", "num_args", "<<", "52", ")", "|", "(", "(", "HOST_WIDE_INT", ")", "cum", ".", "num_arg_words", "<<", "32", ")", ";", "hi", "=", "0", ";", "ciw", "=", "immed_double_const", "(", "lo", ",", "hi", ",", "DImode", ")", ";", "return", "gen_rtx_UNSPEC", "(", "DImode", ",", "gen_rtvec", "(", "1", ",", "ciw", ")", ",", "UNSPEC_UMK_LOAD_CIW", ")", ";", "}", "size", "=", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ",", "named", ")", ";", "num_args", "=", "cum", ".", "num_reg_words", ";", "if", "(", "cum", ".", "force_stack", "||", "cum", ".", "num_reg_words", "+", "size", ">", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "else", "if", "(", "type", "&&", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", "{", "rtx", "reg1", ",", "reg2", ";", "reg1", "=", "gen_rtx_REG", "(", "DImode", ",", "num_args", "+", "16", ")", ";", "reg1", "=", "gen_rtx_EXPR_LIST", "(", "DImode", ",", "reg1", ",", "const0_rtx", ")", ";", "if", "(", "size", "==", "0", ")", "return", "NULL_RTX", ";", "else", "if", "(", "size", "==", "1", ")", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "reg1", ")", ")", ";", "else", "{", "reg2", "=", "gen_rtx_REG", "(", "DImode", ",", "num_args", "+", "17", ")", ";", "reg2", "=", "gen_rtx_EXPR_LIST", "(", "DImode", ",", "reg2", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "reg1", ",", "reg2", ")", ")", ";", "}", "}", "}", "{", "if", "(", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "cum", ";", "if", "(", "type", "==", "void_type_node", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "." ]

[ "alpha", "16", "32", "16", "16", "6", "0", "0", "5", "1", "7", "6", "5", "7", "20", "52", "32", "0", "1", "6", "16", "0", "1", "1", "17", "8", "2", "6", "16" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "isCortexA9", "(", ")", ")", "return", "false", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->", "isSwift", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "mt_asm_output_opcode", "(", "FILE", "*", "f", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "ptr", ")", "{", "if", "(", "mt_nops_required", ")", "fprintf", "(", "f", ",", "\";# need %d nops because of %s\\n\\t\"", ",", "mt_nops_required", ",", "mt_nop_reasons", ")", ";", "while", "(", "mt_nops_required", ")", "{", "fprintf", "(", "f", ",", "\"nop\\n\\t\"", ")", ";", "--", "mt_nops_required", ";", "}", "return", "ptr", ";", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_OPCODE", "." ]

[ "mt", "\";# need %d nops because of %s\\n\\t\"", "\"nop\\n\\t\"" ]

[]

[ "<s>", "void", "rs6000_xcoff_declare_function_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "tree", "decl", ")", "{", "char", "*", "buffer", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "name", ")", "+", "1", ")", ";", "char", "*", "p", ";", "int", "dollar_inside", "=", "0", ";", "struct", "declare_alias_data", "data", "=", "{", "file", ",", "false", "}", ";", "strcpy", "(", "buffer", ",", "name", ")", ";", "p", "=", "strchr", "(", "buffer", ",", "'$'", ")", ";", "while", "(", "p", ")", "{", "*", "p", "=", "'_'", ";", "dollar_inside", "++", ";", "p", "=", "strchr", "(", "p", "+", "1", ",", "'$'", ")", ";", "}", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "{", "if", "(", "!", "RS6000_WEAK", "||", "!", "DECL_WEAK", "(", "decl", ")", ")", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.globl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "else", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.lglobl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "fputs", "(", "\"\\t.csect \"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"[DS]\\n\"", ":", "\"[DS],3\\n\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\t.long .\"", ":", "\"\\t.llong .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\", TOC[tc0], 0\\n\"", ",", "file", ")", ";", "in_section", "=", "NULL", ";", "switch_to_section", "(", "function_section", "(", "decl", ")", ")", ";", "putc", "(", "'.'", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "data", ".", "function_descriptor", "=", "true", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "if", "(", "!", "DECL_IGNORED_P", "(", "decl", ")", ")", "{", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "xcoffout_declare_function", "(", "file", ",", "decl", ",", "buffer", ")", ";", "else", "if", "(", "write_symbols", "==", "DWARF2_DEBUG", ")", "{", "name", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.function .%s,.%s,2,0\\n\"", ",", "name", ",", "name", ")", ";", "}", "}", "return", ";", "}", "</s>" ]

[ "This", "macro", "produces", "the", "initial", "definition", "of", "a", "function", "name", ".", "On", "the", "RS/6000", ",", "we", "need", "to", "place", "an", "extra", "'", ".", "'", "in", "the", "function", "name", "and", "output", "the", "function", "descriptor", ".", "Dollar", "signs", "are", "converted", "to", "underscores", ".", "The", "csect", "for", "the", "function", "will", "have", "already", "been", "created", "when", "text_section", "was", "selected", ".", "We", "do", "have", "to", "go", "back", "to", "that", "csect", ",", "however", ".", "The", "third", "and", "fourth", "parameters", "to", "the", ".function", "pseudo-op", "(", "16", "and", "044", ")", "are", "placeholders", "which", "no", "longer", "have", "any", "use", ".", "Because", "AIX", "assembler", "'s", ".set", "command", "has", "unexpected", "semantics", ",", "we", "output", "all", "aliases", "as", "alternative", "labels", "in", "front", "of", "the", "definition", "." ]

[ "rs6000", "1", "0", "1", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.globl .\"", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.lglobl .\"", "\"\\t.csect \"", "\"[DS]\\n\"", "\"[DS],3\\n\"", "\":\\n\"", "\"\\t.long .\"", "\"\\t.llong .\"", "\", TOC[tc0], 0\\n\"", "\":\\n\"", "\"\\t.function .%s,.%s,2,0\\n\"" ]

[]

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

[ "The", "EABI", "says", "test", "the", "least", "significant", "bit", "of", "a", "guard", "variable", "." ]

[ "arm" ]

[]

[ "<s>", "void", "HexagonTargetMachine", "::", "registerPassBuilderCallbacks", "(", "PassBuilder", "&", "PB", ")", "{", "PB", ".", "registerLateLoopOptimizationsEPCallback", "(", "[", "=", "]", "(", "LoopPassManager", "&", "LPM", ",", "PassBuilder", "::", "OptimizationLevel", "Level", ")", "{", "LPM", ".", "addPass", "(", "HexagonLoopIdiomRecognitionPass", "(", ")", ")", ";", "}", ")", ";", "PB", ".", "registerLoopOptimizerEndEPCallback", "(", "[", "=", "]", "(", "LoopPassManager", "&", "LPM", ",", "PassBuilder", "::", "OptimizationLevel", "Level", ")", "{", "LPM", ".", "addPass", "(", "HexagonVectorLoopCarriedReusePass", "(", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Invoke", "the", "PassBuilder", "callback", "registration", "." ]

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

[]

[ "<s>", "bool", "MipsAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "8", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "if", "(", "processInstruction", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ")", "return", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Instructions", ".", "size", "(", ")", ";", "i", "++", ")", "Out", ".", "EmitInstruction", "(", "Instructions", "[", "i", "]", ",", "STI", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MipsOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_RequiresDifferentSrcAndDst", ":", "return", "Error", "(", "IDLoc", ",", "\"source and destination must be different\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Mips", "Mips", "8", "0", "\"instruction requires a CPU feature not currently enabled\"", "0ULL", "\"too few operands for instruction\"", "Mips", "\"invalid operand for instruction\"", "\"invalid instruction\"", "\"source and destination must be different\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "rtx", "push", "(", "int", "rn", ")", "{", "rtx", "x", ";", "if", "(", "rn", "==", "FPUL_REG", ")", "x", "=", "gen_push_fpul", "(", ")", ";", "else", "if", "(", "rn", "==", "FPSCR_REG", ")", "x", "=", "gen_push_fpscr", "(", ")", ";", "else", "if", "(", "TARGET_FPU_DOUBLE", "&&", "TARGET_FMOVD", "&&", "!", "TARGET_FPU_SINGLE", "&&", "FP_OR_XD_REGISTER_P", "(", "rn", ")", ")", "{", "if", "(", "FP_REGISTER_P", "(", "rn", ")", "&&", "(", "rn", "-", "FIRST_FP_REG", ")", "&", "1", ")", "return", "NULL_RTX", ";", "x", "=", "gen_push_4", "(", "gen_rtx_REG", "(", "DFmode", ",", "rn", ")", ")", ";", "}", "else", "if", "(", "TARGET_SH2E", "&&", "FP_REGISTER_P", "(", "rn", ")", ")", "x", "=", "gen_push_e", "(", "gen_rtx_REG", "(", "SFmode", ",", "rn", ")", ")", ";", "else", "x", "=", "gen_push", "(", "gen_rtx_REG", "(", "SImode", ",", "rn", ")", ")", ";", "x", "=", "emit_frame_insn", "(", "x", ")", ";", "add_reg_note", "(", "x", ",", "REG_INC", ",", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "push", "register", "RN", "onto", "the", "stack", "." ]

[ "sh", "1" ]

[]

[ "<s>", "enum", "reg_class", "alpha_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "class", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "class", "==", "FLOAT_REGS", ")", "return", "NO_REGS", ";", "if", "(", "class", "==", "ALL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "class", ";", "}", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "(", "class", "==", "ALL_REGS", "?", "GENERAL_REGS", ":", "class", ")", ";", "return", "class", ";", "}", "</s>" ]

[ "On", "the", "Alpha", ",", "all", "(", "non-symbolic", ")", "constants", "except", "zero", "go", "into", "a", "floating-point", "register", "via", "memory", ".", "Note", "that", "we", "can", "not", "return", "anything", "that", "is", "not", "a", "subset", "of", "CLASS", ",", "and", "that", "some", "symbolic", "constants", "can", "not", "be", "dropped", "to", "memory", "." ]

[ "alpha" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_lxvr_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ",", "bool", "blk", ",", "bool", "sign_extend", ")", "{", "rtx", "pat", ",", "addr", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "smode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "Pmode", ";", "machine_mode", "mode1", "=", "Pmode", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "if", "(", "icode", "==", "CODE_FOR_nothing", ")", "return", "0", ";", "if", "(", "arg0", "==", "error_mark_node", "||", "arg1", "==", "error_mark_node", ")", "return", "const0_rtx", ";", "if", "(", "target", "==", "0", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "if", "(", "op0", "==", "const0_rtx", ")", "addr", "=", "gen_rtx_MEM", "(", "blk", "?", "BLKmode", ":", "tmode", ",", "op1", ")", ";", "else", "{", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "blk", "?", "BLKmode", ":", "smode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "op1", ",", "op0", ")", ")", ";", "}", "if", "(", "sign_extend", ")", "{", "rtx", "discratch", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "tiscratch", "=", "gen_reg_rtx", "(", "TImode", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "tiscratch", ",", "addr", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "rtx", "scratch", "=", "gen_lowpart", "(", "smode", ",", "tiscratch", ")", ";", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrbx", ")", "emit_insn", "(", "gen_extendqidi2", "(", "discratch", ",", "scratch", ")", ")", ";", "else", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrhx", ")", "emit_insn", "(", "gen_extendhidi2", "(", "discratch", ",", "scratch", ")", ")", ";", "else", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrwx", ")", "emit_insn", "(", "gen_extendsidi2", "(", "discratch", ",", "scratch", ")", ")", ";", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrdx", ")", "discratch", "=", "scratch", ";", "emit_insn", "(", "gen_extendditi2", "(", "target", ",", "discratch", ")", ")", ";", "return", "target", ";", "}", "else", "{", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "addr", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "For", "the", "load", "and", "sign", "extend", "rightmost", "elements", ";", "load", "and", "zero", "extend", "rightmost", "element", "builtins", "." ]

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

[]

[ "<s>", "int", "ia64_move_ok", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "if", "(", "GET_CODE", "(", "dst", ")", "!=", "MEM", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "return", "0", ";", "if", "(", "register_operand", "(", "src", ",", "VOIDmode", ")", ")", "return", "1", ";", "if", "(", "INTEGRAL_MODE_P", "(", "GET_MODE", "(", "dst", ")", ")", ")", "return", "src", "==", "const0_rtx", ";", "else", "return", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", "&&", "CONST_DOUBLE_OK_FOR_G", "(", "src", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "operands", "of", "a", "move", "are", "ok", "." ]

[ "ia64", "1", "0", "1" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isSExtCheaperThanZExt", "(", "EVT", "SrcVT", ",", "EVT", "DstVT", ")", "const", "{", "return", "Subtarget", ".", "is64Bit", "(", ")", "&&", "SrcVT", "==", "MVT", "::", "i32", "&&", "DstVT", "==", "MVT", "::", "i64", ";", "}", "</s>" ]

[ "Return", "true", "if", "sign-extension", "from", "FromTy", "to", "ToTy", "is", "cheaper", "than", "zero-extension", "." ]

[ "RI5CY", "RISCV", "MVT::i32", "MVT::i64" ]

[]

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

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "NVPTX" ]

[]

[ "<s>", "MachineBasicBlock", "*", "XCoreTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "SELECT_CC", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "BRFT_lru6", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "XCore", "XCore", "XCore::SELECT_CC", "\"Unexpected instr type to insert\"", "XCore::BRFT_lru6", "1", "XCore::PHI", "0", "3", "2" ]

[]

[ "<s>", "HOST_WIDE_INT", "bfin_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "offset", "=", "n_regs_saved_by_prologue", "(", ")", "*", "4", ";", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "if", "(", "crtl", "->", "outgoing_args_size", ">=", "FIXED_STACK_AREA", ")", "offset", "+=", "crtl", "->", "outgoing_args_size", ";", "else", "if", "(", "crtl", "->", "outgoing_args_size", ")", "offset", "+=", "FIXED_STACK_AREA", ";", "offset", "+=", "get_frame_size", "(", ")", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "Return", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "bfin", "0", "4" ]

[]

[ "<s>", "bool", "PTXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "formatted_raw_ostream", "&", "Out", ",", "CodeGenFileType", "FileType", ",", "CodeGenOpt", "::", "Level", "OptLevel", ",", "bool", "DisableVerify", ")", "{", "MCContext", "*", "Context", "=", "0", ";", "if", "(", "addCommonCodeGenPasses", "(", "PM", ",", "OptLevel", ",", "DisableVerify", ",", "Context", ")", ")", "return", "true", ";", "assert", "(", "Context", "!=", "0", "&&", "\"Failed to get MCContext\"", ")", ";", "if", "(", "hasMCSaveTempLabels", "(", ")", ")", "Context", "->", "setAllowTemporaryLabels", "(", "false", ")", ";", "const", "MCAsmInfo", "&", "MAI", "=", "*", "getMCAsmInfo", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ";", "OwningPtr", "<", "MCStreamer", ">", "AsmStreamer", ";", "switch", "(", "FileType", ")", "{", "default", ":", "return", "true", ";", "case", "CGFT_AssemblyFile", ":", "{", "MCInstPrinter", "*", "InstPrinter", "=", "getTarget", "(", ")", ".", "createMCInstPrinter", "(", "MAI", ".", "getAssemblerDialect", "(", ")", ",", "MAI", ",", "STI", ")", ";", "MCCodeEmitter", "*", "MCE", "=", "0", ";", "MCAsmBackend", "*", "MAB", "=", "0", ";", "MCStreamer", "*", "S", "=", "getTarget", "(", ")", ".", "createAsmStreamer", "(", "*", "Context", ",", "Out", ",", "true", ",", "hasMCUseLoc", "(", ")", ",", "hasMCUseCFI", "(", ")", ",", "hasMCUseDwarfDirectory", "(", ")", ",", "InstPrinter", ",", "MCE", ",", "MAB", ",", "false", ")", ";", "AsmStreamer", ".", "reset", "(", "S", ")", ";", "break", ";", "}", "case", "CGFT_ObjectFile", ":", "{", "llvm_unreachable", "(", "\"Object file emission is not supported with PTX\"", ")", ";", "}", "case", "CGFT_Null", ":", "AsmStreamer", ".", "reset", "(", "createNullStreamer", "(", "*", "Context", ")", ")", ";", "break", ";", "}", "FunctionPass", "*", "Printer", "=", "getTarget", "(", ")", ".", "createAsmPrinter", "(", "*", "this", ",", "*", "AsmStreamer", ")", ";", "if", "(", "Printer", "==", "0", ")", "return", "true", ";", "AsmStreamer", ".", "take", "(", ")", ";", "PM", ".", "add", "(", "Printer", ")", ";", "PM", ".", "add", "(", "createGCInfoDeleter", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "PTX", "PTX", "0", "0", "\"Failed to get MCContext\"", "0", "0", "\"Object file emission is not supported with PTX\"", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "VT", "==", "MVT", "::", "Other", "||", "(", "VT", "!=", "MVT", "::", "Other", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "1024", "&&", "VT", ".", "getStoreSize", "(", ")", ">", "16", ")", ")", "{", "return", "false", ";", "}", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "{", "bool", "AlignedBy4", "=", "(", "Align", "%", "4", "==", "0", ")", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "AlignedBy4", ";", "return", "AlignedBy4", ";", "}", "if", "(", "!", "Subtarget", "->", "hasUnalignedScratchAccess", "(", ")", "&&", "(", "AddrSpace", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", ")", "{", "return", "false", ";", "}", "if", "(", "Subtarget", "->", "hasUnalignedBufferAccess", "(", ")", ")", "{", "if", "(", "IsFast", ")", "{", "*", "IsFast", "=", "(", "AddrSpace", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", "?", "(", "Align", "%", "4", "==", "0", ")", ":", "true", ";", "}", "return", "true", ";", "}", "if", "(", "VT", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "return", "false", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "true", ";", "return", "VT", ".", "bitsGT", "(", "MVT", "::", "i32", ")", "&&", "Align", "%", "4", "==", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "AMDGPU", "SI", "MVT::Other", "MVT::Other", "1024", "16", "AMDGPU", "AMDGPU", "4", "0", "AMDGPU", "AMDGPU", "AMDGPU", "4", "0", "MVT::i32", "MVT::i32", "4", "0" ]

[]

[ "<s>", "const", "BPFSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "BPF", "BPF" ]

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "X86InstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "uint16_t", "domain", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "bool", "hasAVX2", "=", "Subtarget", ".", "hasAVX2", "(", ")", ";", "uint16_t", "validDomains", "=", "0", ";", "if", "(", "domain", "&&", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "0xe", ";", "else", "if", "(", "domain", "&&", "lookupAVX2", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "hasAVX2", "?", "0xe", ":", "0x6", ";", "else", "if", "(", "domain", "&&", "lookupAVX512", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "0xe", ";", "return", "std", "::", "make_pair", "(", "domain", ",", "validDomains", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "X86", "X86", "X86II::SSEDomainShift", "3", "0", "0xe", "0xe", "0x6", "0xe" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "X86TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "Type", "*", "MemType", "=", "LI", "->", "getType", "(", ")", ";", "bool", "NoImplicitFloatOps", "=", "LI", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "useSoftFloat", "(", ")", "&&", "!", "NoImplicitFloatOps", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "needsCmpXchgNb", "(", "MemType", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MSP430AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "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>", "const", "MCPhysReg", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_SystemZ_SwiftError_SaveList", ";", "return", "CSR_SystemZ_SaveList", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "WebAssemblyAsmTypeCheck", "::", "getGlobal", "(", "SMLoc", "ErrorLoc", ",", "const", "MCInst", "&", "Inst", ",", "wasm", "::", "ValType", "&", "Type", ")", "{", "const", "MCSymbolRefExpr", "*", "SymRef", ";", "if", "(", "getSymRef", "(", "ErrorLoc", ",", "Inst", ",", "SymRef", ")", ")", "return", "true", ";", "auto", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "&", "SymRef", "->", "getSymbol", "(", ")", ")", ";", "switch", "(", "WasmSym", "->", "getType", "(", ")", ".", "getValueOr", "(", "wasm", "::", "WASM_SYMBOL_TYPE_DATA", ")", ")", "{", "case", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ":", "Type", "=", "static_cast", "<", "wasm", "::", "ValType", ">", "(", "WasmSym", "->", "getGlobalType", "(", ")", ".", "Type", ")", ";", "break", ";", "case", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ":", "case", "wasm", "::", "WASM_SYMBOL_TYPE_DATA", ":", "if", "(", "SymRef", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_GOT", ")", "{", "Type", "=", "is64", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ";", "break", ";", "}", "LLVM_FALLTHROUGH", ";", "default", ":", "return", "typeError", "(", "ErrorLoc", ",", "StringRef", "(", "\"symbol \"", ")", "+", "WasmSym", "->", "getName", "(", ")", "+", "\" missing .globaltype\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Get", "the", "Init", "value", "of", "the", "specified", "global", "variable", "." ]

[ "WebAssembly", "WebAssembly", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_DATA", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WASM_SYMBOL_TYPE_DATA", "wasm::ValType", "wasm::ValType", "\"symbol \"", "\" missing .globaltype\"" ]

[]

[ "<s>", "void", "ARMInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "isThumbFunction", "(", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tSpill", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FSTD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", "&&", "\"Unknown regclass!\"", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FSTS", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegisterClass", "ARM", "ARM", "ARM::tSpill", "0", "ARM::STR", "0", "0", "ARM::DPRRegisterClass", "ARM::FSTD", "0", "ARM::SPRRegisterClass", "\"Unknown regclass!\"", "ARM::FSTS", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps1", ",", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps2", ",", "unsigned", "NumLoads", ",", "unsigned", "NumBytes", ")", "const", "{", "assert", "(", "!", "BaseOps1", ".", "empty", "(", ")", "&&", "!", "BaseOps2", ".", "empty", "(", ")", ")", ";", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOps1", ".", "front", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOps2", ".", "front", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "!", "memOpsHaveSameBasePtr", "(", "FirstLdSt", ",", "BaseOps1", ",", "SecondLdSt", ",", "BaseOps2", ")", ")", "return", "false", ";", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "(", "isMUBUF", "(", "FirstLdSt", ")", "&&", "isMUBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "FirstLdSt", ")", "&&", "isMTBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMIMG", "(", "FirstLdSt", ")", "&&", "isMIMG", "(", "SecondLdSt", ")", ")", "||", "(", "isFLAT", "(", "FirstLdSt", ")", "&&", "isFLAT", "(", "SecondLdSt", ")", ")", ")", "{", "const", "unsigned", "MaxGlobalLoadCluster", "=", "7", ";", "if", "(", "NumLoads", ">", "MaxGlobalLoadCluster", ")", "return", "false", ";", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "if", "(", "!", "FirstDst", ")", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "if", "(", "!", "SecondDst", ")", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "else", "if", "(", "isSMRD", "(", "FirstLdSt", ")", "&&", "isSMRD", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "}", "else", "if", "(", "isDS", "(", "FirstLdSt", ")", "&&", "isDS", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "if", "(", "!", "FirstDst", "||", "!", "SecondDst", ")", "return", "false", ";", "unsigned", "LoadClusterThreshold", "=", "16", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "Register", "Reg", "=", "FirstDst", "->", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "Register", "::", "isVirtualRegister", "(", "Reg", ")", "?", "MRI", ".", "getRegClass", "(", "Reg", ")", ":", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "return", "(", "(", "NumLoads", "-", "1", ")", "*", "(", "RI", ".", "getRegSizeInBits", "(", "*", "DstRC", ")", "/", "8", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AMDGPU", "SI", "7", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16", "1", "8" ]

[]

[ "<s>", "int", "loongarch_idiv_insns", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "int", "count", ";", "count", "=", "1", ";", "if", "(", "TARGET_CHECK_ZERO_DIV", ")", "count", "+=", "2", ";", "return", "count", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "for", "an", "integer", "division", "." ]

[ "loongarch", "1", "2" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "&", "Flags", ")", "const", "{", "assert", "(", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "tracksLiveness", "(", ")", "&&", "\"Suitable Machine Function for outlining must track liveness\"", ")", ";", "LiveRegUnits", "LRU", "(", "getRegisterInfo", "(", ")", ")", ";", "std", "::", "for_each", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ",", "[", "&", "LRU", "]", "(", "MachineInstr", "&", "MI", ")", "{", "LRU", ".", "accumulate", "(", "MI", ")", ";", "}", ")", ";", "bool", "R12AvailableInBlock", "=", "LRU", ".", "available", "(", "ARM", "::", "R12", ")", ";", "bool", "CPSRAvailableInBlock", "=", "LRU", ".", "available", "(", "ARM", "::", "CPSR", ")", ";", "if", "(", "R12AvailableInBlock", "&&", "CPSRAvailableInBlock", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "UnsafeRegsDead", ";", "LRU", ".", "addLiveOuts", "(", "MBB", ")", ";", "if", "(", "R12AvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "ARM", "::", "R12", ")", ")", "return", "false", ";", "if", "(", "CPSRAvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "ARM", "::", "CPSR", ")", ")", "return", "false", ";", "if", "(", "any_of", "(", "MBB", ",", "[", "]", "(", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "isCall", "(", ")", ";", "}", ")", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "HasCalls", ";", "bool", "LRIsAvailable", "=", "MBB", ".", "isReturnBlock", "(", ")", "&&", "!", "MBB", ".", "back", "(", ")", ".", "isCall", "(", ")", "?", "isLRAvailable", "(", "getRegisterInfo", "(", ")", ",", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ")", ":", "LRU", ".", "available", "(", "ARM", "::", "LR", ")", ";", "if", "(", "!", "LRIsAvailable", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "LRUnavailableSomewhere", ";", "return", "true", ";", "}", "</s>" ]

[ "Optional", "target", "hook", "that", "returns", "true", "if", "MBB", "is", "safe", "to", "outline", "from", ",", "and", "returns", "any", "target-specific", "information", "in", "Flags", "." ]

[ "ARM", "ARM", "\"Suitable Machine Function for outlining must track liveness\"", "ARM::R12", "ARM::CPSR", "ARM::R12", "ARM::CPSR", "ARM::LR" ]

[]

[ "<s>", "unsigned", "int", "ix86_local_alignment", "(", "tree", "exp", ",", "machine_mode", "mode", ",", "unsigned", "int", "align", ")", "{", "tree", "type", ",", "decl", ";", "if", "(", "exp", "&&", "DECL_P", "(", "exp", ")", ")", "{", "type", "=", "TREE_TYPE", "(", "exp", ")", ";", "decl", "=", "exp", ";", "}", "else", "{", "type", "=", "exp", ";", "decl", "=", "NULL", ";", "}", "if", "(", "!", "TARGET_64BIT", "&&", "align", "==", "64", "&&", "ix86_preferred_stack_boundary", "<", "64", "&&", "(", "mode", "==", "DImode", "||", "(", "type", "&&", "TYPE_MODE", "(", "type", ")", "==", "DImode", ")", ")", "&&", "(", "!", "type", "||", "!", "TYPE_USER_ALIGN", "(", "type", ")", ")", "&&", "(", "!", "decl", "||", "!", "DECL_USER_ALIGN", "(", "decl", ")", ")", ")", "align", "=", "32", ";", "if", "(", "!", "type", ")", "{", "if", "(", "mode", "==", "XFmode", "&&", "align", "<", "GET_MODE_ALIGNMENT", "(", "DFmode", ")", ")", "align", "=", "GET_MODE_ALIGNMENT", "(", "DFmode", ")", ";", "return", "align", ";", "}", "if", "(", "TARGET_IAMCU", ")", "return", "align", ";", "if", "(", "TARGET_64BIT", "&&", "optimize_function_for_speed_p", "(", "cfun", ")", "&&", "TARGET_SSE", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "va_list_type_node", "==", "NULL_TREE", "||", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", "!=", "TYPE_MAIN_VARIANT", "(", "va_list_type_node", ")", ")", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "16", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DCmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "(", "TYPE_MODE", "(", "type", ")", "==", "XCmode", "||", "TYPE_MODE", "(", "type", ")", "==", "TCmode", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "QUAL_UNION_TYPE", ")", "&&", "TYPE_FIELDS", "(", "type", ")", ")", "{", "if", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "type", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "return", "align", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "for", "a", "local", "variable", ".", "TYPE", "is", "the", "data", "type", ",", "and", "ALIGN", "is", "the", "alignment", "that", "the", "object", "would", "ordinarily", "have", ".", "The", "value", "of", "this", "macro", "is", "used", "instead", "of", "that", "alignment", "to", "align", "the", "object", "." ]

[ "i386", "64", "64", "32", "16", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128" ]

[]

[ "<s>", "static", "rtx", "aarch64_progress_pointer", "(", "rtx", "pointer", ")", "{", "HOST_WIDE_INT", "amount", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "pointer", ")", ")", ";", "return", "aarch64_move_pointer", "(", "pointer", ",", "amount", ")", ";", "}", "</s>" ]

[ "Return", "a", "new", "RTX", "holding", "the", "result", "of", "moving", "POINTER", "forward", "by", "the", "size", "of", "the", "mode", "it", "points", "to", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "rl78_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "m", ";", "m", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "m", "->", "virt_insns_ok", "=", "1", ";", "return", "m", ";", "}", "</s>" ]

[ "This", "is", "our", "init_machine_status", ",", "as", "set", "in", "rl78_option_override", "." ]

[ "rl78", "1" ]

[]

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

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

[ "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "void", "vax_expand_prologue", "(", "void", ")", "{", "int", "regno", ",", "offset", ";", "int", "mask", "=", "0", ";", "HOST_WIDE_INT", "size", ";", "rtx", "insn", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "mask", "|=", "1", "<<", "regno", ";", "insn", "=", "emit_insn", "(", "gen_procedure_entry_mask", "(", "GEN_INT", "(", "mask", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "vax_add_reg_cfa_offset", "(", "insn", ",", "4", ",", "arg_pointer_rtx", ")", ";", "vax_add_reg_cfa_offset", "(", "insn", ",", "8", ",", "frame_pointer_rtx", ")", ";", "vax_add_reg_cfa_offset", "(", "insn", ",", "12", ",", "pc_rtx", ")", ";", "offset", "=", "16", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "regno", ")", ")", "{", "vax_add_reg_cfa_offset", "(", "insn", ",", "offset", ",", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ")", ";", "offset", "+=", "4", ";", "}", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "offset", ")", ")", ";", "size", "=", "get_frame_size", "(", ")", ";", "size", "-=", "STARTING_FRAME_OFFSET", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Generate", "the", "assembly", "code", "for", "function", "entry", ".", "FILE", "is", "a", "stdio", "stream", "to", "output", "the", "code", "to", ".", "SIZE", "is", "an", "int", ":", "how", "many", "units", "of", "temporary", "storage", "to", "allocate", ".", "Refer", "to", "the", "array", "`", "regs_ever_live", "'", "to", "determine", "which", "registers", "to", "save", ";", "`", "regs_ever_live", "[", "I", "]", "'", "is", "nonzero", "if", "register", "number", "I", "is", "ever", "used", "in", "the", "function", ".", "This", "function", "is", "responsible", "for", "knowing", "which", "registers", "should", "not", "be", "saved", "even", "if", "used", "." ]

[ "vax", "0", "0", "1", "1", "4", "8", "12", "16", "0", "1", "4" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "JVM" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitStoreConditional", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "isReleaseOrStronger", "(", "Ord", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlexd", ":", "Intrinsic", "::", "arm_strexd", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int32Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "32", ")", ",", "Int32Ty", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Strex", ",", "{", "Lo", ",", "Hi", ",", "Addr", "}", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlex", ":", "Intrinsic", "::", "arm_strex", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Strex", ",", "{", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Strex", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", "}", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_stlexd", "Intrinsic::arm_strexd", "Intrinsic::getDeclaration", "\"lo\"", "32", "\"hi\"", "Intrinsic::ID", "Intrinsic::arm_stlex", "Intrinsic::arm_strex", "Intrinsic::getDeclaration", "0" ]

[]

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

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

[ "J2", "\"RelaxInstruction() unimplemented\"" ]

[]

[ "<s>", "const", "Cpu0AnalyzeImmediate", "::", "InstSeq", "&", "Cpu0AnalyzeImmediate", "::", "Analyze", "(", "uint64_t", "Imm", ",", "unsigned", "Size", ",", "bool", "LastInstrIsADDiu", ")", "{", "this", "->", "Size", "=", "Size", ";", "ADDiu", "=", "Cpu0", "::", "ADDiu", ";", "ORi", "=", "Cpu0", "::", "ORi", ";", "SHL", "=", "Cpu0", "::", "SHL", ";", "LUi", "=", "Cpu0", "::", "LUi", ";", "InstSeqLs", "SeqLs", ";", "if", "(", "LastInstrIsADDiu", "|", "!", "Imm", ")", "GetInstSeqLsADDiu", "(", "Imm", ",", "Size", ",", "SeqLs", ")", ";", "else", "GetInstSeqLs", "(", "Imm", ",", "Size", ",", "SeqLs", ")", ";", "GetShortestSeq", "(", "SeqLs", ",", "Insts", ")", ";", "return", "Insts", ";", "}", "</s>" ]

[ "Analyze", "-", "Get", "an", "instruction", "sequence", "to", "load", "immediate", "Imm", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0::ADDiu", "Cpu0::ORi", "Cpu0::SHL", "Cpu0::LUi" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "if", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "{", "auto", "*", "Assembler", "=", "getTargetStreamer", "(", ")", ".", "getStreamer", "(", ")", ".", "getAssemblerPtr", "(", ")", ";", "if", "(", "Assembler", "!=", "nullptr", ")", "{", "RISCVAsmBackend", "&", "MAB", "=", "static_cast", "<", "RISCVAsmBackend", "&", ">", "(", "Assembler", "->", "getBackend", "(", ")", ")", ";", "MAB", ".", "setForceRelocs", "(", ")", ";", "}", "}", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "unsigned", "OperandIdx", "=", "1", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "++", "OperandIdx", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::FeatureRelax", "RISCV", "RISCV", "RISCV", "1", "\"unexpected token\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Remove sign extends\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Remove sign extends\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getPartialRegUpdateClearance", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "PartialUpdateClearance", "=", "Subtarget", ".", "getPartialUpdateClearance", "(", ")", ";", "if", "(", "!", "PartialUpdateClearance", ")", "return", "0", ";", "assert", "(", "TRI", "&&", "\"Need TRI instance\"", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "readsReg", "(", ")", ")", "return", "0", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "int", "UseOp", "=", "-", "1", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "FCONSTS", ":", "case", "ARM", "::", "VMOVSR", ":", "case", "ARM", "::", "VMOVv8i8", ":", "case", "ARM", "::", "VMOVv4i16", ":", "case", "ARM", "::", "VMOVv2i32", ":", "case", "ARM", "::", "VMOVv2f32", ":", "case", "ARM", "::", "VMOVv1i64", ":", "UseOp", "=", "MI", ".", "findRegisterUseOperandIdx", "(", "Reg", ",", "false", ",", "TRI", ")", ";", "break", ";", "case", "ARM", "::", "VLD1LNd32", ":", "UseOp", "=", "3", ";", "break", ";", "default", ":", "return", "0", ";", "}", "if", "(", "UseOp", "!=", "-", "1", "&&", "MI", ".", "getOperand", "(", "UseOp", ")", ".", "readsReg", "(", ")", ")", "return", "0", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "Reg", ")", ")", "{", "if", "(", "!", "MO", ".", "getSubReg", "(", ")", "||", "MI", ".", "readsVirtualRegister", "(", "Reg", ")", ")", "return", "0", ";", "}", "else", "if", "(", "ARM", "::", "SPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "DReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "Reg", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DReg", "||", "!", "MI", ".", "definesRegister", "(", "DReg", ",", "TRI", ")", ")", "return", "0", ";", "}", "return", "PartialUpdateClearance", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "a", "partial", "register", "update", "." ]

[ "ARM", "ARM", "0", "\"Need TRI instance\"", "0", "1", "ARM::VLDRS", "ARM::FCONSTS", "ARM::VMOVSR", "ARM::VMOVv8i8", "ARM::VMOVv4i16", "ARM::VMOVv2i32", "ARM::VMOVv2f32", "ARM::VMOVv1i64", "ARM::VLD1LNd32", "3", "0", "1", "0", "0", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0" ]

[]

[ "<s>", "const", "char", "*", "JVMTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled target opcode.\\n\"", ")", ";", "break", ";", "case", "JVMISD", "::", "ALLOC", ":", "return", "\"JVMISD::ALLOC\"", ";", "case", "JVMISD", "::", "ADD", ":", "return", "\"JVMISD::ADD\"", ";", "case", "JVMISD", "::", "AND", ":", "return", "\"JVMISD::AND\"", ";", "case", "JVMISD", "::", "DIV", ":", "return", "\"JVMISD::DIV\"", ";", "case", "JVMISD", "::", "EXTEND", ":", "return", "\"JVMISD::EXTEND\"", ";", "case", "JVMISD", "::", "ARGUMENT", ":", "return", "\"JVMISD::ARGUMENT\"", ";", "case", "JVMISD", "::", "LOAD", ":", "return", "\"JVMISD::LOAD\"", ";", "case", "JVMISD", "::", "LOAD_W_CHAIN", ":", "return", "\"JVMISD::LOAD_W_CHAIN\"", ";", "case", "JVMISD", "::", "MUL", ":", "return", "\"JVMISD::MUL\"", ";", "case", "JVMISD", "::", "SHL", ":", "return", "\"JVMISD::SHL\"", ";", "case", "JVMISD", "::", "SRL", ":", "return", "\"JVMISD::SRL\"", ";", "case", "JVMISD", "::", "SRA", ":", "return", "\"JVMISD::SRA\"", ";", "case", "JVMISD", "::", "STORENR", ":", "return", "\"JVMISD::STORENR\"", ";", "case", "JVMISD", "::", "STORE", ":", "return", "\"JVMISD::STORE\"", ";", "case", "JVMISD", "::", "TRUNC", ":", "return", "\"JVMISD::TRUNC\"", ";", "case", "JVMISD", "::", "FIELD_ACC_R", ":", "return", "\"JVMISD::FIELD_ACC_R\"", ";", "case", "JVMISD", "::", "FIELD_ACC_W", ":", "return", "\"JVMISD::FIELD_ACC_W\"", ";", "case", "JVMISD", "::", "INDEX_ACC", ":", "return", "\"JVMISD::INDEX_ACC\"", ";", "case", "JVMISD", "::", "INVOKENV", ":", "return", "\"JVMISD::INVOKENV\"", ";", "case", "JVMISD", "::", "OR", ":", "return", "\"JVMISD::OR\"", ";", "case", "JVMISD", "::", "SUB", ":", "return", "\"JVMISD::SUB\"", ";", "case", "JVMISD", "::", "CMP", ":", "return", "\"JVMISD::CMP\"", ";", "case", "JVMISD", "::", "CALL", ":", "return", "\"JVMISD::CALL\"", ";", "case", "JVMISD", "::", "REM", ":", "return", "\"JVMISD::REM\"", ";", "case", "JVMISD", "::", "RET", ":", "return", "\"JVMISD::RET\"", ";", "case", "JVMISD", "::", "DUP", ":", "return", "\"JVMISD::DUP\"", ";", "case", "JVMISD", "::", "BR_CC", ":", "return", "\"JVMISD::BR_CC\"", ";", "case", "JVMISD", "::", "BR_CONST_CC", ":", "return", "\"JVMISD::BR_CONST_CC\"", ";", "case", "JVMISD", "::", "XOR", ":", "return", "\"JVMISD::XOR\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "JVM", "JVM", "\"Unhandled target opcode.\\n\"", "JVMISD::ALLOC", "\"JVMISD::ALLOC\"", "JVMISD::ADD", "\"JVMISD::ADD\"", "JVMISD::AND", "\"JVMISD::AND\"", "JVMISD::DIV", "\"JVMISD::DIV\"", "JVMISD::EXTEND", "\"JVMISD::EXTEND\"", "JVMISD::ARGUMENT", "\"JVMISD::ARGUMENT\"", "JVMISD::LOAD", "\"JVMISD::LOAD\"", "JVMISD::LOAD_W_CHAIN", "\"JVMISD::LOAD_W_CHAIN\"", "JVMISD::MUL", "\"JVMISD::MUL\"", "JVMISD::SHL", "\"JVMISD::SHL\"", "JVMISD::SRL", "\"JVMISD::SRL\"", "JVMISD::SRA", "\"JVMISD::SRA\"", "JVMISD::STORENR", "\"JVMISD::STORENR\"", "JVMISD::STORE", "\"JVMISD::STORE\"", "JVMISD::TRUNC", "\"JVMISD::TRUNC\"", "JVMISD::FIELD_ACC_R", "\"JVMISD::FIELD_ACC_R\"", "JVMISD::FIELD_ACC_W", "\"JVMISD::FIELD_ACC_W\"", "JVMISD::INDEX_ACC", "\"JVMISD::INDEX_ACC\"", "JVMISD::INVOKENV", "\"JVMISD::INVOKENV\"", "JVMISD::OR", "\"JVMISD::OR\"", "JVMISD::SUB", "\"JVMISD::SUB\"", "JVMISD::CMP", "\"JVMISD::CMP\"", "JVMISD::CALL", "\"JVMISD::CALL\"", "JVMISD::REM", "\"JVMISD::REM\"", "JVMISD::RET", "\"JVMISD::RET\"", "JVMISD::DUP", "\"JVMISD::DUP\"", "JVMISD::BR_CC", "\"JVMISD::BR_CC\"", "JVMISD::BR_CONST_CC", "\"JVMISD::BR_CONST_CC\"", "JVMISD::XOR", "\"JVMISD::XOR\"" ]

[]

[ "<s>", "unsigned", "Mips16InstrInfo", "::", "getOppositeBranchOpc", "(", "unsigned", "Opc", ")", "const", "{", "switch", "(", "Opc", ")", "{", "case", "Mips", "::", "BeqzRxImmX16", ":", "return", "Mips", "::", "BnezRxImmX16", ";", "case", "Mips", "::", "BnezRxImmX16", ":", "return", "Mips", "::", "BeqzRxImmX16", ";", "case", "Mips", "::", "BeqzRxImm16", ":", "return", "Mips", "::", "BnezRxImm16", ";", "case", "Mips", "::", "BnezRxImm16", ":", "return", "Mips", "::", "BeqzRxImm16", ";", "case", "Mips", "::", "BteqzT8CmpX16", ":", "return", "Mips", "::", "BtnezT8CmpX16", ";", "case", "Mips", "::", "BteqzT8SltX16", ":", "return", "Mips", "::", "BtnezT8SltX16", ";", "case", "Mips", "::", "BteqzT8SltiX16", ":", "return", "Mips", "::", "BtnezT8SltiX16", ";", "case", "Mips", "::", "Btnez16", ":", "return", "Mips", "::", "Bteqz16", ";", "case", "Mips", "::", "BtnezX16", ":", "return", "Mips", "::", "BteqzX16", ";", "case", "Mips", "::", "BtnezT8CmpiX16", ":", "return", "Mips", "::", "BteqzT8CmpiX16", ";", "case", "Mips", "::", "BtnezT8SltuX16", ":", "return", "Mips", "::", "BteqzT8SltuX16", ";", "case", "Mips", "::", "BtnezT8SltiuX16", ":", "return", "Mips", "::", "BteqzT8SltiuX16", ";", "case", "Mips", "::", "Bteqz16", ":", "return", "Mips", "::", "Btnez16", ";", "case", "Mips", "::", "BteqzX16", ":", "return", "Mips", "::", "BtnezX16", ";", "case", "Mips", "::", "BteqzT8CmpiX16", ":", "return", "Mips", "::", "BtnezT8CmpiX16", ";", "case", "Mips", "::", "BteqzT8SltuX16", ":", "return", "Mips", "::", "BtnezT8SltuX16", ";", "case", "Mips", "::", "BteqzT8SltiuX16", ":", "return", "Mips", "::", "BtnezT8SltiuX16", ";", "case", "Mips", "::", "BtnezT8CmpX16", ":", "return", "Mips", "::", "BteqzT8CmpX16", ";", "case", "Mips", "::", "BtnezT8SltX16", ":", "return", "Mips", "::", "BteqzT8SltX16", ";", "case", "Mips", "::", "BtnezT8SltiX16", ":", "return", "Mips", "::", "BteqzT8SltiX16", ";", "}", "llvm_unreachable", "(", "\"Illegal opcode!\"", ")", ";", "}", "</s>" ]

[ "getOppositeBranchOpc", "-", "Return", "the", "inverse", "of", "the", "specified", "opcode", ",", "e.g", "." ]

[ "Mips", "Mips", "Mips::BeqzRxImmX16", "Mips::BnezRxImmX16", "Mips::BnezRxImmX16", "Mips::BeqzRxImmX16", "Mips::BeqzRxImm16", "Mips::BnezRxImm16", "Mips::BnezRxImm16", "Mips::BeqzRxImm16", "Mips::BteqzT8CmpX16", "Mips::BtnezT8CmpX16", "Mips::BteqzT8SltX16", "Mips::BtnezT8SltX16", "Mips::BteqzT8SltiX16", "Mips::BtnezT8SltiX16", "Mips::Btnez16", "Mips::Bteqz16", "Mips::BtnezX16", "Mips::BteqzX16", "Mips::BtnezT8CmpiX16", "Mips::BteqzT8CmpiX16", "Mips::BtnezT8SltuX16", "Mips::BteqzT8SltuX16", "Mips::BtnezT8SltiuX16", "Mips::BteqzT8SltiuX16", "Mips::Bteqz16", "Mips::Btnez16", "Mips::BteqzX16", "Mips::BtnezX16", "Mips::BteqzT8CmpiX16", "Mips::BtnezT8CmpiX16", "Mips::BteqzT8SltuX16", "Mips::BtnezT8SltuX16", "Mips::BteqzT8SltiuX16", "Mips::BtnezT8SltiuX16", "Mips::BtnezT8CmpX16", "Mips::BteqzT8CmpX16", "Mips::BtnezT8SltX16", "Mips::BteqzT8SltX16", "Mips::BtnezT8SltiX16", "Mips::BteqzT8SltiX16", "\"Illegal opcode!\"" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "(", "Count", "%", "4", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "4", ")", "OW", "->", "Write32", "(", "0x00000000", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TeeRISC", "4", "0", "0", "4", "0x00000000" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_xchg_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_add_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_sub_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_nand_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_max_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_min_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_umax_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_umin_i32", ":", "case", "Intrinsic", "::", "riscv_masked_cmpxchg_i32", ":", "PointerType", "*", "PtrTy", "=", "cast", "<", "PointerType", ">", "(", "I", ".", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "PtrTy", "->", "getElementType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "Align", "(", "4", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "RI5CY", "RISCV", "Intrinsic::riscv_masked_atomicrmw_xchg_i32", "Intrinsic::riscv_masked_atomicrmw_add_i32", "Intrinsic::riscv_masked_atomicrmw_sub_i32", "Intrinsic::riscv_masked_atomicrmw_nand_i32", "Intrinsic::riscv_masked_atomicrmw_max_i32", "Intrinsic::riscv_masked_atomicrmw_min_i32", "Intrinsic::riscv_masked_atomicrmw_umax_i32", "Intrinsic::riscv_masked_atomicrmw_umin_i32", "Intrinsic::riscv_masked_cmpxchg_i32", "0", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "joinRegisterPartsIntoValue", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "const", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "EVT", "ValueVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "bool", "IsABIRegCopy", "=", "CC", ".", "hasValue", "(", ")", ";", "if", "(", "IsABIRegCopy", "&&", "ValueVT", "==", "MVT", "::", "f16", "&&", "PartVT", "==", "MVT", "::", "f32", ")", "{", "SDValue", "Val", "=", "Parts", "[", "0", "]", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i16", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "f16", ",", "Val", ")", ";", "return", "Val", ";", "}", "if", "(", "ValueVT", ".", "isScalableVector", "(", ")", "&&", "PartVT", ".", "isScalableVector", "(", ")", ")", "{", "LLVMContext", "&", "Context", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "SDValue", "Val", "=", "Parts", "[", "0", "]", ";", "EVT", "ValueEltVT", "=", "ValueVT", ".", "getVectorElementType", "(", ")", ";", "EVT", "PartEltVT", "=", "PartVT", ".", "getVectorElementType", "(", ")", ";", "unsigned", "ValueVTBitSize", "=", "ValueVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "unsigned", "PartVTBitSize", "=", "PartVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "if", "(", "PartVTBitSize", "%", "ValueVTBitSize", "==", "0", ")", "{", "EVT", "SameEltTypeVT", "=", "ValueVT", ";", "if", "(", "ValueEltVT", "!=", "PartEltVT", ")", "{", "unsigned", "Count", "=", "ValueVTBitSize", "/", "PartEltVT", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "Count", "!=", "0", "&&", "\"The number of element should not be zero.\"", ")", ";", "SameEltTypeVT", "=", "EVT", "::", "getVectorVT", "(", "Context", ",", "PartEltVT", ",", "Count", ",", "true", ")", ";", "}", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "SameEltTypeVT", ",", "Val", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "Subtarget", ".", "getXLenVT", "(", ")", ")", ")", ";", "if", "(", "ValueEltVT", "!=", "PartEltVT", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "ValueVT", ",", "Val", ")", ";", "return", "Val", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Target-specific", "combining", "of", "register", "parts", "into", "its", "original", "value", "." ]

[ "RISCV", "RISCV", "MVT::f16", "MVT::f32", "0", "ISD::BITCAST", "MVT::i32", "ISD::TRUNCATE", "MVT::i16", "ISD::BITCAST", "MVT::f16", "0", "0", "0", "\"The number of element should not be zero.\"", "ISD::EXTRACT_SUBVECTOR", "0", "ISD::BITCAST" ]

[]

[ "<s>", "J2ConstantPoolValue", "*", "J2ConstantPoolValue", "::", "Create", "(", "const", "Constant", "*", "Value", ")", "{", "return", "new", "J2ConstantPoolValue", "(", "Value", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "J2", "J2", "J2", "J2" ]

[]

[ "<s>", "MVT", "M68kTargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", "DL", ",", "EVT", "Ty", ")", "const", "{", "if", "(", "Ty", ".", "isSimple", "(", ")", ")", "{", "return", "Ty", ".", "getSimpleVT", "(", ")", ";", "}", "return", "MVT", "::", "getIntegerVT", "(", "8", "*", "DL", ".", "getPointerSize", "(", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "M68k", "M68k", "MVT::getIntegerVT", "8", "0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"TriCore DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "TriCore", "\"TriCore DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "MipsRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "if", "(", "Subtarget", ".", "isSingleFloat", "(", ")", ")", "return", "CSR_SingleFloatOnly_RegMask", ";", "if", "(", "Subtarget", ".", "isABI_N64", "(", ")", ")", "return", "CSR_N64_RegMask", ";", "if", "(", "Subtarget", ".", "isABI_N32", "(", ")", ")", "return", "CSR_N32_RegMask", ";", "if", "(", "Subtarget", ".", "isFP64bit", "(", ")", ")", "return", "CSR_O32_FP64_RegMask", ";", "return", "CSR_O32_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "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", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "HexagonISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::OutputArg", "16", "Hexagon", "4", "1", "0", "1", "0", "HexagonISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "SMLoc", "getLoc", "(", ")", "const", "{", "return", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "source", "location", "of", "the", "point", "where", "the", "field", "was", "defined", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSMSVCRT", "(", ")", ")", "{", "M", ".", "getOrInsertGlobal", "(", "\"__security_cookie\"", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "auto", "*", "SecurityCheckCookie", "=", "cast", "<", "Function", ">", "(", "M", ".", "getOrInsertFunction", "(", "\"__security_check_cookie\"", ",", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ")", ";", "SecurityCheckCookie", "->", "setCallingConv", "(", "CallingConv", "::", "X86_FastCall", ")", ";", "SecurityCheckCookie", "->", "addAttribute", "(", "1", ",", "Attribute", "::", "AttrKind", "::", "InReg", ")", ";", "return", ";", "}", "if", "(", "hasStackGuardSlotTLS", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ")", ")", "return", ";", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "X86", "X86", "\"__security_cookie\"", "\"__security_check_cookie\"", "X86", "1" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Outs", ")", ";", "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", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "MSP430MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "Register", "Reg", "=", "FuncInfo", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "unsigned", "R12", "=", "MSP430", "::", "R12", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R12", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "R12", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "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", "." ]

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430", "\"sret virtual register not created in entry block\"", "MSP430::R12", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "const", "char", "*", "OR1KTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "OR1KISD", "::", "NodeType", ")", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "OR1KISD", "::", "ADJDYNALLOC", ":", "return", "\"OR1KISD::ADJDYNALLOC\"", ";", "case", "OR1KISD", "::", "RET_FLAG", ":", "return", "\"OR1KISD::RET_FLAG\"", ";", "case", "OR1KISD", "::", "CALL", ":", "return", "\"OR1KISD::CALL\"", ";", "case", "OR1KISD", "::", "SELECT_CC", ":", "return", "\"OR1KISD::SELECT_CC\"", ";", "case", "OR1KISD", "::", "SET_FLAG", ":", "return", "\"OR1KISD::SET_FLAG\"", ";", "case", "OR1KISD", "::", "BR_CC", ":", "return", "\"OR1KISD::BR_CC\"", ";", "case", "OR1KISD", "::", "Wrapper", ":", "return", "\"OR1KISD::Wrapper\"", ";", "case", "OR1KISD", "::", "FF1", ":", "return", "\"OR1KISD::FF1\"", ";", "case", "OR1KISD", "::", "FL1", ":", "return", "\"OR1KISD::FL1\"", ";", "case", "OR1KISD", "::", "HI", ":", "return", "\"OR1KISD::HI\"", ";", "case", "OR1KISD", "::", "LO", ":", "return", "\"OR1KISD::LO\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "OR1K", "OR1K", "OR1KISD::NodeType", "OR1KISD::ADJDYNALLOC", "\"OR1KISD::ADJDYNALLOC\"", "OR1KISD::RET_FLAG", "\"OR1KISD::RET_FLAG\"", "OR1KISD::CALL", "\"OR1KISD::CALL\"", "OR1KISD::SELECT_CC", "\"OR1KISD::SELECT_CC\"", "OR1KISD::SET_FLAG", "\"OR1KISD::SET_FLAG\"", "OR1KISD::BR_CC", "\"OR1KISD::BR_CC\"", "OR1KISD::Wrapper", "\"OR1KISD::Wrapper\"", "OR1KISD::FF1", "\"OR1KISD::FF1\"", "OR1KISD::FL1", "\"OR1KISD::FL1\"", "OR1KISD::HI", "\"OR1KISD::HI\"", "OR1KISD::LO", "\"OR1KISD::LO\"" ]

[]