Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "isLittleEndian", "(", ")", "const", "{", "return", "IsLittle", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "triple", "is", "little", "endian", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "setExecutionDomain", "(", "MachineInstr", "&", "MI", ",", "unsigned", "Domain", ")", "const", "{", "assert", "(", "Domain", ">", "0", "&&", "Domain", "<", "4", "&&", "\"Invalid execution domain\"", ")", ";", "uint16_t", "dom", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "assert", "(", "dom", "&&", "\"Not an SSE instruction\"", ")", ";", "const", "uint16_t", "*", "table", "=", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ")", ";", "if", "(", "!", "table", ")", "{", "assert", "(", "(", "Subtarget", ".", "hasAVX2", "(", ")", "||", "Domain", "<", "3", ")", "&&", "\"256-bit vector operations only available in AVX2\"", ")", ";", "table", "=", "lookupAVX2", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ")", ";", "}", "assert", "(", "table", "&&", "\"Cannot change domain\"", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "table", "[", "Domain", "-", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Change", "the", "opcode", "of", "MI", "to", "execute", "in", "Domain", "." ]

[ "X86", "X86", "0", "4", "\"Invalid execution domain\"", "X86II::SSEDomainShift", "3", "\"Not an SSE instruction\"", "3", "\"256-bit vector operations only available in AVX2\"", "\"Cannot change domain\"", "1" ]

[]

[ "<s>", "void", "SystemZTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Constraint", ".", "length", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'I'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isUInt", "<", "8", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'J'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isUInt", "<", "12", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'K'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'L'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isInt", "<", "20", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'M'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0x7fffffff", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "}", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1", "0", "8", "12", "16", "20", "0x7fffffff" ]

[]

[ "<s>", "int", "compute_plussi_cc", "(", "rtx", "*", "operands", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "if", "(", "TARGET_H8300", ")", "{", "return", "CC_CLOBBER", ";", "}", "else", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "register_operand", "(", "operands", "[", "1", "]", ",", "VOIDmode", ")", ")", "{", "HOST_WIDE_INT", "intval", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "1", "&&", "intval", "<=", "7", ")", ")", "return", "CC_SET_ZN", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "-", "7", "&&", "intval", "<=", "-", "1", ")", ")", "return", "CC_SET_ZN", ";", "switch", "(", "(", "unsigned", "int", ")", "intval", "&", "0xffffffff", ")", "{", "case", "0x00000001", ":", "case", "0x00000002", ":", "case", "0x00000004", ":", "return", "CC_NONE_0HIT", ";", "case", "0xffffffff", ":", "case", "0xfffffffe", ":", "case", "0xfffffffc", ":", "return", "CC_NONE_0HIT", ";", "case", "0x00010000", ":", "case", "0x00020000", ":", "return", "CC_CLOBBER", ";", "case", "0xffff0000", ":", "case", "0xfffe0000", ":", "return", "CC_CLOBBER", ";", "}", "if", "(", "(", "intval", "&", "0xffff", ")", "==", "0", ")", "return", "CC_CLOBBER", ";", "}", "return", "CC_SET_ZN", ";", "}", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "an", "addition", "insn", "." ]

[ "h8300", "0", "2", "1", "2", "1", "7", "7", "1", "0xffffffff", "0x00000001", "0x00000002", "0x00000004", "0xffffffff", "0xfffffffe", "0xfffffffc", "0x00010000", "0x00020000", "0xffff0000", "0xfffe0000", "0xffff", "0" ]

[]

[ "<s>", "static", "bool", "insn_references_regno_p", "(", "rtx_insn", "*", "insn", ",", "unsigned", "int", "regno", ",", "enum", "attr_type", "type", ")", "{", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "ref", ";", "for", "(", "ref", "=", "DF_INSN_INFO_DEFS", "(", "insn_info", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "DF_REF_REGNO", "(", "ref", ")", "==", "regno", ")", "return", "true", ";", "if", "(", "type", "==", "TYPE_LOAD", "||", "type", "==", "TYPE_FPLOAD", "||", "type", "==", "TYPE_VECLOAD", ")", "for", "(", "ref", "=", "DF_INSN_INFO_USES", "(", "insn_info", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "DF_REF_REGNO", "(", "ref", ")", "==", "regno", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "INSN", "contains", "a", "reference", "to", "REGNO", "that", "will", "inhibit", "the", "PCREL_OPT", "optimization", ".", "If", "TYPE", "is", "a", "load", "or", "store", "instruction", ",", "return", "true", "if", "there", "is", "a", "definition", "of", "REGNO", ".", "If", "TYPE", "is", "a", "load", "instruction", ",", "then", "return", "true", "of", "there", "is", "a", "use", "of", "REGNO", "." ]

[ "rs6000" ]

[]

[ "<s>", "int", "SystemZHazardRecognizer", "::", "groupingCost", "(", "SUnit", "*", "SU", ")", "const", "{", "const", "MCSchedClassDesc", "*", "SC", "=", "getSchedClass", "(", "SU", ")", ";", "if", "(", "!", "SC", "->", "isValid", "(", ")", ")", "return", "0", ";", "if", "(", "SC", "->", "BeginGroup", ")", "{", "if", "(", "CurrGroupSize", ")", "return", "3", "-", "CurrGroupSize", ";", "return", "-", "1", ";", "}", "if", "(", "SC", "->", "EndGroup", ")", "{", "unsigned", "resultingGroupSize", "=", "(", "CurrGroupSize", "+", "getNumDecoderSlots", "(", "SU", ")", ")", ";", "if", "(", "resultingGroupSize", "<", "3", ")", "return", "(", "3", "-", "resultingGroupSize", ")", ";", "return", "-", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "decoder", "grouping", "for", "SU", "." ]

[ "SystemZ", "SystemZ", "0", "3", "1", "3", "3", "1", "0" ]

[]

[ "<s>", "static", "void", "mips_multi_add_insn", "(", "const", "char", "*", "format", ",", "...", ")", "{", "struct", "mips_multi_member", "*", "member", ";", "va_list", "ap", ";", "unsigned", "int", "i", ";", "rtx", "op", ";", "member", "=", "mips_multi_add", "(", ")", ";", "member", "->", "is_label_p", "=", "false", ";", "member", "->", "format", "=", "format", ";", "va_start", "(", "ap", ",", "format", ")", ";", "i", "=", "0", ";", "while", "(", "(", "op", "=", "va_arg", "(", "ap", ",", "rtx", ")", ")", ")", "member", "->", "operands", "[", "i", "++", "]", "=", "op", ";", "va_end", "(", "ap", ")", ";", "mips_multi_num_insns", "++", ";", "}", "</s>" ]

[ "Add", "a", "normal", "insn", "with", "the", "given", "asm", "format", "to", "the", "current", "multi-insn", "sequence", ".", "The", "other", "arguments", "are", "a", "null-terminated", "list", "of", "operands", "." ]

[ "mips", "0" ]

[]

[ "<s>", "StringRef", "XtensaAsmPrinter", "::", "getPassName", "(", ")", "const", "{", "return", "\"Xtensa Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"Xtensa Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "RISCVAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "RISCVOperand", "&", "Op", "=", "static_cast", "<", "RISCVOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "MCRegister", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "bool", "IsRegFPR64", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR64RegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "bool", "IsRegFPR64C", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR64CRegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "bool", "IsRegVR", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "VRRegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "if", "(", "(", "IsRegFPR64", "&&", "Kind", "==", "MCK_FPR32", ")", "||", "(", "IsRegFPR64C", "&&", "Kind", "==", "MCK_FPR32C", ")", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR64ToFPR32", "(", "Reg", ")", ";", "return", "Match_Success", ";", "}", "if", "(", "IsRegFPR64", "&&", "Kind", "==", "MCK_FPR16", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR64ToFPR16", "(", "Reg", ")", ";", "return", "Match_Success", ";", "}", "if", "(", "IsRegVR", "&&", "(", "Kind", "==", "MCK_VRM2", "||", "Kind", "==", "MCK_VRM4", "||", "Kind", "==", "MCK_VRM8", ")", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertVRToVRMx", "(", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "Reg", ",", "Kind", ")", ";", "if", "(", "Op", ".", "Reg", ".", "RegNum", "==", "0", ")", "return", "Match_InvalidOperand", ";", "return", "Match_Success", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::FPR64RegClassID", "RISCV", "RISCV::FPR64CRegClassID", "RISCV", "RISCV::VRRegClassID", "0" ]

[]

[ "<s>", "bool", "DeadCodeElimination", "::", "erase", "(", "const", "SetVector", "<", "NodeId", ">", "&", "Nodes", ")", "{", "if", "(", "Nodes", ".", "empty", "(", ")", ")", "return", "false", ";", "NodeList", "DRNs", ",", "DINs", ";", "for", "(", "auto", "I", ":", "Nodes", ")", "{", "auto", "BA", "=", "DFG", ".", "addr", "<", "NodeBase", "*", ">", "(", "I", ")", ";", "uint16_t", "Type", "=", "BA", ".", "Addr", "->", "getType", "(", ")", ";", "if", "(", "Type", "==", "NodeAttrs", "::", "Ref", ")", "{", "DRNs", ".", "push_back", "(", "DFG", ".", "addr", "<", "RefNode", "*", ">", "(", "I", ")", ")", ";", "continue", ";", "}", "uint16_t", "Kind", "=", "BA", ".", "Addr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "NodeAttrs", "::", "Stmt", "||", "Kind", "==", "NodeAttrs", "::", "Phi", ")", "{", "for", "(", "auto", "N", ":", "NodeAddr", "<", "CodeNode", "*", ">", "(", "BA", ")", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "DRNs", ".", "push_back", "(", "N", ")", ";", "DINs", ".", "push_back", "(", "DFG", ".", "addr", "<", "InstrNode", "*", ">", "(", "I", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unexpected code node\"", ")", ";", "return", "false", ";", "}", "}", "auto", "UsesFirst", "=", "[", "]", "(", "NodeAddr", "<", "RefNode", "*", ">", "A", ",", "NodeAddr", "<", "RefNode", "*", ">", "B", ")", "->", "bool", "{", "uint16_t", "KindA", "=", "A", ".", "Addr", "->", "getKind", "(", ")", ",", "KindB", "=", "B", ".", "Addr", "->", "getKind", "(", ")", ";", "if", "(", "KindA", "==", "NodeAttrs", "::", "Use", "&&", "KindB", "==", "NodeAttrs", "::", "Def", ")", "return", "true", ";", "if", "(", "KindA", "==", "NodeAttrs", "::", "Def", "&&", "KindB", "==", "NodeAttrs", "::", "Use", ")", "return", "false", ";", "return", "A", ".", "Id", "<", "B", ".", "Id", ";", "}", ";", "llvm", "::", "sort", "(", "DRNs", ",", "UsesFirst", ")", ";", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Removing dead ref nodes:\\n\"", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "DRNs", ")", "{", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\" \"", "<<", "PrintNode", "<", "RefNode", "*", ">", "(", "RA", ",", "DFG", ")", "<<", "'\\n'", ";", "if", "(", "DFG", ".", "IsUse", "(", "RA", ")", ")", "DFG", ".", "unlinkUse", "(", "RA", ",", "true", ")", ";", "else", "if", "(", "DFG", ".", "IsDef", "(", "RA", ")", ")", "DFG", ".", "unlinkDef", "(", "RA", ",", "true", ")", ";", "}", "for", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ":", "DINs", ")", "{", "NodeAddr", "<", "BlockNode", "*", ">", "BA", "=", "IA", ".", "Addr", "->", "getOwner", "(", "DFG", ")", ";", "BA", ".", "Addr", "->", "removeMember", "(", "IA", ",", "DFG", ")", ";", "if", "(", "!", "DFG", ".", "IsCode", "<", "NodeAttrs", "::", "Stmt", ">", "(", "IA", ")", ")", "continue", ";", "MachineInstr", "*", "MI", "=", "NodeAddr", "<", "StmtNode", "*", ">", "(", "IA", ")", ".", "Addr", "->", "getCode", "(", ")", ";", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\"erasing: \"", "<<", "*", "MI", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "erase", "-", "Erases", "an", "element", "identified", "by", "Key", ",", "if", "it", "exists", "." ]

[ "Hexagon", "\"Unexpected code node\"", "\"Removing dead ref nodes:\\n\"", "\" \"", "\"erasing: \"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "VE", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ve_reflong\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_pc_hi32\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ve_pc_lo32\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ve_got_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_got_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_gotoff_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_gotoff_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_plt_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_plt_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tls_gd_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tls_gd_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tpoff_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tpoff_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "VE", "VE::NumTargetFixupKinds", "\"fixup_ve_reflong\"", "0", "32", "0", "\"fixup_ve_hi32\"", "0", "32", "0", "\"fixup_ve_lo32\"", "0", "32", "0", "\"fixup_ve_pc_hi32\"", "0", "32", "\"fixup_ve_pc_lo32\"", "0", "32", "\"fixup_ve_got_hi32\"", "0", "32", "0", "\"fixup_ve_got_lo32\"", "0", "32", "0", "\"fixup_ve_gotoff_hi32\"", "0", "32", "0", "\"fixup_ve_gotoff_lo32\"", "0", "32", "0", "\"fixup_ve_plt_hi32\"", "0", "32", "0", "\"fixup_ve_plt_lo32\"", "0", "32", "0", "\"fixup_ve_tls_gd_hi32\"", "0", "32", "0", "\"fixup_ve_tls_gd_lo32\"", "0", "32", "0", "\"fixup_ve_tpoff_hi32\"", "0", "32", "0", "\"fixup_ve_tpoff_lo32\"", "0", "32", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "EVT", "VT1", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "isZExtFree", "(", "VT1", ",", "VT2", ")", ")", "{", "return", "true", ";", "}", "if", "(", "Val", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "false", ";", "return", "(", "VT1", ".", "isSimple", "(", ")", "&&", "VT1", ".", "isInteger", "(", ")", "&&", "VT2", ".", "isSimple", "(", ")", "&&", "VT2", ".", "isInteger", "(", ")", "&&", "VT1", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ISD::LOAD", "32" ]

[]

[ "<s>", "void", "SIAnnotateControlFlow", "::", "push", "(", "BasicBlock", "*", "BB", ",", "Value", "*", "Saved", ")", "{", "Stack", ".", "push_back", "(", "std", "::", "make_pair", "(", "BB", ",", "Saved", ")", ")", ";", "}", "</s>" ]

[ "Push", "the", "current", "solver", "state", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isImmMskBitp", "(", "Value", ")", ")", "{", "int", "N", "=", "Log2_32", "(", "Value", ")", "+", "1", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "MKMSK_rus", ")", ",", "Reg", ")", ".", "addImm", "(", "N", ")", ";", "}", "if", "(", "isImmU16", "(", "Value", ")", ")", "{", "int", "Opcode", "=", "isImmU6", "(", "Value", ")", "?", "XCore", "::", "LDC_ru6", ":", "XCore", "::", "LDC_lru6", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ";", "}", "MachineConstantPool", "*", "ConstantPool", "=", "MBB", ".", "getParent", "(", ")", "->", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Value", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "LDWCP_lru6", ")", ",", "Reg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "XCore", "XCore", "1", "XCore::MKMSK_rus", "XCore::LDC_ru6", "XCore::LDC_lru6", "4", "XCore::LDWCP_lru6" ]

[]

[ "<s>", "Align", "ARMTargetLowering", "::", "getABIAlignmentForCallingConv", "(", "Type", "*", "ArgTy", ",", "DataLayout", "DL", ")", "const", "{", "const", "Align", "ABITypeAlign", "(", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ")", ";", "if", "(", "!", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "ABITypeAlign", ";", "return", "std", "::", "min", "(", "ABITypeAlign", ",", "DL", ".", "getStackAlignment", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "correct", "alignment", "for", "the", "current", "calling", "convention", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "do_dispatch", "(", "rtx_insn", "*", "insn", ",", "int", "mode", ")", "{", "if", "(", "mode", "==", "DISPATCH_INIT", ")", "init_dispatch_sched", "(", ")", ";", "else", "if", "(", "mode", "==", "ADD_TO_DISPATCH_WINDOW", ")", "add_to_dispatch_window", "(", "insn", ")", ";", "}", "</s>" ]

[ "This", "routine", "is", "the", "driver", "of", "the", "dispatch", "scheduler", "." ]

[ "i386" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon_HVX", ")", ";", "else", "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", "Hexagon", "4", "1", "0", "1", "0", "HexagonISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "GBZ80TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "int64_t", "Offs", "=", "AM", ".", "BaseOffs", ";", "if", "(", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "!", "AM", ".", "BaseGV", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "!", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "1", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "!", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "Offs", ">=", "0xFF00", ")", "{", "return", "(", "AM", ".", "Scale", "==", "1", "&&", "Offs", "==", "0xFF00", ")", "||", "(", "AM", ".", "Scale", "==", "0", "&&", "Offs", "<=", "0xFFFF", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "GBZ80", "GB", "0", "0", "0", "0", "1", "0", "0xFF00", "1", "0xFF00", "0", "0xFFFF" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "llvm_unreachable", "(", "\"relaxInstruction() should not be called\"", ")", ";", "}", "</s>" ]

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

[ "VE", "\"relaxInstruction() should not be called\"" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "VE", "VE", "\"Should not custom lower this!\"", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::VASTART", "ISD::VAARG" ]

[]

[ "<s>", "StackOffset", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "IsFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "TRI", "->", "hasStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CSSize", "=", "X86FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "bool", "IsWin64Prologue", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "int64_t", "FPDelta", "=", "0", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_INTR", "&&", "Offset", ">=", "0", ")", "{", "Offset", "+=", "getOffsetOfLocalArea", "(", ")", ";", "}", "if", "(", "IsWin64Prologue", ")", "{", "assert", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "StackSize", "%", "16", ")", "==", "8", ")", ";", "uint64_t", "FrameSize", "=", "StackSize", "-", "SlotSize", ";", "if", "(", "X86FI", "->", "getRestoreBasePointer", "(", ")", ")", "FrameSize", "+=", "SlotSize", ";", "uint64_t", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "uint64_t", "SEHFrameOffset", "=", "calculateSetFPREG", "(", "NumBytes", ")", ";", "if", "(", "FI", "&&", "FI", "==", "X86FI", "->", "getFAIndex", "(", ")", ")", "return", "StackOffset", "::", "getFixed", "(", "-", "SEHFrameOffset", ")", ";", "FPDelta", "=", "FrameSize", "-", "SEHFrameOffset", ";", "assert", "(", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "FPDelta", "%", "16", ")", "==", "0", ")", "&&", "\"FPDelta isn't aligned per the Win64 ABI!\"", ")", ";", "}", "if", "(", "FrameReg", "==", "TRI", "->", "getFramePtr", "(", ")", ")", "{", "Offset", "+=", "SlotSize", ";", "Offset", "+=", "FPDelta", ";", "int", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "Offset", "-=", "TailCallReturnAddrDelta", ";", "return", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "}", "if", "(", "TRI", "->", "hasStackRealignment", "(", "MF", ")", "||", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "assert", "(", "isAligned", "(", "MFI", ".", "getObjectAlign", "(", "FI", ")", ",", "-", "(", "Offset", "+", "StackSize", ")", ")", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "StackSize", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "16", "8", "X86", "X86", "16", "0", "\"FPDelta isn't aligned per the Win64 ABI!\"", "X86", "0" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnablePromoteConstant", ")", "addPass", "(", "createAArch64PromoteConstantPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64AddressTypePromotionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "case", "'L'", ":", "case", "'H'", ":", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "RegNumber", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "RegNumber", ")", ")", "RegNumber", "=", "TRI", "->", "getSubReg", "(", "RegNumber", ",", "ExtraCode", "[", "0", "]", "==", "'L'", "?", "Hexagon", "::", "isub_lo", ":", "Hexagon", "::", "isub_hi", ")", ";", "OS", "<<", "HexagonInstPrinter", "::", "getRegisterName", "(", "RegNumber", ")", ";", "return", "false", ";", "}", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "OS", "<<", "\"i\"", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "Hexagon", "Hexagon", "0", "1", "0", "0", "Hexagon::DoubleRegsRegClass", "0", "Hexagon::isub_lo", "Hexagon::isub_hi", "Hexagon", "\"i\"" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "bfin_valid_add", "(", "enum", "machine_mode", "mode", ",", "HOST_WIDE_INT", "value", ")", "{", "unsigned", "HOST_WIDE_INT", "v", "=", "value", ">", "0", "?", "value", ":", "-", "value", ";", "int", "sz", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "int", "shift", "=", "sz", "==", "1", "?", "0", ":", "sz", "==", "2", "?", "1", ":", "2", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "sz", "==", "8", "?", "0x7ffe", ":", "0x7fff", ";", "return", "(", "v", "&", "~", "(", "mask", "<<", "shift", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "legitimate", "memory", "address", "for", "a", "memory", "operand", "of", "mode", "MODE", ".", "Return", "false", "if", "not", "." ]

[ "bfin", "0", "1", "0", "2", "1", "2", "8", "0x7ffe", "0x7fff", "0" ]

[]

[ "<s>", "static", "bool", "s390_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fundecl", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "OFFSET_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", ")", "return", "int_size_in_bytes", "(", "type", ")", ">", "8", ";", "if", "(", "TARGET_VX_ABI", "&&", "VECTOR_TYPE_P", "(", "type", ")", "&&", "int_size_in_bytes", "(", "type", ")", "<=", "16", ")", "return", "false", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", "||", "VECTOR_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "return", "values", "of", "type", "TYPE", "should", "be", "returned", "in", "a", "memory", "buffer", "whose", "address", "is", "passed", "by", "the", "caller", "as", "hidden", "first", "argument", "." ]

[ "s390", "8", "16" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLoadBitCastBeneficial", "(", "EVT", "LoadVT", ",", "EVT", "BitcastVT", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasDQI", "(", ")", "&&", "BitcastVT", "==", "MVT", "::", "v8i1", ")", "return", "false", ";", "return", "TargetLowering", "::", "isLoadBitCastBeneficial", "(", "LoadVT", ",", "BitcastVT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "following", "transform", "is", "beneficial", ":", "fold", "(", "conv", "(", "load", "x", ")", ")", "-", ">", "(", "load", "(", "conv", "*", ")", "x", ")", "On", "architectures", "that", "do", "n't", "natively", "support", "some", "vector", "loads", "efficiently", ",", "casting", "the", "load", "to", "a", "smaller", "vector", "of", "larger", "types", "and", "loading", "is", "more", "efficient", ",", "however", ",", "this", "can", "be", "undone", "by", "optimizations", "in", "dag", "combiner", "." ]

[ "X86", "X86", "MVT::v8i1" ]

[]

[ "<s>", "bool", "MCS51TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "if", "(", "CallConv", "==", "CallingConv", "::", "MCS51_BUILTIN", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_MCS51_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", "." ]

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

[]

[ "<s>", "const", "uint16_t", "*", "AMDGPURegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "&", "CalleeSavedReg", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SPIRV Decorations Generation\"", ";", "}", "</s>" ]

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

[ "SPIRV", "\"SPIRV Decorations Generation\"" ]

[]

[ "<s>", "unsigned", "J2InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "J2", "::", "BRA", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "J2", "J2", "\"code size not handled\"", "0", "J2::BRA" ]

[]

[ "<s>", "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCE", ".", "setModuleInfo", "(", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ")", ";", "II", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "Is64BitMode", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "TargetInstrDesc", "&", "Desc", "=", "I", "->", "getDesc", "(", ")", ";", "emitInstruction", "(", "*", "I", ",", "&", "Desc", ")", ";", "if", "(", "Desc", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOVPC32r", ")", "emitInstruction", "(", "*", "I", ",", "&", "II", "->", "get", "(", "X86", "::", "POP32r", ")", ")", ";", "NumEmitted", "++", ";", "}", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"JITTing function '\"", "\"'\\n\"", "X86::MOVPC32r", "X86::POP32r" ]

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "OR1K", "OR1K", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "unsigned", "RegIndex", ",", "Register", "Addr", ",", "uint64_t", "MemSize", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "unsigned", "MaxSize", "=", "MemSize", "*", "8", ";", "if", "(", "!", "Arg", ".", "IsFixed", ")", "MaxSize", "=", "0", ";", "Register", "ValVReg", "=", "Arg", ".", "Regs", "[", "RegIndex", "]", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", ")", "{", "MVT", "LocVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "MVT", "ValVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i8", "||", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i16", ")", "{", "std", "::", "swap", "(", "ValVT", ",", "LocVT", ")", ";", "MemSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "}", "ValVReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ",", "MaxSize", ")", ";", "const", "LLT", "RegTy", "=", "MRI", ".", "getType", "(", "ValVReg", ")", ";", "if", "(", "RegTy", ".", "getSizeInBits", "(", ")", "<", "LocVT", ".", "getSizeInBits", "(", ")", ")", "ValVReg", "=", "MIRBuilder", ".", "buildTrunc", "(", "RegTy", ",", "ValVReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "else", "{", "MemSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "}", "assignValueToAddress", "(", "ValVReg", ",", "Addr", ",", "MemSize", ",", "MPO", ",", "VA", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AArch64", "8", "0", "MVT::i8", "MVT::i16", "0" ]

[]

[ "<s>", "bool", "isTargetEHABICompatible", "(", ")", "const", "{", "return", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "EABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "EABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "Android", ")", "&&", "!", "isTargetDarwin", "(", ")", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "supports", "the", "EHABI", "exception", "handling", "standard", "." ]

[ "ARM" ]

[]

[ "<s>", "ArrayRef", "<", "MCPhysReg", ">", "ARMBaseRegisterInfo", "::", "getIntraCallClobberedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "IntraCallClobberedRegs", "[", "]", "=", "{", "ARM", "::", "R12", "}", ";", "return", "ArrayRef", "<", "MCPhysReg", ">", "(", "IntraCallClobberedRegs", ")", ";", "}", "</s>" ]

[ "Return", "a", "list", "of", "all", "of", "the", "registers", "which", "are", "clobbered", "``", "inside", "''", "a", "call", "to", "the", "given", "function", "." ]

[ "ARM", "ARM", "ARM::R12" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "unsigned", "Alignment", ")", "{", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "\"Unexpected data type for Gather/Scatter\"", ")", ";", "unsigned", "VF", "=", "SrcVTy", "->", "getVectorNumElements", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "\"Unexpected type for Ptr argument\"", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "bool", "Scalarize", "=", "false", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "!", "isLegalMaskedGather", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "!", "isLegalMaskedScatter", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "VF", "==", "2", "||", "(", "VF", "==", "4", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "Scalarize", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "X86", "X86", "\"Unexpected data type for Gather/Scatter\"", "\"Unexpected type for Ptr argument\"", "2", "4" ]

[]

[ "<s>", "void", "nds32_check_isr_attrs_conflict", "(", "tree", "func_decl", ",", "tree", "func_attrs", ")", "{", "int", "save_all_p", ",", "partial_save_p", ";", "int", "nested_p", ",", "not_nested_p", ",", "nested_ready_p", ";", "int", "intr_p", ",", "excp_p", ",", "reset_p", ";", "save_all_p", "=", "partial_save_p", "=", "0", ";", "nested_p", "=", "not_nested_p", "=", "nested_ready_p", "=", "0", ";", "intr_p", "=", "excp_p", "=", "reset_p", "=", "0", ";", "if", "(", "lookup_attribute", "(", "\"save_all\"", ",", "func_attrs", ")", ")", "save_all_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"partial_save\"", ",", "func_attrs", ")", ")", "partial_save_p", "=", "1", ";", "if", "(", "(", "save_all_p", "+", "partial_save_p", ")", ">", "1", ")", "error", "(", "\"multiple save reg attributes to function %qD\"", ",", "func_decl", ")", ";", "if", "(", "lookup_attribute", "(", "\"nested\"", ",", "func_attrs", ")", ")", "nested_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"not_nested\"", ",", "func_attrs", ")", ")", "not_nested_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"nested_ready\"", ",", "func_attrs", ")", ")", "nested_ready_p", "=", "1", ";", "if", "(", "(", "nested_p", "+", "not_nested_p", "+", "nested_ready_p", ")", ">", "1", ")", "error", "(", "\"multiple nested types attributes to function %qD\"", ",", "func_decl", ")", ";", "if", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "func_attrs", ")", ")", "intr_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"exception\"", ",", "func_attrs", ")", ")", "excp_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"reset\"", ",", "func_attrs", ")", ")", "reset_p", "=", "1", ";", "if", "(", "(", "intr_p", "+", "excp_p", "+", "reset_p", ")", ">", "1", ")", "error", "(", "\"multiple interrupt attributes to function %qD\"", ",", "func_decl", ")", ";", "}", "</s>" ]

[ "Function", "for", "nds32_merge_decl_attributes", "(", ")", "and", "nds32_insert_attributes", "(", ")", "to", "check", "if", "there", "are", "any", "conflict", "isr-specific", "attributes", "being", "set", ".", "We", "need", "to", "check", ":", "1", ".", "Only", "'save_all", "'", "or", "'partial_save", "'", "in", "the", "attributes", ".", "2", ".", "Only", "'nested", "'", ",", "'not_nested", "'", ",", "or", "'nested_ready", "'", "in", "the", "attributes", ".", "3", ".", "Only", "'interrupt", "'", ",", "'exception", "'", ",", "or", "'reset", "'", "in", "the", "attributes", "." ]

[ "nds32", "0", "0", "0", "\"save_all\"", "1", "\"partial_save\"", "1", "1", "\"multiple save reg attributes to function %qD\"", "\"nested\"", "1", "\"not_nested\"", "1", "\"nested_ready\"", "1", "1", "\"multiple nested types attributes to function %qD\"", "\"interrupt\"", "1", "\"exception\"", "1", "\"reset\"", "1", "1", "\"multiple interrupt attributes to function %qD\"" ]

[]

[ "<s>", "static", "rtvec", "rs6000_const_vec", "(", "machine_mode", "mode", ")", "{", "int", "i", ",", "subparts", ";", "rtvec", "v", ";", "switch", "(", "mode", ")", "{", "case", "E_V1TImode", ":", "subparts", "=", "1", ";", "break", ";", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "subparts", "=", "2", ";", "break", ";", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "subparts", "=", "4", ";", "break", ";", "case", "E_V8HImode", ":", "subparts", "=", "8", ";", "break", ";", "case", "E_V16QImode", ":", "subparts", "=", "16", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "v", "=", "rtvec_alloc", "(", "subparts", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "subparts", "/", "2", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "i", "+", "subparts", "/", "2", ")", ";", "for", "(", "i", "=", "subparts", "/", "2", ";", "i", "<", "subparts", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "i", "-", "subparts", "/", "2", ")", ";", "return", "v", ";", "}", "</s>" ]

[ "Generate", "a", "vector", "of", "constants", "to", "permute", "MODE", "for", "a", "little-endian", "storage", "operation", "by", "swapping", "the", "two", "halves", "of", "a", "vector", "." ]

[ "rs6000", "1", "2", "4", "8", "16", "0", "2", "2", "2", "2" ]

[]

[ "<s>", "static", "std", "::", "string", "getEdgeAttributes", "(", "const", "void", "*", ",", "GraphTraits", "<", "SpillCostAnalysisGraph", ">", "::", "ChildIteratorType", "e", ",", "const", "SpillCostAnalysisGraph", "&", "G", ")", "{", "std", "::", "string", "tmp", ";", "raw_string_ostream", "s", "(", "tmp", ")", ";", "MachineInstr", "*", "MI", "=", "e", ".", "getMI", "(", ")", ";", "s", "<<", "\"label=\\\"\"", ";", "if", "(", "MI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "s", "<<", "\"BB#\"", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "\":\"", "<<", "std", "::", "distance", "(", "MBB", "->", "instr_begin", "(", ")", ",", "MachineBasicBlock", "::", "instr_iterator", "(", "MI", ")", ")", ";", "}", "s", "<<", "\"\\\"\"", ";", "return", "s", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "If", "you", "want", "to", "override", "the", "dot", "attributes", "printed", "for", "a", "particular", "edge", ",", "override", "this", "method", "." ]

[ "Patmos", "\"label=\\\"\"", "\"BB#\"", "\":\"", "\"\\\"\"" ]

[]

[ "<s>", "unsigned", "MCS51InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "MCS51", "::", "STDPtrQRr", ":", "case", "MCS51", "::", "STDWPtrQRr", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51::STDPtrQRr", "MCS51::STDWPtrQRr", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", "&&", "!", "DisableVSXSwapRemoval", ")", "addPass", "(", "createPPCVSXSwapRemovalPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "void", "emit_store_conditional", "(", "machine_mode", "mode", ",", "rtx", "res", ",", "rtx", "mem", ",", "rtx", "val", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "fn", "=", "gen_store_conditionalqi", ";", "break", ";", "case", "E_HImode", ":", "fn", "=", "gen_store_conditionalhi", ";", "break", ";", "case", "E_SImode", ":", "fn", "=", "gen_store_conditionalsi", ";", "break", ";", "case", "E_DImode", ":", "fn", "=", "gen_store_conditionaldi", ";", "break", ";", "case", "E_TImode", ":", "fn", "=", "gen_store_conditionalti", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "PPC405_ERRATUM77", ")", "emit_insn", "(", "gen_hwsync", "(", ")", ")", ";", "emit_insn", "(", "fn", "(", "res", ",", "mem", ",", "val", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "store-conditional", "instruction", "in", "MODE", "." ]

[ "rs6000" ]

[]

[ "<s>", "uint64_t", "SIMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isExpr", "(", ")", "&&", "MO", ".", "getExpr", "(", ")", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "Constant", ")", "{", "MCFixupKind", "Kind", ";", "if", "(", "needsPCRel", "(", "MO", ".", "getExpr", "(", ")", ")", ")", "Kind", "=", "FK_PCRel_4", ";", "else", "Kind", "=", "FK_Data_4", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "uint32_t", "Offset", "=", "Desc", ".", "getSize", "(", ")", ";", "assert", "(", "Offset", "==", "4", "||", "Offset", "==", "8", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "Offset", ",", "MO", ".", "getExpr", "(", ")", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "}", "unsigned", "OpNo", "=", "0", ";", "for", "(", "unsigned", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "OpNo", "<", "e", ";", "++", "OpNo", ")", "{", "if", "(", "&", "MO", "==", "&", "MI", ".", "getOperand", "(", "OpNo", ")", ")", "break", ";", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "AMDGPU", "::", "isSISrcOperand", "(", "Desc", ",", "OpNo", ")", ")", "{", "uint32_t", "Enc", "=", "getLitEncoding", "(", "MO", ",", "Desc", ".", "OpInfo", "[", "OpNo", "]", ",", "STI", ")", ";", "if", "(", "Enc", "!=", "~", "0U", ")", "return", "Enc", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "llvm_unreachable", "(", "\"Encoding of this operand type is not supported yet.\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "4", "8", "0", "AMDGPU::isSISrcOperand", "0U", "\"Encoding of this operand type is not supported yet.\"", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MemorySSAWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AVRTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "auto", "STI", "=", "static_cast", "<", "const", "AVRTargetMachine", "&", ">", "(", "this", "->", "getTargetMachine", "(", ")", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "LD8loRegClass", ")", ";", "case", "'b'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "PTRDISPREGSRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "LD8RegClass", ")", ";", "case", "'l'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPR8loRegClass", ")", ";", "case", "'e'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'q'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPRSPRegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPR8RegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i16", "&&", "\"inline asm constraint too large\"", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "DREGSRegClass", ")", ";", "case", "'t'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R0", ")", ",", "&", "AVR", "::", "GPR8RegClass", ")", ";", "case", "'w'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "IWREGSRegClass", ")", ";", "case", "'x'", ":", "case", "'X'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R27R26", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'y'", ":", "case", "'Y'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R29R28", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'z'", ":", "case", "'Z'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R31R30", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "STI", "->", "getRegisterInfo", "(", ")", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "1", "0", "0U", "AVR::LD8loRegClass", "0U", "AVR::PTRDISPREGSRegClass", "0U", "AVR::LD8RegClass", "0U", "AVR::GPR8loRegClass", "0U", "AVR::PTRREGSRegClass", "0U", "AVR::GPRSPRegClass", "MVT::i8", "0U", "AVR::GPR8RegClass", "MVT::i16", "\"inline asm constraint too large\"", "0U", "AVR::DREGSRegClass", "AVR::R0", "AVR::GPR8RegClass", "0U", "AVR::IWREGSRegClass", "AVR::R27R26", "AVR::PTRREGSRegClass", "AVR::R29R28", "AVR::PTRREGSRegClass", "AVR::R31R30", "AVR::PTRREGSRegClass" ]

[]

[ "<s>", "bool", "AMDGPUCFGPerform", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "func", ")", "{", "return", "llvmCFGStruct", "::", "CFGStructurizer", "<", "AMDGPUCFGStructurizer", ">", "(", ")", ".", "run", "(", "func", ",", "*", "this", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be reloaded into\"", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "DestReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "isAGPRClass", "(", "RC", ")", "?", "getAGPRSpillRestoreOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be reloaded into\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "0" ]

[]

[ "<s>", "WeightedLeaf", "pop", "(", ")", "{", "if", "(", "HaveConst", ")", "{", "HaveConst", "=", "false", ";", "return", "ConstElt", ";", "}", "std", "::", "pop_heap", "(", "Q", ".", "begin", "(", ")", ",", "Q", ".", "end", "(", ")", ",", "WeightedLeaf", "::", "Compare", ")", ";", "return", "Q", ".", "pop_back_val", "(", ")", ";", "}", "</s>" ]

[ "Pop", "the", "previous", "solver", "state", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "writeSPToGlobal", "(", "unsigned", "SrcReg", ",", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "InsertStore", ",", "const", "DebugLoc", "&", "DL", ")", "const", "{", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "char", "*", "ES", "=", "\"__stack_pointer\"", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "ES", ")", ";", "BuildMI", "(", "MBB", ",", "InsertStore", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "GLOBAL_SET_I32", ")", ")", ".", "addExternalSymbol", "(", "SPSymbol", ",", "WebAssemblyII", "::", "MO_SYMBOL_GLOBAL", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "</s>" ]

[ "Write", "SP", "back", "to", "__stack_pointer", "global", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "WebAssembly::GLOBAL_SET_I32", "WebAssemblyII::MO_SYMBOL_GLOBAL" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isPredicable", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "OpC", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "OpC", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "B", ":", "case", "PPC", "::", "BLR", ":", "case", "PPC", "::", "BLR8", ":", "case", "PPC", "::", "BCTR", ":", "case", "PPC", "::", "BCTR8", ":", "case", "PPC", "::", "BCTRL", ":", "case", "PPC", "::", "BCTRL8", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::B", "PPC::BLR", "PPC::BLR8", "PPC::BCTR", "PPC::BCTR8", "PPC::BCTRL", "PPC::BCTRL8" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "OS", "<<", "\"\\tlock\\n\"", ";", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86II::LOCK", "\"\\tlock\\n\"", "X86" ]

[]

[ "<s>", "void", "HexagonTargetMachine", "::", "registerPassBuilderCallbacks", "(", "PassBuilder", "&", "PB", ",", "bool", "DebugPassManager", ")", "{", "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>", "static", "void", "riscv_extend_comparands", "(", "rtx_code", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "word_mode", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "op0", ")", ")", ")", "{", "if", "(", "unsigned_condition", "(", "code", ")", "==", "code", "&&", "(", "GET_MODE", "(", "*", "op0", ")", "==", "QImode", "&&", "!", "(", "GET_CODE", "(", "*", "op0", ")", "==", "SUBREG", "&&", "SUBREG_PROMOTED_VAR_P", "(", "*", "op0", ")", "&&", "SUBREG_PROMOTED_SIGNED_P", "(", "*", "op0", ")", "&&", "(", "CONST_INT_P", "(", "*", "op1", ")", "||", "(", "GET_CODE", "(", "*", "op1", ")", "==", "SUBREG", "&&", "SUBREG_PROMOTED_VAR_P", "(", "*", "op1", ")", "&&", "SUBREG_PROMOTED_SIGNED_P", "(", "*", "op1", ")", ")", ")", ")", ")", ")", "{", "*", "op0", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "CONST_INT_P", "(", "*", "op1", ")", ")", "*", "op1", "=", "GEN_INT", "(", "(", "uint8_t", ")", "INTVAL", "(", "*", "op1", ")", ")", ";", "else", "*", "op1", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "else", "{", "*", "op0", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "*", "op1", "!=", "const0_rtx", ")", "*", "op1", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "}", "}", "</s>" ]

[ "Sign-", "or", "zero-extend", "OP0", "and", "OP1", "for", "integer", "comparisons", "." ]

[ "riscv" ]

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "HexagonISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "HexagonISD", "::", "ALLOCA", ":", "return", "\"HexagonISD::ALLOCA\"", ";", "case", "HexagonISD", "::", "ARGEXTEND", ":", "return", "\"HexagonISD::ARGEXTEND\"", ";", "case", "HexagonISD", "::", "AT_GOT", ":", "return", "\"HexagonISD::AT_GOT\"", ";", "case", "HexagonISD", "::", "AT_PCREL", ":", "return", "\"HexagonISD::AT_PCREL\"", ";", "case", "HexagonISD", "::", "BARRIER", ":", "return", "\"HexagonISD::BARRIER\"", ";", "case", "HexagonISD", "::", "CALLR", ":", "return", "\"HexagonISD::CALLR\"", ";", "case", "HexagonISD", "::", "CALLv3nr", ":", "return", "\"HexagonISD::CALLv3nr\"", ";", "case", "HexagonISD", "::", "CALLv3", ":", "return", "\"HexagonISD::CALLv3\"", ";", "case", "HexagonISD", "::", "COMBINE", ":", "return", "\"HexagonISD::COMBINE\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CP", ":", "return", "\"HexagonISD::CP\"", ";", "case", "HexagonISD", "::", "DCFETCH", ":", "return", "\"HexagonISD::DCFETCH\"", ";", "case", "HexagonISD", "::", "EH_RETURN", ":", "return", "\"HexagonISD::EH_RETURN\"", ";", "case", "HexagonISD", "::", "EXTRACTU", ":", "return", "\"HexagonISD::EXTRACTU\"", ";", "case", "HexagonISD", "::", "EXTRACTURP", ":", "return", "\"HexagonISD::EXTRACTURP\"", ";", "case", "HexagonISD", "::", "FCONST32", ":", "return", "\"HexagonISD::FCONST32\"", ";", "case", "HexagonISD", "::", "INSERT", ":", "return", "\"HexagonISD::INSERT\"", ";", "case", "HexagonISD", "::", "INSERTRP", ":", "return", "\"HexagonISD::INSERTRP\"", ";", "case", "HexagonISD", "::", "JT", ":", "return", "\"HexagonISD::JT\"", ";", "case", "HexagonISD", "::", "PACKHL", ":", "return", "\"HexagonISD::PACKHL\"", ";", "case", "HexagonISD", "::", "POPCOUNT", ":", "return", "\"HexagonISD::POPCOUNT\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "SHUFFEB", ":", "return", "\"HexagonISD::SHUFFEB\"", ";", "case", "HexagonISD", "::", "SHUFFEH", ":", "return", "\"HexagonISD::SHUFFEH\"", ";", "case", "HexagonISD", "::", "SHUFFOB", ":", "return", "\"HexagonISD::SHUFFOB\"", ";", "case", "HexagonISD", "::", "SHUFFOH", ":", "return", "\"HexagonISD::SHUFFOH\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "case", "HexagonISD", "::", "VCMPBEQ", ":", "return", "\"HexagonISD::VCMPBEQ\"", ";", "case", "HexagonISD", "::", "VCMPBGT", ":", "return", "\"HexagonISD::VCMPBGT\"", ";", "case", "HexagonISD", "::", "VCMPBGTU", ":", "return", "\"HexagonISD::VCMPBGTU\"", ";", "case", "HexagonISD", "::", "VCMPHEQ", ":", "return", "\"HexagonISD::VCMPHEQ\"", ";", "case", "HexagonISD", "::", "VCMPHGT", ":", "return", "\"HexagonISD::VCMPHGT\"", ";", "case", "HexagonISD", "::", "VCMPHGTU", ":", "return", "\"HexagonISD::VCMPHGTU\"", ";", "case", "HexagonISD", "::", "VCMPWEQ", ":", "return", "\"HexagonISD::VCMPWEQ\"", ";", "case", "HexagonISD", "::", "VCMPWGT", ":", "return", "\"HexagonISD::VCMPWGT\"", ";", "case", "HexagonISD", "::", "VCMPWGTU", ":", "return", "\"HexagonISD::VCMPWGTU\"", ";", "case", "HexagonISD", "::", "VCOMBINE", ":", "return", "\"HexagonISD::VCOMBINE\"", ";", "case", "HexagonISD", "::", "VPACK", ":", "return", "\"HexagonISD::VPACK\"", ";", "case", "HexagonISD", "::", "VSHLH", ":", "return", "\"HexagonISD::VSHLH\"", ";", "case", "HexagonISD", "::", "VSHLW", ":", "return", "\"HexagonISD::VSHLW\"", ";", "case", "HexagonISD", "::", "VSPLATB", ":", "return", "\"HexagonISD::VSPLTB\"", ";", "case", "HexagonISD", "::", "VSPLATH", ":", "return", "\"HexagonISD::VSPLATH\"", ";", "case", "HexagonISD", "::", "VSRAH", ":", "return", "\"HexagonISD::VSRAH\"", ";", "case", "HexagonISD", "::", "VSRAW", ":", "return", "\"HexagonISD::VSRAW\"", ";", "case", "HexagonISD", "::", "VSRLH", ":", "return", "\"HexagonISD::VSRLH\"", ";", "case", "HexagonISD", "::", "VSRLW", ":", "return", "\"HexagonISD::VSRLW\"", ";", "case", "HexagonISD", "::", "VSXTBH", ":", "return", "\"HexagonISD::VSXTBH\"", ";", "case", "HexagonISD", "::", "VSXTBW", ":", "return", "\"HexagonISD::VSXTBW\"", ";", "case", "HexagonISD", "::", "OP_END", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::NodeType", "HexagonISD::ALLOCA", "\"HexagonISD::ALLOCA\"", "HexagonISD::ARGEXTEND", "\"HexagonISD::ARGEXTEND\"", "HexagonISD::AT_GOT", "\"HexagonISD::AT_GOT\"", "HexagonISD::AT_PCREL", "\"HexagonISD::AT_PCREL\"", "HexagonISD::BARRIER", "\"HexagonISD::BARRIER\"", "HexagonISD::CALLR", "\"HexagonISD::CALLR\"", "HexagonISD::CALLv3nr", "\"HexagonISD::CALLv3nr\"", "HexagonISD::CALLv3", "\"HexagonISD::CALLv3\"", "HexagonISD::COMBINE", "\"HexagonISD::COMBINE\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CP", "\"HexagonISD::CP\"", "HexagonISD::DCFETCH", "\"HexagonISD::DCFETCH\"", "HexagonISD::EH_RETURN", "\"HexagonISD::EH_RETURN\"", "HexagonISD::EXTRACTU", "\"HexagonISD::EXTRACTU\"", "HexagonISD::EXTRACTURP", "\"HexagonISD::EXTRACTURP\"", "HexagonISD::FCONST32", "\"HexagonISD::FCONST32\"", "HexagonISD::INSERT", "\"HexagonISD::INSERT\"", "HexagonISD::INSERTRP", "\"HexagonISD::INSERTRP\"", "HexagonISD::JT", "\"HexagonISD::JT\"", "HexagonISD::PACKHL", "\"HexagonISD::PACKHL\"", "HexagonISD::POPCOUNT", "\"HexagonISD::POPCOUNT\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::SHUFFEB", "\"HexagonISD::SHUFFEB\"", "HexagonISD::SHUFFEH", "\"HexagonISD::SHUFFEH\"", "HexagonISD::SHUFFOB", "\"HexagonISD::SHUFFOB\"", "HexagonISD::SHUFFOH", "\"HexagonISD::SHUFFOH\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"", "HexagonISD::VCMPBEQ", "\"HexagonISD::VCMPBEQ\"", "HexagonISD::VCMPBGT", "\"HexagonISD::VCMPBGT\"", "HexagonISD::VCMPBGTU", "\"HexagonISD::VCMPBGTU\"", "HexagonISD::VCMPHEQ", "\"HexagonISD::VCMPHEQ\"", "HexagonISD::VCMPHGT", "\"HexagonISD::VCMPHGT\"", "HexagonISD::VCMPHGTU", "\"HexagonISD::VCMPHGTU\"", "HexagonISD::VCMPWEQ", "\"HexagonISD::VCMPWEQ\"", "HexagonISD::VCMPWGT", "\"HexagonISD::VCMPWGT\"", "HexagonISD::VCMPWGTU", "\"HexagonISD::VCMPWGTU\"", "HexagonISD::VCOMBINE", "\"HexagonISD::VCOMBINE\"", "HexagonISD::VPACK", "\"HexagonISD::VPACK\"", "HexagonISD::VSHLH", "\"HexagonISD::VSHLH\"", "HexagonISD::VSHLW", "\"HexagonISD::VSHLW\"", "HexagonISD::VSPLATB", "\"HexagonISD::VSPLTB\"", "HexagonISD::VSPLATH", "\"HexagonISD::VSPLATH\"", "HexagonISD::VSRAH", "\"HexagonISD::VSRAH\"", "HexagonISD::VSRAW", "\"HexagonISD::VSRAW\"", "HexagonISD::VSRLH", "\"HexagonISD::VSRLH\"", "HexagonISD::VSRLW", "\"HexagonISD::VSRLW\"", "HexagonISD::VSXTBH", "\"HexagonISD::VSXTBH\"", "HexagonISD::VSXTBW", "\"HexagonISD::VSXTBW\"", "HexagonISD::OP_END" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "return", "createAMDGPUELFObjectWriter", "(", "OS", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "R600" ]

[]

[ "<s>", "static", "void", "arm_expand_vec_perm_1", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "sel", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "bool", "one_vector_p", "=", "rtx_equal_p", "(", "op0", ",", "op1", ")", ";", "gcc_checking_assert", "(", "vmode", "==", "V8QImode", "||", "vmode", "==", "V16QImode", ")", ";", "gcc_checking_assert", "(", "GET_MODE", "(", "op0", ")", "==", "vmode", ")", ";", "gcc_checking_assert", "(", "GET_MODE", "(", "op1", ")", "==", "vmode", ")", ";", "gcc_checking_assert", "(", "GET_MODE", "(", "sel", ")", "==", "vmode", ")", ";", "gcc_checking_assert", "(", "TARGET_NEON", ")", ";", "if", "(", "one_vector_p", ")", "{", "if", "(", "vmode", "==", "V8QImode", ")", "emit_insn", "(", "gen_neon_vtbl1v8qi", "(", "target", ",", "op0", ",", "sel", ")", ")", ";", "else", "emit_insn", "(", "gen_neon_vtbl1v16qi", "(", "target", ",", "op0", ",", "sel", ")", ")", ";", "}", "else", "{", "rtx", "pair", ";", "if", "(", "vmode", "==", "V8QImode", ")", "{", "pair", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_neon_vcombinev8qi", "(", "pair", ",", "op0", ",", "op1", ")", ")", ";", "pair", "=", "gen_lowpart", "(", "TImode", ",", "pair", ")", ";", "emit_insn", "(", "gen_neon_vtbl2v8qi", "(", "target", ",", "pair", ",", "sel", ")", ")", ";", "}", "else", "{", "pair", "=", "gen_reg_rtx", "(", "OImode", ")", ";", "emit_insn", "(", "gen_neon_vcombinev16qi", "(", "pair", ",", "op0", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_neon_vtbl2v16qi", "(", "target", ",", "pair", ",", "sel", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Generate", "a", "variable", "permutation", "." ]

[ "arm" ]

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "HexagonISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "HexagonISD", "::", "ALLOCA", ":", "return", "\"HexagonISD::ALLOCA\"", ";", "case", "HexagonISD", "::", "AT_GOT", ":", "return", "\"HexagonISD::AT_GOT\"", ";", "case", "HexagonISD", "::", "AT_PCREL", ":", "return", "\"HexagonISD::AT_PCREL\"", ";", "case", "HexagonISD", "::", "BARRIER", ":", "return", "\"HexagonISD::BARRIER\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "CALLnr", ":", "return", "\"HexagonISD::CALLnr\"", ";", "case", "HexagonISD", "::", "CALLR", ":", "return", "\"HexagonISD::CALLR\"", ";", "case", "HexagonISD", "::", "COMBINE", ":", "return", "\"HexagonISD::COMBINE\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CP", ":", "return", "\"HexagonISD::CP\"", ";", "case", "HexagonISD", "::", "DCFETCH", ":", "return", "\"HexagonISD::DCFETCH\"", ";", "case", "HexagonISD", "::", "EH_RETURN", ":", "return", "\"HexagonISD::EH_RETURN\"", ";", "case", "HexagonISD", "::", "TSTBIT", ":", "return", "\"HexagonISD::TSTBIT\"", ";", "case", "HexagonISD", "::", "EXTRACTU", ":", "return", "\"HexagonISD::EXTRACTU\"", ";", "case", "HexagonISD", "::", "INSERT", ":", "return", "\"HexagonISD::INSERT\"", ";", "case", "HexagonISD", "::", "JT", ":", "return", "\"HexagonISD::JT\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "case", "HexagonISD", "::", "VCOMBINE", ":", "return", "\"HexagonISD::VCOMBINE\"", ";", "case", "HexagonISD", "::", "VPACKE", ":", "return", "\"HexagonISD::VPACKE\"", ";", "case", "HexagonISD", "::", "VPACKO", ":", "return", "\"HexagonISD::VPACKO\"", ";", "case", "HexagonISD", "::", "VASL", ":", "return", "\"HexagonISD::VASL\"", ";", "case", "HexagonISD", "::", "VASR", ":", "return", "\"HexagonISD::VASR\"", ";", "case", "HexagonISD", "::", "VLSR", ":", "return", "\"HexagonISD::VLSR\"", ";", "case", "HexagonISD", "::", "VSPLAT", ":", "return", "\"HexagonISD::VSPLAT\"", ";", "case", "HexagonISD", "::", "VEXTRACTW", ":", "return", "\"HexagonISD::VEXTRACTW\"", ";", "case", "HexagonISD", "::", "VINSERTW0", ":", "return", "\"HexagonISD::VINSERTW0\"", ";", "case", "HexagonISD", "::", "VROR", ":", "return", "\"HexagonISD::VROR\"", ";", "case", "HexagonISD", "::", "READCYCLE", ":", "return", "\"HexagonISD::READCYCLE\"", ";", "case", "HexagonISD", "::", "VZERO", ":", "return", "\"HexagonISD::VZERO\"", ";", "case", "HexagonISD", "::", "D2P", ":", "return", "\"HexagonISD::D2P\"", ";", "case", "HexagonISD", "::", "P2D", ":", "return", "\"HexagonISD::P2D\"", ";", "case", "HexagonISD", "::", "V2Q", ":", "return", "\"HexagonISD::V2Q\"", ";", "case", "HexagonISD", "::", "Q2V", ":", "return", "\"HexagonISD::Q2V\"", ";", "case", "HexagonISD", "::", "TYPECAST", ":", "return", "\"HexagonISD::TYPECAST\"", ";", "case", "HexagonISD", "::", "OP_END", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::NodeType", "HexagonISD::ALLOCA", "\"HexagonISD::ALLOCA\"", "HexagonISD::AT_GOT", "\"HexagonISD::AT_GOT\"", "HexagonISD::AT_PCREL", "\"HexagonISD::AT_PCREL\"", "HexagonISD::BARRIER", "\"HexagonISD::BARRIER\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::CALLnr", "\"HexagonISD::CALLnr\"", "HexagonISD::CALLR", "\"HexagonISD::CALLR\"", "HexagonISD::COMBINE", "\"HexagonISD::COMBINE\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CP", "\"HexagonISD::CP\"", "HexagonISD::DCFETCH", "\"HexagonISD::DCFETCH\"", "HexagonISD::EH_RETURN", "\"HexagonISD::EH_RETURN\"", "HexagonISD::TSTBIT", "\"HexagonISD::TSTBIT\"", "HexagonISD::EXTRACTU", "\"HexagonISD::EXTRACTU\"", "HexagonISD::INSERT", "\"HexagonISD::INSERT\"", "HexagonISD::JT", "\"HexagonISD::JT\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"", "HexagonISD::VCOMBINE", "\"HexagonISD::VCOMBINE\"", "HexagonISD::VPACKE", "\"HexagonISD::VPACKE\"", "HexagonISD::VPACKO", "\"HexagonISD::VPACKO\"", "HexagonISD::VASL", "\"HexagonISD::VASL\"", "HexagonISD::VASR", "\"HexagonISD::VASR\"", "HexagonISD::VLSR", "\"HexagonISD::VLSR\"", "HexagonISD::VSPLAT", "\"HexagonISD::VSPLAT\"", "HexagonISD::VEXTRACTW", "\"HexagonISD::VEXTRACTW\"", "HexagonISD::VINSERTW0", "\"HexagonISD::VINSERTW0\"", "HexagonISD::VROR", "\"HexagonISD::VROR\"", "HexagonISD::READCYCLE", "\"HexagonISD::READCYCLE\"", "HexagonISD::VZERO", "\"HexagonISD::VZERO\"", "HexagonISD::D2P", "\"HexagonISD::D2P\"", "HexagonISD::P2D", "\"HexagonISD::P2D\"", "HexagonISD::V2Q", "\"HexagonISD::V2Q\"", "HexagonISD::Q2V", "\"HexagonISD::Q2V\"", "HexagonISD::TYPECAST", "\"HexagonISD::TYPECAST\"", "HexagonISD::OP_END" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "!", "MI", ".", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isPredicable", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_exact_insn", "(", "insn_code", "icode", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "int", "arg_offset", "=", "0", ";", "if", "(", "base", "->", "use_mask_predication_p", "(", ")", ")", "{", "if", "(", "use_real_mask_p", "(", "pred", ")", ")", "add_input_operand", "(", "arg_offset", "++", ")", ";", "else", "add_all_one_mask_operand", "(", "mask_mode", "(", ")", ")", ";", "}", "if", "(", "!", "function_returns_void_p", "(", ")", "&&", "base", "->", "has_merge_operand_p", "(", ")", ")", "{", "if", "(", "use_real_merge_p", "(", "pred", ")", ")", "add_input_operand", "(", "arg_offset", "++", ")", ";", "else", "add_vundef_operand", "(", "mode", ")", ";", "}", "for", "(", "int", "argno", "=", "arg_offset", ";", "argno", "<", "call_expr_nargs", "(", "exp", ")", ";", "argno", "++", ")", "add_input_operand", "(", "argno", ")", ";", "if", "(", "base", "->", "apply_tail_policy_p", "(", ")", ")", "add_input_operand", "(", "Pmode", ",", "get_tail_policy_for_pred", "(", "pred", ")", ")", ";", "if", "(", "base", "->", "apply_mask_policy_p", "(", ")", ")", "add_input_operand", "(", "Pmode", ",", "get_mask_policy_for_pred", "(", "pred", ")", ")", ";", "if", "(", "base", "->", "apply_vl_p", "(", ")", ")", "add_input_operand", "(", "Pmode", ",", "get_avl_type_rtx", "(", "avl_type", "::", "NONVLMAX", ")", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "with", "a", "1:1", "mapping", "between", "arguments", "and", "input", "operands", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "RCPair", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'h'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "hGPRRegClass", ")", ";", "break", ";", "case", "'r'", ":", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPRRegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPR_8RegClass", ")", ";", "break", ";", "case", "'t'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "ARM", "::", "CPSR", ")", ",", "&", "ARM", "::", "CCRRegClass", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "0U", "ARM::hGPRRegClass", "0U", "ARM::GPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPRRegClass", "64", "0U", "ARM::DPRRegClass", "128", "0U", "ARM::QPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPR_8RegClass", "64", "0U", "ARM::DPR_8RegClass", "128", "0U", "ARM::QPR_8RegClass", "MVT::f32", "0U", "ARM::SPRRegClass", "\"{cc}\"", "ARM::CPSR", "ARM::CCRRegClass" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "TII", "->", "get", "(", "Opcode", ")", ".", "mayStore", "(", ")", "&&", "!", "TII", "->", "isGather4", "(", "Opcode", ")", "&&", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "dmask", ")", "!=", "-", "1", ")", "{", "return", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "}", "if", "(", "Opcode", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Opcode", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "V_DIV_SCALE_F32", ":", "case", "AMDGPU", "::", "V_DIV_SCALE_F64", ":", "{", "SDValue", "Src0", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Src1", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "Src2", "=", "Node", "->", "getOperand", "(", "5", ")", ";", "if", "(", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "&&", "(", "Src0", "==", "Src1", "||", "Src0", "==", "Src2", ")", ")", "break", ";", "MVT", "VT", "=", "Src0", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "VT", ",", "Src0", ".", "getNode", "(", ")", "->", "isDivergent", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "UndefReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ",", "VT", ")", ";", "SDValue", "ImpDef", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "UndefReg", ",", "Src0", ",", "SDValue", "(", ")", ")", ";", "if", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "if", "(", "Src1", ".", "isMachineOpcode", "(", ")", "&&", "Src1", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src1", ";", "else", "if", "(", "Src2", ".", "isMachineOpcode", "(", ")", "&&", "Src2", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src2", ";", "else", "{", "assert", "(", "Src1", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", ";", "Src0", "=", "UndefReg", ";", "Src1", "=", "UndefReg", ";", "}", "}", "else", "break", ";", "SmallVector", "<", "SDValue", ",", "9", ">", "Ops", "(", "Node", "->", "op_begin", "(", ")", ",", "Node", "->", "op_end", "(", ")", ")", ";", "Ops", "[", "1", "]", "=", "Src0", ";", "Ops", "[", "3", "]", "=", "Src1", ";", "Ops", "[", "5", "]", "=", "Src2", ";", "Ops", ".", "push_back", "(", "ImpDef", ".", "getValue", "(", "1", ")", ")", ";", "return", "DAG", ".", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "Node", ")", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ")", ";", "}", "default", ":", "break", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE", "AMDGPU::V_DIV_SCALE_F32", "AMDGPU::V_DIV_SCALE_F64", "1", "3", "5", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "9", "1", "3", "5", "1" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "Subtarget", "->", "useSjLjEH", "(", ")", "?", "ARM", "::", "NoRegister", ":", "ARM", "::", "R0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "ARM", "ARM", "ARM::NoRegister", "ARM::R0" ]

[]

[ "<s>", "static", "void", "xtensa_reorg_loops", "(", "void", ")", "{", "if", "(", "TARGET_LOOPS", ")", "reorg_loops", "(", "false", ",", "&", "xtensa_doloop_hooks", ")", ";", "}", "</s>" ]

[ "Run", "from", "machine_dependent_reorg", ",", "this", "pass", "looks", "for", "doloop_end", "insns", "and", "tries", "to", "rewrite", "the", "RTL", "of", "these", "loops", "so", "that", "proper", "Xtensa", "hardware", "loops", "are", "generated", "." ]

[ "xtensa" ]

[]

[ "<s>", "rtx", "aarch64_simd_gen_const_vector_dup", "(", "machine_mode", "mode", ",", "int", "val", ")", "{", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "nunits", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nunits", ";", "i", "++", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "GEN_INT", "(", "val", ")", ";", "return", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "v", ")", ";", "}", "</s>" ]

[ "Return", "a", "const_int", "vector", "of", "VAL", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "unsigned", "RISCVMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unexpected operand type!\"", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Unexpected operand type!\"" ]

[]

[ "<s>", "void", "MOSFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "MOS", "::", "RC30", ")", ";", "SavedRegs", ".", "set", "(", "MOS", "::", "RC31", ")", ";", "}", "if", "(", "isISR", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "MOS", "::", "RC16", ")", ";", "SavedRegs", ".", "set", "(", "MOS", "::", "RC17", ")", ";", "if", "(", "!", "SavedRegs", ".", "none", "(", ")", ")", "SavedRegs", ".", "set", "(", "MOS", "::", "A", ")", ";", "if", "(", "SavedRegs", ".", "size", "(", ")", ">", "4", ")", "SavedRegs", ".", "set", "(", "MOS", "::", "Y", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "MOS", "MOS", "MOS::RC30", "MOS::RC31", "MOS::RC16", "MOS::RC17", "MOS::A", "4", "MOS::Y" ]

[]

[ "<s>", "rtx", "frv_split_scc", "(", "rtx", "dest", ",", "rtx", "test", ",", "rtx", "cc_reg", ",", "rtx", "cr_reg", ",", "HOST_WIDE_INT", "value", ")", "{", "rtx", "ret", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cr_reg", ",", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "test", ")", ",", "GET_MODE", "(", "cr_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "GEN_INT", "(", "value", ")", ")", ";", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "GET_MODE", "(", "cr_reg", ")", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "dest", ",", "const0_rtx", ")", ")", ")", ";", "ret", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Split", "a", "SCC", "instruction", "into", "component", "parts", ",", "returning", "a", "SEQUENCE", "to", "hold", "the", "separate", "insns", "." ]

[ "frv" ]

[]

[ "<s>", "virtual", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "LLVM_OVERRIDE", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "SystemZ" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createAMDGPUELFObjectWriter", "(", "Is64Bit", ",", "HasRelocationAddend", ",", "OS", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "\"expected switch to return\"" ]

[]

[ "<s>", "unsigned", "LanaiMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCOperand", "&", "MCOp", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "SubtargetInfo", ")", "const", "{", "if", "(", "MCOp", ".", "isReg", "(", ")", ")", "return", "getLanaiRegisterNumbering", "(", "MCOp", ".", "getReg", "(", ")", ")", ";", "if", "(", "MCOp", ".", "isImm", "(", ")", ")", "<", "unsigned", ">", "(", "MCOp", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MCOp", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCOp", ".", "getExpr", "(", ")", ";", "if", "(", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Binary", ")", "{", "const", "MCBinaryExpr", "*", "BinaryExpr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", ";", "Expr", "=", "BinaryExpr", "->", "getLHS", "(", ")", ";", "}", "assert", "(", "isa", "<", "LanaiMCExpr", ">", "(", "Expr", ")", "||", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MCOp", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", "(", "Expr", ")", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai", "Lanai", "0", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getRepRegClassFor", "(", "MVT", "VT", ")", "const", "override", "{", "if", "(", "VT", "==", "MVT", "::", "Untyped", ")", "return", "Subtarget", "->", "hasDSP", "(", ")", "?", "&", "Mips", "::", "ACC64DSPRegClass", ":", "&", "Mips", "::", "ACC64RegClass", ";", "return", "TargetLowering", "::", "getRepRegClassFor", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "'representative", "'", "register", "class", "for", "the", "specified", "value", "type", "." ]

[ "Mips", "MVT::Untyped", "Mips::ACC64DSPRegClass", "Mips::ACC64RegClass" ]

[]

[ "<s>", "static", "bool", "m32r_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "m32r_pass_by_reference", "(", "NULL", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "false", ")", ";", "}", "</s>" ]

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

[ "m32r" ]

[]

[ "<s>", "void", "MipsTargetELFStreamer", "::", "emitAssignment", "(", "MCSymbol", "*", "Symbol", ",", "const", "MCExpr", "*", "Value", ")", "{", "if", "(", "Value", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "SymbolRef", ")", "return", ";", "const", "MCSymbol", "&", "RhsSym", "=", "static_cast", "<", "const", "MCSymbolRefExpr", "*", ">", "(", "Value", ")", "->", "getSymbol", "(", ")", ";", "MCSymbolData", "&", "Data", "=", "getStreamer", "(", ")", ".", "getOrCreateSymbolData", "(", "&", "RhsSym", ")", ";", "if", "(", "!", "(", "MCELF", "::", "getOther", "(", "Data", ")", "&", "(", "ELF", "::", "STO_MIPS_MICROMIPS", ">>", "2", ")", ")", ")", "return", ";", "MCSymbolData", "&", "SymbolData", "=", "getStreamer", "(", ")", ".", "getOrCreateSymbolData", "(", "Symbol", ")", ";", "MCELF", "::", "setOther", "(", "SymbolData", ",", "ELF", "::", "STO_MIPS_MICROMIPS", ">>", "2", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assignment", "of", "Value", "to", "Symbol", "." ]

[ "Mips", "Mips", "2", "2" ]

[]

[ "<s>", "ArrayRef", "<", "MCPhysReg", ">", "MipsABIInfo", "::", "GetVarArgRegs", "(", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsN32", "(", ")", "||", "IsN64", "(", ")", ")", "return", "makeArrayRef", "(", "Mips64IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "the", "variable", "argument", "list", "." ]

[ "Mips", "Mips", "Mips", "\"Unhandled ABI\"" ]

[]

[ "<s>", "uint64_t", "X86TargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Align", "TyAlign", "=", "DL", ".", "getABITypeAlign", "(", "Ty", ")", ";", "if", "(", "TyAlign", ">", "8", ")", "return", "TyAlign", ".", "value", "(", ")", ";", "return", "8", ";", "}", "Align", "Alignment", "(", "4", ")", ";", "if", "(", "Subtarget", ".", "hasSSE1", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Alignment", ")", ";", "return", "Alignment", ".", "value", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "X86", "X86", "8", "8", "4" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ")", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "int", "Cost", "=", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "return", "vectorCostAdjustment", "(", "Cost", ",", "Opcode", ",", "Ty", ",", "nullptr", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "PowerPC", "PPC", "\"Invalid opcode\"" ]

[]

[ "<s>", "virtual", "bool", "isToken", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "Kind", "==", "KindToken", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "SystemZ" ]

[]

[ "<s>", "static", "bool", "rs6000_hard_regno_call_part_clobbered", "(", "unsigned", "int", ",", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "INT_REGNO_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "TARGET_VSX", "&&", "FP_REGNO_P", "(", "regno", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "8", "&&", "!", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_CALL_PART_CLOBBERED", "." ]

[ "rs6000", "4", "8" ]

[]

[ "<s>", "virtual", "const", "TMS320C64XRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X" ]

[]

[ "<s>", "Register", "Cpu0RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "Cpu0", "::", "FP", ")", ":", "(", "Cpu0", "::", "SP", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Cpu0", "Cpu0", "Cpu0::FP", "Cpu0::SP" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "AVR" ]

[]

[ "<s>", "void", "RISCVMCAsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "unsigned", "Opcode", "=", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "assert", "(", "Opcode", "&&", "\"Unexpected insn to relax\"", ")", ";", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "Opcode", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Unexpected insn to relax\"" ]

[]

[ "<s>", "static", "rtx", "nvptx_expand_cmp_swap", "(", "tree", "exp", ",", "rtx", "target", ",", "machine_mode", "ARG_UNUSED", "(", "m", ")", ",", "int", "ARG_UNUSED", "(", "ignore", ")", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "!", "target", ")", "target", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "mem", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "Pmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "cmp", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "src", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "pat", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "mem", ")", ";", "if", "(", "!", "REG_P", "(", "cmp", ")", ")", "cmp", "=", "copy_to_mode_reg", "(", "mode", ",", "cmp", ")", ";", "if", "(", "!", "REG_P", "(", "src", ")", ")", "src", "=", "copy_to_mode_reg", "(", "mode", ",", "src", ")", ";", "if", "(", "mode", "==", "SImode", ")", "pat", "=", "gen_atomic_compare_and_swapsi_1", "(", "target", ",", "mem", ",", "cmp", ",", "src", ",", "const0_rtx", ")", ";", "else", "pat", "=", "gen_atomic_compare_and_swapdi_1", "(", "target", ",", "mem", ",", "cmp", ",", "src", ",", "const0_rtx", ")", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "the", "CMP_SWAP", "PTX", "builtins", ".", "We", "have", "our", "own", "versions", "that", "do", "not", "require", "taking", "the", "address", "of", "any", "object", ",", "other", "than", "the", "memory", "cell", "being", "operated", "on", "." ]

[ "nvptx", "0", "1", "2" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "ADDriOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "ADDri", ":", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "?", "ARM", "::", "tADDrSPi", ":", "ARM", "::", "t2ADDri", ")", ";", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", ".", "get", "(", "ADDriOpc", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", ".", "getRegClass", "(", "MCID", ",", "0", ",", "this", ")", ")", ";", "MachineInstrBuilder", "MIB", "=", "AddDefaultPred", "(", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ")", ";", "if", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "AddDefaultCC", "(", "MIB", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::ADDri", "ARM::tADDrSPi", "ARM::t2ADDri", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AMDGPU", "AMDGPU", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amd_kernel_code_t\"" ]

[]

[ "<s>", "bool", "riscv_epilogue_uses", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", "return", "true", ";", "if", "(", "epilogue_completed", "&&", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "EPILOGUE_USES", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "MI", "->", "mayStore", "(", ")", "&&", "hasStoreToStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "char", "sizetochar", "(", "int", "size", ")", "{", "switch", "(", "size", ")", "{", "case", "64", ":", "return", "'d'", ";", "case", "32", ":", "return", "'s'", ";", "case", "16", ":", "return", "'h'", ";", "case", "8", ":", "return", "'b'", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "equivalent", "letter", "for", "size", "." ]

[ "aarch64", "64", "32", "16", "8" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "EXTSW", ":", "case", "PPC", "::", "EXTSW_32_64", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SubIdx", "=", "PPC", "::", "sub_32", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "PowerPC", "PPC", "PPC::EXTSW", "PPC::EXTSW_32_64", "1", "0", "PPC::sub_32" ]

[]

[ "<s>", "bool", "XtensaInstrInfo", "::", "isCopyInstr", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "*", "&", "Src", ",", "const", "MachineOperand", "*", "&", "Dest", ")", "const", "{", "if", "(", "!", "MI", ".", "isMoveReg", "(", ")", ")", "return", "false", ";", "Dest", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "Xtensa", "Xtensa", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "NVPTXTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int1RegsRegClass", ")", ";", "case", "'c'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int16RegsRegClass", ")", ";", "case", "'h'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int16RegsRegClass", ")", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int32RegsRegClass", ")", ";", "case", "'l'", ":", "case", "'N'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Int64RegsRegClass", ")", ";", "case", "'f'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Float32RegsRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "NVPTX", "::", "Float64RegsRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "1", "0", "0U", "NVPTX::Int1RegsRegClass", "0U", "NVPTX::Int16RegsRegClass", "0U", "NVPTX::Int16RegsRegClass", "0U", "NVPTX::Int32RegsRegClass", "0U", "NVPTX::Int64RegsRegClass", "0U", "NVPTX::Float32RegsRegClass", "0U", "NVPTX::Float64RegsRegClass" ]

[]

[ "<s>", "void", "XNCMRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "llvm_unreachable", "(", "0", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "XNCM", "XNCM", "0" ]

[]

[ "<s>", "unsigned", "getEUsPerCU", "(", "const", "MCSubtargetInfo", "*", "STI", ")", "{", "if", "(", "isGFX10Plus", "(", "*", "STI", ")", "&&", "STI", "->", "getFeatureBits", "(", ")", ".", "test", "(", "FeatureCuMode", ")", ")", "return", "2", ";", "return", "4", ";", "}", "</s>" ]

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

[ "AMDGPU", "2", "4" ]

[]

[ "<s>", "BitVector", "X86RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "RSP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ESP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SPL", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "X86", "::", "RBP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "EBP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "BP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "BPL", ")", ";", "}", "Reserved", ".", "set", "(", "X86", "::", "ST0", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST1", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST2", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST3", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST4", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST5", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST6", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST7", ")", ";", "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", "." ]

[ "X86", "X86", "X86::RSP", "X86::ESP", "X86::SP", "X86::SPL", "X86::RBP", "X86::EBP", "X86::BP", "X86::BPL", "X86::ST0", "X86::ST1", "X86::ST2", "X86::ST3", "X86::ST4", "X86::ST5", "X86::ST6", "X86::ST7" ]

[]

[ "<s>", "Optional", "<", "MCDisassembler", "::", "DecodeStatus", ">", "AMDGPUDisassembler", "::", "onSymbolStart", "(", "SymbolInfoTy", "&", "Symbol", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "if", "(", "Symbol", ".", "Type", "==", "ELF", "::", "STT_AMDGPU_HSA_KERNEL", ")", "{", "Size", "=", "256", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "StringRef", "Name", "=", "Symbol", ".", "Name", ";", "if", "(", "Symbol", ".", "Type", "==", "ELF", "::", "STT_OBJECT", "&&", "Name", ".", "endswith", "(", "StringRef", "(", "\".kd\"", ")", ")", ")", "{", "Size", "=", "64", ";", "return", "decodeKernelDescriptor", "(", "Name", ".", "drop_back", "(", "3", ")", ",", "Bytes", ",", "Address", ")", ";", "}", "return", "None", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "256", "\".kd\"", "64", "3" ]

[]

[ "<s>", "bool", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "TPC" ]

[]

[ "<s>", "bool", "valid_sf_si_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_ALLOW_SF_SUBREG", ")", "return", "true", ";", "if", "(", "mode", "!=", "SFmode", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_INT", ")", "return", "true", ";", "if", "(", "!", "SUBREG_P", "(", "src", ")", "||", "!", "sf_subreg_operand", "(", "src", ",", "mode", ")", ")", "return", "true", ";", "if", "(", "SUBREG_P", "(", "dest", ")", ")", "{", "rtx", "dest_subreg", "=", "SUBREG_REG", "(", "dest", ")", ";", "rtx", "src_subreg", "=", "SUBREG_REG", "(", "src", ")", ";", "return", "GET_MODE", "(", "dest_subreg", ")", "==", "GET_MODE", "(", "src_subreg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "a", "SFmode", "or", "SImode", "move", "can", "be", "done", "without", "converting", "one", "mode", "to", "another", ".", "This", "arrises", "when", "we", "have", ":", "(", "SUBREG", ":", "SF", "(", "REG", ":", "SI", "...", ")", ")", "(", "SUBREG", ":", "SI", "(", "REG", ":", "SF", "...", ")", ")", "and", "one", "of", "the", "values", "is", "in", "a", "floating", "point/vector", "register", ",", "where", "SFmode", "scalars", "are", "stored", "in", "DFmode", "format", "." ]

[ "powerpcspe" ]

[]