Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "int", "compute_plussi_length", "(", "rtx", "*", "operands", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "if", "(", "TARGET_H8300", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", ")", "return", "6", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "(", "n", "&", "0xffffff", ")", "==", "0", ")", "return", "2", ";", "if", "(", "(", "n", "&", "0xffff", ")", "==", "0", ")", "return", "4", ";", "if", "(", "(", "n", "&", "0xff", ")", "==", "0", ")", "return", "6", ";", "}", "return", "8", ";", "}", "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", "2", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "-", "7", "&&", "intval", "<=", "-", "1", ")", ")", "return", "2", ";", "switch", "(", "(", "unsigned", "int", ")", "intval", "&", "0xffffffff", ")", "{", "case", "0x00000001", ":", "case", "0x00000002", ":", "case", "0x00000004", ":", "return", "2", ";", "case", "0xffffffff", ":", "case", "0xfffffffe", ":", "case", "0xfffffffc", ":", "return", "2", ";", "case", "0x00010000", ":", "case", "0x00020000", ":", "return", "2", ";", "case", "0xffff0000", ":", "case", "0xfffe0000", ":", "return", "2", ";", "}", "if", "(", "(", "intval", "&", "0xffff", ")", "==", "0", ")", "return", "4", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0", ")", "return", "h8300_length_from_table", "(", "operands", "[", "0", "]", ",", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ",", "&", "addl_length_table", ")", ";", "else", "return", "h8300_length_from_table", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "&", "addl_length_table", ")", ";", "return", "6", ";", "}", "}", "</s>" ]

[ "Compute", "the", "length", "of", "an", "addition", "insn", "." ]

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

[]

[ "<s>", "static", "bool", "flow_dependent_p", "(", "rtx", "insn", ",", "rtx", "dep_insn", ")", "{", "rtx", "tmp", "=", "PATTERN", "(", "insn", ")", ";", "note_stores", "(", "PATTERN", "(", "dep_insn", ")", ",", "flow_dependent_p_1", ",", "&", "tmp", ")", ";", "return", "tmp", "==", "NULL_RTX", ";", "}", "</s>" ]

[ "Check", "if", "INSN", "is", "flow-dependent", "on", "DEP_INSN", ".", "Can", "also", "be", "used", "to", "check", "if", "DEP_INSN", "is", "anti-flow", "dependent", "on", "INSN", "." ]

[ "sh" ]

[]

[ "<s>", "ATTRIBUTE_UNUSED", "static", "section", "*", "x86_64_elf_select_section", "(", "tree", "decl", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "ix86_in_large_data_p", "(", "decl", ")", ")", "{", "const", "char", "*", "sname", "=", "NULL", ";", "unsigned", "int", "flags", "=", "SECTION_WRITE", "|", "SECTION_LARGE", ";", "switch", "(", "categorize_decl_for_section", "(", "decl", ",", "reloc", ")", ")", "{", "case", "SECCAT_DATA", ":", "sname", "=", "\".ldata\"", ";", "break", ";", "case", "SECCAT_DATA_REL", ":", "sname", "=", "\".ldata.rel\"", ";", "break", ";", "case", "SECCAT_DATA_REL_LOCAL", ":", "sname", "=", "\".ldata.rel.local\"", ";", "break", ";", "case", "SECCAT_DATA_REL_RO", ":", "sname", "=", "\".ldata.rel.ro\"", ";", "break", ";", "case", "SECCAT_DATA_REL_RO_LOCAL", ":", "sname", "=", "\".ldata.rel.ro.local\"", ";", "break", ";", "case", "SECCAT_BSS", ":", "sname", "=", "\".lbss\"", ";", "flags", "|=", "SECTION_BSS", ";", "break", ";", "case", "SECCAT_RODATA", ":", "case", "SECCAT_RODATA_MERGE_STR", ":", "case", "SECCAT_RODATA_MERGE_STR_INIT", ":", "case", "SECCAT_RODATA_MERGE_CONST", ":", "sname", "=", "\".lrodata\"", ";", "flags", "&=", "~", "SECTION_WRITE", ";", "break", ";", "case", "SECCAT_SRODATA", ":", "case", "SECCAT_SDATA", ":", "case", "SECCAT_SBSS", ":", "gcc_unreachable", "(", ")", ";", "case", "SECCAT_TEXT", ":", "case", "SECCAT_TDATA", ":", "case", "SECCAT_TBSS", ":", "break", ";", "}", "if", "(", "sname", ")", "{", "if", "(", "!", "DECL_P", "(", "decl", ")", ")", "return", "get_section", "(", "sname", ",", "flags", ",", "NULL", ")", ";", "return", "get_named_section", "(", "decl", ",", "sname", ",", "reloc", ")", ";", "}", "}", "return", "default_elf_select_section", "(", "decl", ",", "reloc", ",", "align", ")", ";", "}", "</s>" ]

[ "switch", "to", "the", "appropriate", "section", "for", "output", "of", "DECL", ".", "DECL", "is", "either", "a", "`", "VAR_DECL", "'", "node", "or", "a", "constant", "of", "some", "sort", ".", "RELOC", "indicates", "whether", "forming", "the", "initial", "value", "of", "DECL", "requires", "link-time", "relocations", "." ]

[ "i386", "\".ldata\"", "\".ldata.rel\"", "\".ldata.rel.local\"", "\".ldata.rel.ro\"", "\".ldata.rel.ro.local\"", "\".lbss\"", "\".lrodata\"" ]

[]

[ "<s>", "unsigned", "MipsFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "getGlobalBaseRegClass", "(", "MF", ")", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SPUTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SPU", "::", "R64CRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SPU", "::", "R32CRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SPU", "::", "R32FPRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SPU", "::", "R64FPRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SPU", "::", "GPRCRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "1", "0", "MVT::i64", "0U", "SPU::R64CRegClass", "0U", "SPU::R32CRegClass", "MVT::f32", "0U", "SPU::R32FPRegClass", "MVT::f64", "0U", "SPU::R64FPRegClass", "0U", "SPU::GPRCRegClass" ]

[]

[ "<s>", "static", "bool", "rtx_ok_for_offset_p", "(", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "op", ")", "||", "INTVAL", "(", "op", ")", "<", "0", ")", "return", "false", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "return", "INTVAL", "(", "op", ")", "<=", "31", ";", "case", "E_HImode", ":", "return", "(", "INTVAL", "(", "op", ")", "%", "2", ")", "==", "0", "&&", "INTVAL", "(", "op", ")", "<", "63", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "(", "INTVAL", "(", "op", ")", "%", "4", ")", "==", "0", "&&", "INTVAL", "(", "op", ")", "<", "127", ";", "case", "E_DImode", ":", "case", "E_DFmode", ":", "return", "(", "INTVAL", "(", "op", ")", "%", "4", ")", "==", "0", "&&", "INTVAL", "(", "op", ")", "<", "123", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "an", "offset", "suitable", "for", "use", "as", "a", "displacement", "in", "the", "address", "of", "a", "memory", "access", "in", "mode", "MODE", "." ]

[ "visium", "0", "31", "2", "0", "63", "4", "0", "127", "4", "0", "123" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "DstReg", ")", ";", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "unsigned", "Opc", ";", "if", "(", "SystemZ", "::", "GRX32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "STI", ".", "hasLoadStoreOnCond2", "(", ")", ")", "Opc", "=", "SystemZ", "::", "LOCRMux", ";", "else", "{", "Opc", "=", "SystemZ", "::", "LOCR", ";", "MRI", ".", "constrainRegClass", "(", "DstReg", ",", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "}", "}", "else", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "SystemZ", "::", "LOCGR", ";", "else", "llvm_unreachable", "(", "\"Invalid register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "SystemZ::GRX32BitRegClass", "SystemZ::LOCRMux", "SystemZ::LOCR", "SystemZ::GR32BitRegClass", "SystemZ::GR64BitRegClass", "SystemZ::LOCGR", "\"Invalid register class\"" ]

[]

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

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

[ "SHUXI", "SHUXI::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "(", "NumBytes", "-", "1", ")", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "0", "support::little", "1", "8", "0xff" ]

[]

[ "<s>", "void", "PPCInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "const", "char", "*", "RegName", "=", "getRegisterName", "(", "RegNo", ")", ";", "if", "(", "RegName", "[", "0", "]", "==", "'q'", ")", "{", "std", "::", "string", "RN", "(", "RegName", ")", ";", "RN", "[", "0", "]", "=", "'f'", ";", "OS", "<<", "RN", ";", "return", ";", "}", "OS", "<<", "RegName", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

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

[]

[ "<s>", "void", "AArch64LongBranchStub", "::", "applyFixup", "(", "Relocation", "&", "pSrcReloc", ",", "IRBuilder", "&", "pBuilder", ",", "BranchIsland", "&", "pIsland", ")", "{", "LDSymbol", "*", "symbol", "=", "pSrcReloc", ".", "symInfo", "(", ")", "->", "outSymbol", "(", ")", ";", "uint64_t", "dest", "=", "symbol", "->", "fragRef", "(", ")", "->", "frag", "(", ")", "->", "getParent", "(", ")", "->", "getSection", "(", ")", ".", "addr", "(", ")", "+", "symbol", "->", "fragRef", "(", ")", "->", "getOutputOffset", "(", ")", ";", "uint64_t", "src", "=", "pIsland", ".", "getParent", "(", ")", "->", "getSection", "(", ")", ".", "addr", "(", ")", "+", "pIsland", ".", "offset", "(", ")", "+", "pIsland", ".", "size", "(", ")", ";", "if", "(", "isValidForADRP", "(", "src", ",", "dest", ")", ")", "{", "m_pData", "=", "ADRP_TEMPLATE", ";", "m_Name", "=", "\"adrp_veneer\"", ";", "m_Size", "=", "sizeof", "(", "ADRP_TEMPLATE", ")", ";", "getFixupList", "(", ")", ".", "clear", "(", ")", ";", "addFixup", "(", "0x0", ",", "0", ",", "llvm", "::", "ELF", "::", "R_AARCH64_ADR_PREL_PG_HI21", ")", ";", "addFixup", "(", "0x4", ",", "0", ",", "llvm", "::", "ELF", "::", "R_AARCH64_ADD_ABS_LO12_NC", ")", ";", "}", "Stub", "::", "applyFixup", "(", "pSrcReloc", ",", "pBuilder", ",", "pIsland", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"adrp_veneer\"", "0x0", "0", "0x4", "0" ]

[]

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

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

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

[]

[ "<s>", "bool", "XCorePassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createXCoreISelDag", "(", "getXCoreTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore" ]

[]

[ "<s>", "SDNode", "*", "SystemZDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "0", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "if", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "if", "(", "ConstantSDNode", "*", "Op1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", ")", "{", "uint64_t", "Val", "=", "Op1", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "SystemZ", "::", "isImmLF", "(", "Val", ")", "&&", "!", "SystemZ", "::", "isImmHF", "(", "Val", ")", ")", "Node", "=", "splitLargeImmediate", "(", "Opcode", ",", "Node", ",", "Node", "->", "getOperand", "(", "0", ")", ",", "Val", "-", "uint32_t", "(", "Val", ")", ",", "uint32_t", "(", "Val", ")", ")", ";", "}", "break", ";", "case", "ISD", "::", "Constant", ":", "if", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "{", "uint64_t", "Val", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "SystemZ", "::", "isImmLF", "(", "Val", ")", "&&", "!", "SystemZ", "::", "isImmHF", "(", "Val", ")", "&&", "!", "isInt", "<", "32", ">", "(", "Val", ")", ")", "Node", "=", "splitLargeImmediate", "(", "ISD", "::", "OR", ",", "Node", ",", "SDValue", "(", ")", ",", "Val", "-", "uint32_t", "(", "Val", ")", ",", "uint32_t", "(", "Val", ")", ")", ";", "}", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "if", "(", "ConstantSDNode", "*", "Op2", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "2", ")", ")", ")", "{", "uint64_t", "Value", "=", "-", "Op2", "->", "getZExtValue", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "isInt", "<", "32", ">", "(", "Value", ")", ")", "{", "SDValue", "Ops", "[", "]", "=", "{", "Node", "->", "getOperand", "(", "0", ")", ",", "Node", "->", "getOperand", "(", "1", ")", ",", "CurDAG", "->", "getConstant", "(", "int32_t", "(", "Value", ")", ",", "VT", ")", "}", ";", "Node", "=", "CurDAG", "->", "MorphNodeTo", "(", "Node", ",", "ISD", "::", "ATOMIC_LOAD_ADD", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ",", "array_lengthof", "(", "Ops", ")", ")", ";", "}", "}", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "Node", "->", "dump", "(", "CurDAG", ")", ";", "else", "ResNode", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "SystemZ", "SystemZ", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "0", "ISD::OR", "ISD::XOR", "0", "MVT::i64", "1", "SystemZ::isImmLF", "SystemZ::isImmHF", "0", "ISD::Constant", "0", "MVT::i64", "SystemZ::isImmLF", "SystemZ::isImmHF", "32", "ISD::OR", "ISD::ATOMIC_LOAD_SUB", "2", "0", "MVT::i32", "32", "0", "1", "ISD::ATOMIC_LOAD_ADD", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "bool", "GRDest", "=", "XCore", "::", "GRRegsRegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "GRSrc", "=", "XCore", "::", "GRRegsRegClass", ".", "contains", "(", "SrcReg", ")", ";", "if", "(", "GRDest", "&&", "GRSrc", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "ADD_2rus", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "GRDest", "&&", "SrcReg", "==", "XCore", "::", "SP", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "LDAWSP_ru6", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "DestReg", "==", "XCore", "::", "SP", "&&", "GRSrc", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "SETSP_1r", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "XCore", "XCore", "XCore::GRRegsRegClass", "XCore::GRRegsRegClass", "XCore::ADD_2rus", "0", "XCore::SP", "XCore::LDAWSP_ru6", "0", "XCore::SP", "XCore::SETSP_1r", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_trn", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "vmode", ")", ">", "8", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "odd", "=", "0", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "1", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "2", ")", "{", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "i", "+", "odd", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "1", "]", "!=", "(", "(", "i", "+", "nelt", "+", "odd", ")", "&", "mask", ")", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "odd", "=", "!", "odd", ";", "}", "out", "=", "d", "->", "target", ";", "if", "(", "odd", ")", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_trn2v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_trn2v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_trn2v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_trn2v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_trn2v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_trn2v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_trn2v2di", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_trn2v4hf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_trn2v8hf", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_trn2v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_trn2v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_trn2v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "else", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_trn1v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_trn1v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_trn1v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_trn1v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_trn1v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_trn1v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_trn1v2di", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_trn1v4hf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_trn1v8hf", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_trn1v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_trn1v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_trn1v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "emit_insn", "(", "gen", "(", "out", ",", "in0", ",", "in1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "suitable", "for", "the", "TRN", "instructions", "." ]

[ "aarch64", "8", "0", "0", "0", "0", "1", "1", "1", "2", "1", "0", "2", "1" ]

[]

[ "<s>", "Instruction", "*", "ARMTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicOrdering", "Ord", ",", "bool", "IsStore", ",", "bool", "IsLoad", ")", "const", "{", "switch", "(", "Ord", ")", "{", "case", "AtomicOrdering", "::", "NotAtomic", ":", "case", "AtomicOrdering", "::", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "AtomicOrdering", "::", "Monotonic", ":", "case", "AtomicOrdering", "::", "Acquire", ":", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "SequentiallyConsistent", ":", "if", "(", "!", "IsStore", ")", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "Release", ":", "case", "AtomicOrdering", "::", "AcquireRelease", ":", "if", "(", "Subtarget", "->", "isSwift", "(", ")", ")", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISHST", ")", ";", "else", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISH", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown fence ordering in emitLeadingFence\"", ")", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "ARM", "ARM", "\"Invalid fence: unordered/non-atomic\"", "ARM_MB::ISHST", "ARM_MB::ISH", "\"Unknown fence ordering in emitLeadingFence\"" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred", ")", "const", "{", "assert", "(", "!", "MI", "->", "isBundle", "(", ")", "&&", "\"PatmosInstrInfo::PredicateInstruction() can't handle bundles\"", ")", ";", "if", "(", "MI", "->", "isPredicable", "(", ")", ")", "{", "assert", "(", "!", "isPredicated", "(", "MI", ")", "&&", "\"Cannot predicate an instruction already predicated.\"", ")", ";", "int", "i", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "assert", "(", "i", "!=", "-", "1", ")", ";", "MachineOperand", "&", "PO1", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "MachineOperand", "&", "PO2", "=", "MI", "->", "getOperand", "(", "i", "+", "1", ")", ";", "assert", "(", "PO1", ".", "isReg", "(", ")", "&&", "PO2", ".", "isImm", "(", ")", "&&", "\"Unexpected Patmos predicate operand\"", ")", ";", "PO1", ".", "setReg", "(", "Pred", "[", "0", "]", ".", "getReg", "(", ")", ")", ";", "PO2", ".", "setImm", "(", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ")", ";", "fixOpcodeForGuard", "(", "MI", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "Patmos", "Patmos", "\"PatmosInstrInfo::PredicateInstruction() can't handle bundles\"", "\"Cannot predicate an instruction already predicated.\"", "1", "1", "\"Unexpected Patmos predicate operand\"", "0", "1" ]

[]

[ "<s>", "void", "ix86_target_macros", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "cpp_assert", "(", "parse_in", ",", "\"cpu=x86_64\"", ")", ";", "cpp_assert", "(", "parse_in", ",", "\"machine=x86_64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__amd64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__amd64__\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__x86_64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__x86_64__\"", ")", ";", "if", "(", "TARGET_X32", ")", "{", "cpp_define", "(", "parse_in", ",", "\"_ILP32\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__ILP32__\"", ")", ";", "}", "}", "else", "{", "cpp_assert", "(", "parse_in", ",", "\"cpu=i386\"", ")", ";", "cpp_assert", "(", "parse_in", ",", "\"machine=i386\"", ")", ";", "builtin_define_std", "(", "\"i386\"", ")", ";", "}", "if", "(", "!", "TARGET_80387", ")", "cpp_define", "(", "parse_in", ",", "\"_SOFT_FLOAT\"", ")", ";", "if", "(", "TARGET_LONG_DOUBLE_64", ")", "cpp_define", "(", "parse_in", ",", "\"__LONG_DOUBLE_64__\"", ")", ";", "if", "(", "TARGET_LONG_DOUBLE_128", ")", "cpp_define", "(", "parse_in", ",", "\"__LONG_DOUBLE_128__\"", ")", ";", "if", "(", "TARGET_128BIT_LONG_DOUBLE", ")", "cpp_define", "(", "parse_in", ",", "\"__SIZEOF_FLOAT80__=16\"", ")", ";", "else", "cpp_define", "(", "parse_in", ",", "\"__SIZEOF_FLOAT80__=12\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SIZEOF_FLOAT128__=16\"", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__ATOMIC_HLE_ACQUIRE=%d\"", ",", "IX86_HLE_ACQUIRE", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__ATOMIC_HLE_RELEASE=%d\"", ",", "IX86_HLE_RELEASE", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__GCC_ASM_FLAG_OUTPUTS__\"", ")", ";", "ix86_target_macros_internal", "(", "ix86_isa_flags", ",", "ix86_isa_flags2", ",", "ix86_arch", ",", "ix86_tune", ",", "ix86_fpmath", ",", "cpp_define", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SEG_FS\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SEG_GS\"", ")", ";", "}", "</s>" ]

[ "Function", "to", "tell", "the", "preprocessor", "about", "the", "defines", "for", "the", "current", "target", "." ]

[ "i386", "\"cpu=x86_64\"", "\"machine=x86_64\"", "\"__amd64\"", "\"__amd64__\"", "\"__x86_64\"", "\"__x86_64__\"", "\"_ILP32\"", "\"__ILP32__\"", "\"cpu=i386\"", "\"machine=i386\"", "\"i386\"", "\"_SOFT_FLOAT\"", "\"__LONG_DOUBLE_64__\"", "\"__LONG_DOUBLE_128__\"", "\"__SIZEOF_FLOAT80__=16\"", "\"__SIZEOF_FLOAT80__=12\"", "\"__SIZEOF_FLOAT128__=16\"", "\"__ATOMIC_HLE_ACQUIRE=%d\"", "\"__ATOMIC_HLE_RELEASE=%d\"", "\"__GCC_ASM_FLAG_OUTPUTS__\"", "\"__SEG_FS\"", "\"__SEG_GS\"" ]

[]

[ "<s>", "static", "enum", "insn_code", "aarch64_constant_pool_reload_icode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "CODE_FOR_aarch64_reload_movcpsfdi", ";", "case", "E_DFmode", ":", "return", "CODE_FOR_aarch64_reload_movcpdfdi", ";", "case", "E_TFmode", ":", "return", "CODE_FOR_aarch64_reload_movcptfdi", ";", "case", "E_V8QImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv8qidi", ";", "case", "E_V16QImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv16qidi", ";", "case", "E_V4HImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv4hidi", ";", "case", "E_V8HImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv8hidi", ";", "case", "E_V2SImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv2sidi", ";", "case", "E_V4SImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv4sidi", ";", "case", "E_V2DImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv2didi", ";", "case", "E_V2DFmode", ":", "return", "CODE_FOR_aarch64_reload_movcpv2dfdi", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "reload", "icode", "required", "for", "a", "constant", "pool", "in", "mode", "." ]

[ "aarch64" ]

[]

[ "<s>", "MachineInstrBuilder", "MipsInstrInfo", "::", "insertNop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "DL", ")", "const", "{", "assert", "(", "!", "Subtarget", ".", "inMips16Mode", "(", ")", "&&", "\"insertNop does not support MIPS16e mode at this time\"", ")", ";", "const", "unsigned", "MMOpc", "=", "Subtarget", ".", "hasMips32r6", "(", ")", "?", "Mips", "::", "SLL_MMR6", ":", "Mips", "::", "SLL_MM", ";", "const", "unsigned", "Opc", "=", "Subtarget", ".", "inMicroMipsMode", "(", ")", "?", "MMOpc", ":", "Mips", "::", "SLL", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "Mips", "::", "ZERO", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Insert", "an", "ISA", "appropriate", "nop", "." ]

[ "Mips", "Mips", "Mips", "\"insertNop does not support MIPS16e mode at this time\"", "Mips", "Mips::SLL_MMR6", "Mips::SLL_MM", "Mips", "Mips::SLL", "Mips::ZERO", "Mips::ZERO", "0" ]

[]

[ "<s>", "void", "emitInst", "(", "uint32_t", "Inst", ")", "{", "char", "Buffer", "[", "4", "]", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "4", ";", "++", "I", ")", "{", "Buffer", "[", "I", "]", "=", "uint8_t", "(", "Inst", ")", ";", "Inst", ">>=", "8", ";", "}", "EmitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "emitBytes", "(", "StringRef", "(", "Buffer", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "AArch64", "4", "0", "4", "8", "4" ]

[]

[ "<s>", "SDValue", "LanaiTargetLowering", "::", "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", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Lanai32", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "LanaiMachineFunctionInfo", "*", "LanaiMFI", "=", "MF", ".", "getInfo", "<", "LanaiMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "LanaiMFI", "->", "getSRetReturnReg", "(", ")", ";", "assert", "(", "Reg", "&&", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Lanai", "::", "RV", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Lanai", "::", "RV", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "unsigned", "Opc", "=", "LanaiISD", "::", "RET_FLAG", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "ArrayRef", "<", "SDValue", ">", "(", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "ISD::OutputArg", "16", "Lanai", "4", "1", "0", "\"Can only return in registers!\"", "1", "Lanai", "Lanai", "Lanai", "Lanai", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", "Lanai::RV", "1", "Lanai::RV", "0", "LanaiISD::RET_FLAG", "MVT::Other", "0" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "GlobalBaseReg", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "return", "Table", ";", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "X86", "X86", "X86ISD::GlobalBaseReg" ]

[]

[ "<s>", "Register", "getGlobalBaseReg", "(", ")", "const", "{", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "Sparc" ]

[]

[ "<s>", "static", "void", "frv_reorg_packet", "(", "void", ")", "{", "frv_fill_unused_units", "(", "GROUP_I", ")", ";", "frv_fill_unused_units", "(", "GROUP_FM", ")", ";", "frv_align_label", "(", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "frv_reorg", ",", "called", "after", "each", "packet", "has", "been", "constructed", "in", "frv_packet", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "return", "false", ";", "case", "MVT", "::", "f64", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "R600", "SI", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "MVT", "WebAssemblyTargetLowering", "::", "getPointerTy", "(", "const", "DataLayout", "&", "DL", ",", "uint32_t", "AS", ")", "const", "{", "if", "(", "AS", "==", "WebAssembly", "::", "WasmAddressSpace", "::", "WASM_ADDRESS_SPACE_EXTERNREF", ")", "return", "MVT", "::", "externref", ";", "if", "(", "AS", "==", "WebAssembly", "::", "WasmAddressSpace", "::", "WASM_ADDRESS_SPACE_FUNCREF", ")", "return", "MVT", "::", "funcref", ";", "return", "TargetLowering", "::", "getPointerTy", "(", "DL", ",", "AS", ")", ";", "}", "</s>" ]

[ "Return", "the", "pointer", "type", "for", "the", "given", "address", "space", ",", "defaults", "to", "the", "pointer", "type", "from", "the", "data", "layout", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::WasmAddressSpace", "MVT::externref", "WebAssembly::WasmAddressSpace", "MVT::funcref" ]

[]

[ "<s>", "static", "rtx", "frv_expand_set_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "call", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "if", "(", "!", "frv_check_constant_argument", "(", "icode", ",", "1", ",", "op0", ")", ")", "return", "NULL_RTX", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "a", "single", ",", "constant", "argument", ".", "At", "the", "moment", ",", "only", "MHDSETS", "falls", "into", "this", "category", "." ]

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

[]

[ "<s>", "static", "void", "mips_block_move_loop", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ")", "{", "rtx", "label", ",", "src_reg", ",", "dest_reg", ",", "final_src", ";", "HOST_WIDE_INT", "leftover", ";", "leftover", "=", "length", "%", "MAX_MOVE_BYTES", ";", "length", "-=", "leftover", ";", "mips_adjust_block_mem", "(", "src", ",", "MAX_MOVE_BYTES", ",", "&", "src_reg", ",", "&", "src", ")", ";", "mips_adjust_block_mem", "(", "dest", ",", "MAX_MOVE_BYTES", ",", "&", "dest_reg", ",", "&", "dest", ")", ";", "final_src", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "src_reg", ",", "GEN_INT", "(", "length", ")", ",", "0", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "mips_block_move_straight", "(", "dest", ",", "src", ",", "MAX_MOVE_BYTES", ")", ";", "emit_move_insn", "(", "src_reg", ",", "plus_constant", "(", "src_reg", ",", "MAX_MOVE_BYTES", ")", ")", ";", "emit_move_insn", "(", "dest_reg", ",", "plus_constant", "(", "dest_reg", ",", "MAX_MOVE_BYTES", ")", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_insn", "(", "gen_cmpdi", "(", "src_reg", ",", "final_src", ")", ")", ";", "else", "emit_insn", "(", "gen_cmpsi", "(", "src_reg", ",", "final_src", ")", ")", ";", "emit_jump_insn", "(", "gen_bne", "(", "label", ")", ")", ";", "if", "(", "leftover", ")", "mips_block_move_straight", "(", "dest", ",", "src", ",", "leftover", ")", ";", "}", "</s>" ]

[ "Move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", "using", "a", "loop", "that", "moves", "MAX_MOVE_BYTES", "per", "iteration", ".", "LENGTH", "must", "be", "at", "least", "MAX_MOVE_BYTES", ".", "Assume", "that", "the", "memory", "regions", "do", "not", "overlap", "." ]

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

[]

[ "<s>", "bool", "X86DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ";", "switch", "(", "ConstraintCode", ")", "{", "case", "'o'", ":", "case", "'v'", ":", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectAddr", "(", "0", ",", "Op", ",", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "OutOps", ".", "push_back", "(", "Op2", ")", ";", "OutOps", ".", "push_back", "(", "Op3", ")", ";", "OutOps", ".", "push_back", "(", "Op4", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "sparc_gimplify_va_arg", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", ")", "{", "HOST_WIDE_INT", "size", ",", "rsize", ",", "align", ";", "tree", "addr", ",", "incr", ";", "bool", "indirect", ";", "tree", "ptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "if", "(", "pass_by_reference", "(", "NULL", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "false", ")", ")", "{", "indirect", "=", "true", ";", "size", "=", "rsize", "=", "UNITS_PER_WORD", ";", "align", "=", "0", ";", "}", "else", "{", "indirect", "=", "false", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "rsize", "=", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "&", "-", "UNITS_PER_WORD", ";", "align", "=", "0", ";", "if", "(", "TARGET_ARCH64", ")", "{", "if", "(", "TYPE_ALIGN", "(", "type", ")", ">=", "2", "*", "(", "unsigned", ")", "BITS_PER_WORD", ")", "align", "=", "2", "*", "UNITS_PER_WORD", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "size", "==", "0", ")", "size", "=", "rsize", "=", "UNITS_PER_WORD", ";", "else", "size", "=", "rsize", ";", "}", "}", "}", "incr", "=", "valist", ";", "if", "(", "align", ")", "{", "incr", "=", "fold_build_pointer_plus_hwi", "(", "incr", ",", "align", "-", "1", ")", ";", "incr", "=", "fold_convert", "(", "sizetype", ",", "incr", ")", ";", "incr", "=", "fold_build2", "(", "BIT_AND_EXPR", ",", "sizetype", ",", "incr", ",", "size_int", "(", "-", "align", ")", ")", ";", "incr", "=", "fold_convert", "(", "ptr_type_node", ",", "incr", ")", ";", "}", "gimplify_expr", "(", "&", "incr", ",", "pre_p", ",", "post_p", ",", "is_gimple_val", ",", "fb_rvalue", ")", ";", "addr", "=", "incr", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "size", "<", "rsize", ")", "addr", "=", "fold_build_pointer_plus_hwi", "(", "incr", ",", "rsize", "-", "size", ")", ";", "if", "(", "indirect", ")", "{", "addr", "=", "fold_convert", "(", "build_pointer_type", "(", "ptrtype", ")", ",", "addr", ")", ";", "addr", "=", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "else", "if", "(", "align", "==", "0", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "BITS_PER_WORD", ")", "{", "tree", "tmp", "=", "create_tmp_var", "(", "type", ",", "\"va_arg_tmp\"", ")", ";", "tree", "dest_addr", "=", "build_fold_addr_expr", "(", "tmp", ")", ";", "tree", "copy", "=", "build_call_expr", "(", "builtin_decl_implicit", "(", "BUILT_IN_MEMCPY", ")", ",", "3", ",", "dest_addr", ",", "addr", ",", "size_int", "(", "rsize", ")", ")", ";", "TREE_ADDRESSABLE", "(", "tmp", ")", "=", "1", ";", "gimplify_and_add", "(", "copy", ",", "pre_p", ")", ";", "addr", "=", "dest_addr", ";", "}", "else", "addr", "=", "fold_convert", "(", "ptrtype", ",", "addr", ")", ";", "incr", "=", "fold_build_pointer_plus_hwi", "(", "incr", ",", "rsize", ")", ";", "gimplify_assign", "(", "valist", ",", "incr", ",", "post_p", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "</s>" ]

[ "Implement", "`", "va_arg", "'", "for", "stdarg", "." ]

[ "sparc", "0", "1", "0", "2", "2", "0", "1", "0", "\"va_arg_tmp\"", "3", "1" ]

[]

[ "<s>", "void", "emitFill", "(", "const", "MCExpr", "&", "NumBytes", ",", "uint64_t", "FillValue", ",", "SMLoc", "Loc", ")", "override", "{", "EmitMappingSymbol", "(", "\"$d\"", ")", ";", "MCObjectStreamer", "::", "emitFill", "(", "NumBytes", ",", "FillValue", ",", "Loc", ")", ";", "}", "</s>" ]

[ "Emit", "Size", "bytes", "worth", "of", "the", "value", "specified", "by", "FillValue", "." ]

[ "CSKY", "\"$d\"" ]

[]

[ "<s>", "void", "BlackfinRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "dl", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "::", "getUnknownLoc", "(", ")", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FrameSize", "%", "4", ")", "{", "FrameSize", "=", "(", "FrameSize", "+", "3", ")", "&", "~", "3", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "assert", "(", "!", "MFI", "->", "hasCalls", "(", ")", "&&", "\"FP elimination on a non-leaf function is not supported\"", ")", ";", "adjustRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "-", "FrameSize", ")", ";", "return", ";", "}", "if", "(", "FrameSize", "<=", "0x3ffff", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "LINK", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "PUSH", ")", ")", ".", "addReg", "(", "BF", "::", "RETS", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "PUSH", ")", ")", ".", "addReg", "(", "BF", "::", "FP", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "MOVE", ")", ",", "BF", "::", "FP", ")", ".", "addReg", "(", "BF", "::", "SP", ")", ";", "loadConstant", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "P1", ",", "-", "FrameSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "ADDpp", ")", ",", "BF", "::", "SP", ")", ".", "addReg", "(", "BF", "::", "SP", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "BF", "::", "P1", ",", "RegState", "::", "Kill", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "4", "3", "3", "\"FP elimination on a non-leaf function is not supported\"", "BF::SP", "BF::P1", "0x3ffff", "BF::LINK", "BF::PUSH", "BF::RETS", "BF::PUSH", "BF::FP", "BF::MOVE", "BF::FP", "BF::SP", "BF::P1", "BF::ADDpp", "BF::SP", "BF::SP", "BF::P1" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "computeKnownBitsForTargetInstr", "(", "GISelKnownBits", "&", "KB", ",", "Register", "R", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "unsigned", "Depth", ")", "const", "{", "const", "MachineInstr", "*", "MI", "=", "MRI", ".", "getVRegDef", "(", "R", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "G_INTRINSIC", ":", "{", "switch", "(", "MI", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_workitem_id_x", ":", "knownBitsForWorkitemID", "(", "*", "getSubtarget", "(", ")", ",", "KB", ",", "Known", ",", "0", ")", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_workitem_id_y", ":", "knownBitsForWorkitemID", "(", "*", "getSubtarget", "(", ")", ",", "KB", ",", "Known", ",", "1", ")", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_workitem_id_z", ":", "knownBitsForWorkitemID", "(", "*", "getSubtarget", "(", ")", ",", "KB", ",", "Known", ",", "2", ")", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_mbcnt_lo", ":", "case", "Intrinsic", "::", "amdgcn_mbcnt_hi", ":", "{", "unsigned", "Size", "=", "MRI", ".", "getType", "(", "R", ")", ".", "getSizeInBits", "(", ")", ";", "Known", ".", "Zero", ".", "setHighBits", "(", "Size", "-", "getSubtarget", "(", ")", "->", "getWavefrontSizeLog2", "(", ")", ")", ";", "break", ";", "}", "case", "Intrinsic", "::", "amdgcn_groupstaticsize", ":", "{", "Known", ".", "Zero", ".", "setHighBits", "(", "countLeadingZeros", "(", "getSubtarget", "(", ")", "->", "getLocalMemorySize", "(", ")", ")", ")", ";", "break", ";", "}", "}", "break", ";", "}", "case", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_UBYTE", ":", "Known", ".", "Zero", ".", "setHighBits", "(", "24", ")", ";", "break", ";", "case", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_USHORT", ":", "Known", ".", "Zero", ".", "setHighBits", "(", "16", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "AMDGPU", "SI", "AMDGPU::G_INTRINSIC", "Intrinsic::amdgcn_workitem_id_x", "0", "Intrinsic::amdgcn_workitem_id_y", "1", "Intrinsic::amdgcn_workitem_id_z", "2", "Intrinsic::amdgcn_mbcnt_lo", "Intrinsic::amdgcn_mbcnt_hi", "Intrinsic::amdgcn_groupstaticsize", "AMDGPU::G_AMDGPU_BUFFER_LOAD_UBYTE", "24", "AMDGPU::G_AMDGPU_BUFFER_LOAD_USHORT", "16" ]

[]

[ "<s>", "int", "nds32_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "int", "adjust_value", "=", "0", ";", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_call_internal", ":", "case", "CODE_FOR_call_value_internal", ":", "{", "if", "(", "NDS32_ALIGN_P", "(", ")", ")", "{", "rtx_insn", "*", "next_insn", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "next_insn", "&&", "get_attr_length", "(", "next_insn", ")", "!=", "2", ")", "adjust_value", "+=", "2", ";", "}", "if", "(", "find_reg_note", "(", "insn", ",", "REG_NORETURN", ",", "NULL_RTX", ")", ")", "{", "if", "(", "TARGET_16_BIT", ")", "adjust_value", "+=", "2", ";", "else", "adjust_value", "+=", "4", ";", "}", "}", "return", "length", "+", "adjust_value", ";", "default", ":", "return", "length", ";", "}", "}", "</s>" ]

[ "Computing", "the", "Length", "of", "an", "Insn", ".", "Modifies", "the", "length", "assigned", "to", "instruction", "INSN", ".", "LEN", "is", "the", "initially", "computed", "length", "of", "the", "insn", "." ]

[ "nds32", "0", "2", "2", "2", "4" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "{", "return", "Start", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "MSP430" ]

[]

[ "<s>", "bool", "sh_legitimate_index_p", "(", "machine_mode", "mode", ",", "rtx", "op", ",", "bool", "consider_sh2a", ",", "bool", "allow_zero", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "op", ")", ")", "return", "false", ";", "if", "(", "TARGET_SHMEDIA", ")", "{", "int", "size", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "satisfies_constraint_I06", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "!", "(", "INTVAL", "(", "op", ")", "&", "(", "size", "-", "1", ")", ")", "&&", "INTVAL", "(", "op", ")", ">=", "-", "512", "*", "size", "&&", "INTVAL", "(", "op", ")", "<", "512", "*", "size", ")", ";", "}", "else", "{", "const", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "op", ")", ";", "const", "int", "max_disp", "=", "sh_max_mov_insn_displacement", "(", "mode", ",", "consider_sh2a", ")", ";", "const", "int", "align_mask", "=", "mov_insn_alignment_mask", "(", "mode", ",", "consider_sh2a", ")", ";", "if", "(", "!", "allow_zero", "&&", "max_disp", "<", "1", ")", "return", "false", ";", "return", "offset", ">=", "0", "&&", "offset", "<=", "max_disp", "&&", "(", "offset", "&", "align_mask", ")", "==", "0", ";", "}", "}", "</s>" ]

[ "Return", "TRUE", "for", "a", "valid", "displacement", "for", "the", "REG+disp", "addressing", "with", "MODE", "." ]

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

[]

[ "<s>", "void", "R600PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createR600EmitClauseMarkers", "(", ")", ",", "false", ")", ";", "if", "(", "EnableR600IfConvert", ")", "addPass", "(", "&", "IfConverterID", ",", "false", ")", ";", "addPass", "(", "createR600ClauseMergePass", "(", "*", "TM", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getSubClassWithSubReg", "(", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Idx", ")", "const", "{", "if", "(", "!", "Is64Bit", "&&", "Idx", "==", "X86", "::", "sub_8bit", ")", "Idx", "=", "X86", "::", "sub_8bit_hi", ";", "return", "X86GenRegisterInfo", "::", "getSubClassWithSubReg", "(", "RC", ",", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "legal", "sub-class", "of", "RC", "that", "supports", "the", "sub-register", "index", "Idx", "." ]

[ "X86", "X86", "X86::sub_8bit", "X86::sub_8bit_hi", "X86" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "MFI", "->", "getLDSSize", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "AMDGPURegisterInfo", "::", "getRegPressureLimit", "(", "RC", ",", "MF", ")", ";", "case", "AMDGPU", "::", "VGPR_32RegClassID", ":", "return", "std", "::", "min", "(", "ST", ".", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ")", ";", "case", "AMDGPU", "::", "SGPR_32RegClassID", ":", "return", "std", "::", "min", "(", "ST", ".", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU", "AMDGPU::VGPR_32RegClassID", "AMDGPU::SGPR_32RegClassID" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "X86InstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "const", "X86RegisterInfo", "&", "RegInfo", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "StackPtr", "=", "RegInfo", ".", "getStackRegister", "(", ")", ";", "bool", "reseveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "int", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "bool", "IsLP64", "=", "STI", ".", "isTarget64BitLP64", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reseveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "CalleeAmt", "=", "isDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reseveCallFrame", ")", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "unsigned", "StackAlign", "=", "TM", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "getSUBriOpcode", "(", "IsLP64", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "{", "unsigned", "Opc", "=", "getADDriOpcode", "(", "IsLP64", ",", "Amount", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "return", ";", "}", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", "&&", "CalleeAmt", ")", "{", "unsigned", "Opc", "=", "getSUBriOpcode", "(", "IsLP64", ",", "CalleeAmt", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "std", "::", "prev", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "0", "0", "1", "0", "0", "1", "3", "3" ]

[]

[ "<s>", "static", "bool", "mmix_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "aligned_p", ")", "switch", "(", "size", ")", "{", "case", "1", ":", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "{", "assemble_integer_with_op", "(", "\"\\t.byte\\t\"", ",", "x", ")", ";", "return", "true", ";", "}", "fputs", "(", "\"\\tBYTE\\t\"", ",", "asm_out_file", ")", ";", "mmix_print_operand", "(", "asm_out_file", ",", "x", ",", "'B'", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "case", "2", ":", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "{", "aligned_p", "=", "0", ";", "break", ";", "}", "fputs", "(", "\"\\tWYDE\\t\"", ",", "asm_out_file", ")", ";", "mmix_print_operand", "(", "asm_out_file", ",", "x", ",", "'W'", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "case", "4", ":", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "{", "aligned_p", "=", "0", ";", "break", ";", "}", "fputs", "(", "\"\\tTETRA\\t\"", ",", "asm_out_file", ")", ";", "mmix_print_operand", "(", "asm_out_file", ",", "x", ",", "'L'", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "case", "8", ":", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", ")", ";", "assemble_integer_with_op", "(", "\"\\tOCTA\\t\"", ",", "x", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "Use", "mmix_print_operand", "for", "WYDE", "and", "TETRA", ".", "Use", "mmix_output_octa", "to", "output", "8-byte", "CONST_DOUBLEs", "." ]

[ "mmix", "1", "\"\\t.byte\\t\"", "\"\\tBYTE\\t\"", "2", "0", "\"\\tWYDE\\t\"", "4", "0", "\"\\tTETRA\\t\"", "8", "\"\\tOCTA\\t\"" ]

[]

[ "<s>", "unsigned", "Mips16InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "unsigned", "DefaultSafety", "=", "1", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "PPC", "::", "G8RC_NOX0RegClassID", ":", "case", "PPC", "::", "GPRC_NOR0RegClassID", ":", "case", "PPC", "::", "G8RCRegClassID", ":", "case", "PPC", "::", "GPRCRegClassID", ":", "{", "unsigned", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "return", "32", "-", "FP", "-", "DefaultSafety", ";", "}", "case", "PPC", "::", "F8RCRegClassID", ":", "case", "PPC", "::", "F4RCRegClassID", ":", "case", "PPC", "::", "VRRCRegClassID", ":", "case", "PPC", "::", "VFRCRegClassID", ":", "case", "PPC", "::", "VSLRCRegClassID", ":", "case", "PPC", "::", "VSHRCRegClassID", ":", "return", "32", "-", "DefaultSafety", ";", "case", "PPC", "::", "VSRCRegClassID", ":", "case", "PPC", "::", "VSFRCRegClassID", ":", "return", "64", "-", "DefaultSafety", ";", "case", "PPC", "::", "CRRCRegClassID", ":", "return", "8", "-", "DefaultSafety", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "PowerPC", "PPC", "1", "0", "PPC::G8RC_NOX0RegClassID", "PPC::GPRC_NOR0RegClassID", "PPC::G8RCRegClassID", "PPC::GPRCRegClassID", "1", "0", "32", "PPC::F8RCRegClassID", "PPC::F4RCRegClassID", "PPC::VRRCRegClassID", "PPC::VFRCRegClassID", "PPC::VSLRCRegClassID", "PPC::VSHRCRegClassID", "32", "PPC::VSRCRegClassID", "PPC::VSFRCRegClassID", "64", "PPC::CRRCRegClassID", "8" ]

[]

[ "<s>", "unsigned", "PIC16InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "PIC16", "::", "movwf", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isSymbol", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16::movwf", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "flag_delete_null_pointer_checks", "=", "0", ";", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"-fpic is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"-fPIC is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"-fpie is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"-fPIE is not supported\"", ")", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "avr_register_passes", "(", ")", ";", "}", "</s>" ]

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

[ "avr", "0", "0", "0", "1", "\"-fpic is not supported\"", "2", "\"-fPIC is not supported\"", "1", "\"-fpie is not supported\"", "2", "\"-fPIE is not supported\"", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1" ]

[]

[ "<s>", "DecodeStatus", "MipsDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Region", ",", "Address", ",", "Size", ",", "Insn", ",", "isBigEndian", ",", "IsMicroMips", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "IsMicroMips", ")", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableMicroMips32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "Result", "=", "decodeInstruction", "(", "DecoderTableMips32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "4", "Mips", "4" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "wasm_atomic_notify", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "Align", "(", "4", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOVolatile", "|", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "case", "Intrinsic", "::", "wasm_atomic_wait_i32", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "Align", "(", "4", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOVolatile", "|", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "case", "Intrinsic", "::", "wasm_atomic_wait_i64", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i64", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "Align", "(", "8", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOVolatile", "|", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "Intrinsic::wasm_atomic_notify", "ISD::INTRINSIC_W_CHAIN", "MVT::i32", "0", "0", "4", "Intrinsic::wasm_atomic_wait_i32", "ISD::INTRINSIC_W_CHAIN", "MVT::i32", "0", "0", "4", "Intrinsic::wasm_atomic_wait_i64", "ISD::INTRINSIC_W_CHAIN", "MVT::i64", "0", "0", "8" ]

[]

[ "<s>", "bool", "MVEGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Scatters", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", ")", "Gathers", ".", "push_back", "(", "II", ")", ";", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", ")", "Scatters", ".", "push_back", "(", "II", ")", ";", "}", "}", "bool", "Changed", "=", "false", ";", "for", "(", "IntrinsicInst", "*", "I", ":", "Gathers", ")", "Changed", "|=", "lowerGather", "(", "I", ")", ";", "for", "(", "IntrinsicInst", "*", "I", ":", "Scatters", ")", "Changed", "|=", "lowerScatter", "(", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "Intrinsic::masked_gather", "Intrinsic::masked_scatter" ]

[]

[ "<s>", "bool", "aarch64_expand_cpymem", "(", "rtx", "*", "operands", ")", "{", "int", "mode_bits", ";", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "base", ";", "machine_mode", "cur_mode", "=", "BLKmode", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "unsigned", "HOST_WIDE_INT", "max_copy_size", "=", "256", ";", "if", "(", "optimize_function_for_size_p", "(", "cfun", ")", ")", "max_copy_size", "=", "128", ";", "int", "copy_bits", "=", "256", ";", "if", "(", "size", "<=", "24", "||", "!", "TARGET_SIMD", "||", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS", ")", ")", "{", "copy_bits", "=", "128", ";", "max_copy_size", "=", "max_copy_size", "/", "2", ";", "}", "if", "(", "size", ">", "max_copy_size", ")", "return", "false", ";", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "dst", ",", "0", ")", ")", ";", "dst", "=", "adjust_automodify_address", "(", "dst", ",", "VOIDmode", ",", "base", ",", "0", ")", ";", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "0", ")", ")", ";", "src", "=", "adjust_automodify_address", "(", "src", ",", "VOIDmode", ",", "base", ",", "0", ")", ";", "int", "n", "=", "size", "*", "BITS_PER_UNIT", ";", "while", "(", "n", ">", "0", ")", "{", "opt_scalar_int_mode", "mode_iter", ";", "FOR_EACH_MODE_IN_CLASS", "(", "mode_iter", ",", "MODE_INT", ")", "if", "(", "GET_MODE_BITSIZE", "(", "mode_iter", ".", "require", "(", ")", ")", "<=", "MIN", "(", "n", ",", "copy_bits", ")", ")", "cur_mode", "=", "mode_iter", ".", "require", "(", ")", ";", "gcc_assert", "(", "cur_mode", "!=", "BLKmode", ")", ";", "mode_bits", "=", "GET_MODE_BITSIZE", "(", "cur_mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "mode_bits", "==", "128", "&&", "copy_bits", "==", "256", ")", "cur_mode", "=", "V4SImode", ";", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "cur_mode", ")", ";", "n", "-=", "mode_bits", ";", "if", "(", "n", ">", "0", "&&", "n", "<", "copy_bits", "/", "2", ")", "{", "machine_mode", "next_mode", "=", "smallest_mode_for_size", "(", "n", ",", "MODE_INT", ")", ";", "int", "n_bits", "=", "GET_MODE_BITSIZE", "(", "next_mode", ")", ".", "to_constant", "(", ")", ";", "gcc_assert", "(", "n_bits", "<=", "mode_bits", ")", ";", "src", "=", "aarch64_move_pointer", "(", "src", ",", "(", "n", "-", "n_bits", ")", "/", "BITS_PER_UNIT", ")", ";", "dst", "=", "aarch64_move_pointer", "(", "dst", ",", "(", "n", "-", "n_bits", ")", "/", "BITS_PER_UNIT", ")", ";", "n", "=", "n_bits", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "cpymem", ",", "as", "if", "from", "a", "__builtin_memcpy", ".", "Return", "true", "if", "we", "succeed", ",", "otherwise", "return", "false", "." ]

[ "aarch64", "0", "1", "2", "2", "256", "128", "256", "24", "128", "2", "0", "0", "0", "0", "0", "128", "256", "0", "2" ]

[]

[ "<s>", "static", "int", "avr_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "mode", "==", "QImode", "?", "2", ":", "mode", "==", "HImode", "?", "4", ":", "mode", "==", "SImode", "?", "8", ":", "mode", "==", "SFmode", "?", "8", ":", "16", ")", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_MEMORY_MOVE_COST", "'" ]

[ "avr", "2", "4", "8", "8", "16" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "FPSCR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "FramePtr", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "Reserved", ".", "set", "(", "ARM", "::", "R9", ")", ";", "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", "." ]

[ "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::R9" ]

[]

[ "<s>", "Cpu0Subtarget", "&", "Cpu0Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "if", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "cpu0", "||", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "cpu0el", ")", "{", "if", "(", "CPU", ".", "empty", "(", ")", "||", "CPU", "==", "\"generic\"", ")", "{", "CPU", "=", "\"cpu032II\"", ";", "}", "else", "if", "(", "CPU", "==", "\"help\"", ")", "{", "CPU", "=", "\"\"", ";", "return", "*", "this", ";", "}", "else", "if", "(", "CPU", "!=", "\"cpu032I\"", "&&", "CPU", "!=", "\"cpu032II\"", ")", "{", "CPU", "=", "\"cpu032II\"", ";", "}", "}", "else", "{", "errs", "(", ")", "<<", "\"!!!Error, TargetTriple.getArch() = \"", "<<", "TargetTriple", ".", "getArch", "(", ")", "<<", "\"CPU = \"", "<<", "CPU", "<<", "\"\\n\"", ";", "exit", "(", "0", ")", ";", "}", "if", "(", "CPU", "==", "\"cpu032I\"", ")", "Cpu0ArchVersion", "=", "Cpu032I", ";", "else", "if", "(", "CPU", "==", "\"cpu032II\"", ")", "Cpu0ArchVersion", "=", "Cpu032II", ";", "if", "(", "isCpu032I", "(", ")", ")", "{", "HasCmp", "=", "true", ";", "HasSlt", "=", "false", ";", "}", "else", "if", "(", "isCpu032II", "(", ")", ")", "{", "HasCmp", "=", "true", ";", "HasSlt", "=", "true", ";", "}", "else", "{", "errs", "(", ")", "<<", "\"-mcpu must be empty(default:cpu032II), cpu032I or cpu032II\"", "<<", "\"\\n\"", ";", "}", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPU", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "\"generic\"", "\"cpu032II\"", "\"help\"", "\"\"", "\"cpu032I\"", "\"cpu032II\"", "\"cpu032II\"", "\"!!!Error, TargetTriple.getArch() = \"", "\"CPU = \"", "\"\\n\"", "0", "\"cpu032I\"", "Cpu0", "Cpu0", "\"cpu032II\"", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "\"-mcpu must be empty(default:cpu032II), cpu032I or cpu032II\"", "\"\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "type", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", "||", "(", "TARGET_HARD_FLOAT", "&&", "!", "is_complex_IBM_long_double", "(", "mode", ")", "&&", "FLOAT128_2REG_P", "(", "mode", ")", ")", ")", ")", "return", "64", ";", "else", "if", "(", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "return", "128", ";", "else", "if", "(", "PAIRED_VECTOR_MODE", "(", "mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "8", "&&", "int_size_in_bytes", "(", "type", ")", "<", "16", ")", ")", "return", "64", ";", "else", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "elt_mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "16", ")", ")", "return", "128", ";", "if", "(", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "&&", "!", "rs6000_compat_align_parm", ")", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "{", "bool", "aggregate_p", "=", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "!", "SCALAR_FLOAT_MODE_P", "(", "elt_mode", ")", ")", ";", "if", "(", "aggregate_p", "!=", "(", "mode", "==", "BLKmode", ")", ")", "{", "static", "bool", "warned", ";", "if", "(", "!", "warned", "&&", "warn_psabi", ")", "{", "warned", "=", "true", ";", "inform", "(", "input_location", ",", "\"the ABI of passing aggregates with %d-byte alignment\"", "\" has changed in GCC 5\"", ",", "(", "int", ")", "TYPE_ALIGN", "(", "type", ")", "/", "BITS_PER_UNIT", ")", ";", "}", "}", "if", "(", "aggregate_p", ")", "return", "128", ";", "}", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "mode", "==", "BLKmode", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "return", "128", ";", "return", "PARM_BOUNDARY", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "expression", "that", "gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", ".", "If", "it", "is", "not", "defined", ",", "PARM_BOUNDARY", "is", "used", "for", "all", "arguments", ".", "V.4", "wants", "long", "longs", "and", "doubles", "to", "be", "double", "word", "aligned", ".", "Just", "testing", "the", "mode", "size", "is", "a", "boneheaded", "way", "to", "do", "this", "as", "it", "means", "that", "other", "types", "such", "as", "complex", "int", "are", "also", "double", "word", "aligned", ".", "However", ",", "we", "'re", "stuck", "with", "this", "because", "changing", "the", "ABI", "might", "break", "existing", "library", "interfaces", ".", "Quadword", "align", "Altivec/VSX", "vectors", ".", "Quadword", "align", "large", "synthetic", "vector", "types", "." ]

[ "rs6000", "8", "64", "128", "8", "16", "64", "16", "128", "64", "\"the ABI of passing aggregates with %d-byte alignment\"", "\" has changed in GCC 5\"", "128", "64", "128" ]

[]

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

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

[ "LM32", "LM32" ]

[]

[ "<s>", "int", "mcore_num_ones", "(", "int", "mask", ")", "{", "mask", "=", "(", "mask", ">>", "1", "&", "0x55555555", ")", "+", "(", "mask", "&", "0x55555555", ")", ";", "mask", "=", "(", "(", "mask", ">>", "2", ")", "&", "0x33333333", ")", "+", "(", "mask", "&", "0x33333333", ")", ";", "mask", "=", "(", "(", "mask", ">>", "4", ")", "+", "mask", ")", "&", "0x0f0f0f0f", ";", "mask", "=", "(", "(", "mask", ">>", "8", ")", "+", "mask", ")", ";", "return", "(", "mask", "+", "(", "mask", ">>", "16", ")", ")", "&", "0xff", ";", "}", "</s>" ]

[ "Count", "the", "number", "of", "ones", "in", "mask", "." ]

[ "mcore", "1", "0x55555555", "0x55555555", "2", "0x33333333", "0x33333333", "4", "0x0f0f0f0f", "8", "16", "0xff" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "void", "X86InstructionSelector", "::", "beginFunction", "(", "const", "MachineFunction", "&", "MF", ")", "{", "OptForSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "OptForMinSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "AvailableFeatures", "=", "computeAvailableFeatures", "(", "&", "MF", ",", "&", "STI", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "exception", "information", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "avr_file_start", "(", "void", ")", "{", "int", "sfr_offset", "=", "avr_arch", "->", "sfr_offset", ";", "if", "(", "avr_arch", "->", "asm_only", ")", "error", "(", "\"architecture %qs supported for assembler only\"", ",", "avr_mmcu", ")", ";", "default_file_start", "(", ")", ";", "if", "(", "AVR_HAVE_SPH", ")", "fprintf", "(", "asm_out_file", ",", "\"__SP_H__ = 0x%02x\\n\"", ",", "avr_addr", ".", "sp_h", "-", "sfr_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__SP_L__ = 0x%02x\\n\"", ",", "avr_addr", ".", "sp_l", "-", "sfr_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__SREG__ = 0x%02x\\n\"", ",", "avr_addr", ".", "sreg", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPZ", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPZ__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampz", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPY", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPY__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampy", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPX", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPX__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampx", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPD__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampd", "-", "sfr_offset", ")", ";", "if", "(", "AVR_XMEGA", "||", "AVR_TINY", ")", "fprintf", "(", "asm_out_file", ",", "\"__CCP__ = 0x%02x\\n\"", ",", "avr_addr", ".", "ccp", "-", "sfr_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__tmp_reg__ = %d\\n\"", ",", "AVR_TMP_REGNO", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__zero_reg__ = %d\\n\"", ",", "AVR_ZERO_REGNO", ")", ";", "}", "</s>" ]

[ "Outputs", "some", "appropriate", "text", "to", "go", "at", "the", "start", "of", "an", "assembler", "file", "." ]

[ "avr", "\"architecture %qs supported for assembler only\"", "\"__SP_H__ = 0x%02x\\n\"", "\"__SP_L__ = 0x%02x\\n\"", "\"__SREG__ = 0x%02x\\n\"", "\"__RAMPZ__ = 0x%02x\\n\"", "\"__RAMPY__ = 0x%02x\\n\"", "\"__RAMPX__ = 0x%02x\\n\"", "\"__RAMPD__ = 0x%02x\\n\"", "\"__CCP__ = 0x%02x\\n\"", "\"__tmp_reg__ = %d\\n\"", "\"__zero_reg__ = %d\\n\"" ]

[]

[ "<s>", "inline", "static", "rtx", "emit_set_insn", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "return", "emit_insn", "(", "gen_rtx_SET", "(", "x", ",", "y", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "insn", "that", "'s", "a", "simple", "single-set", ".", "Both", "the", "operands", "must", "be", "known", "to", "be", "valid", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "buildOutlinedFrame", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "OutlinedFunction", "&", "OF", ")", "const", "{", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerTailCall", ")", "return", ";", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerThunk", ")", "{", "MachineInstr", "*", "Call", "=", "&", "*", "--", "MBB", ".", "instr_end", "(", ")", ";", "bool", "isThumb", "=", "Subtarget", ".", "isThumb", "(", ")", ";", "unsigned", "FuncOp", "=", "isThumb", "?", "2", ":", "0", ";", "unsigned", "Opc", "=", "Call", "->", "getOperand", "(", "FuncOp", ")", ".", "isReg", "(", ")", "?", "isThumb", "?", "ARM", "::", "tTAILJMPr", ":", "ARM", "::", "TAILJMPr", ":", "isThumb", "?", "Subtarget", ".", "isTargetMachO", "(", ")", "?", "ARM", "::", "tTAILJMPd", ":", "ARM", "::", "tTAILJMPdND", ":", "ARM", "::", "TAILJMPd", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "add", "(", "Call", "->", "getOperand", "(", "FuncOp", ")", ")", ";", "if", "(", "isThumb", "&&", "!", "Call", "->", "getOperand", "(", "FuncOp", ")", ".", "isReg", "(", ")", ")", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "Call", "->", "eraseFromParent", "(", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "get", "(", "Subtarget", ".", "getReturnOpcode", "(", ")", ")", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "custom", "frame", "for", "outlined", "functions", "." ]

[ "ARM", "ARM", "2", "0", "ARM::tTAILJMPr", "ARM::TAILJMPr", "ARM::tTAILJMPd", "ARM::tTAILJMPdND", "ARM::TAILJMPd", "ARMCC::AL", "ARMCC::AL" ]

[]

[ "<s>", "bool", "TPCInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TPC", "::", "JMPR", ")", "{", "return", "true", ";", "}", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "getNumOperands", "(", ")", ">", "1", ")", "{", "const", "MachineOperand", "&", "PossiblePred", "=", "MI", ".", "getOperand", "(", "MCID", ".", "getNumOperands", "(", ")", "-", "2", ")", ";", "const", "MachineOperand", "&", "PossiblePol", "=", "MI", ".", "getOperand", "(", "MCID", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "if", "(", "!", "PossiblePol", ".", "isImm", "(", ")", "||", "!", "PossiblePred", ".", "isReg", "(", ")", ")", "return", "false", ";", "Register", "PReg", "=", "PossiblePred", ".", "getReg", "(", ")", ";", "if", "(", "PReg", "==", "TPC", "::", "SP0", "||", "PReg", "==", "TPC", "::", "VP0", ")", "return", "false", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "PReg", ".", "isPhysical", "(", ")", ")", "{", "RC", "=", "getClassOfPhysicalRegister", "(", "PReg", ",", "RI", ")", ";", "}", "else", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "RC", "=", "MRI", ".", "getRegClass", "(", "PReg", ")", ";", "}", "return", "TPC", "::", "SPRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "TPC", "::", "VPRFRegClass", ".", "hasSubClassEq", "(", "RC", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "TPC", "TPC", "TPC::JMPR", "1", "2", "1", "TPC::SP0", "TPC::VP0", "TPC::SPRFRegClass", "TPC::VPRFRegClass" ]

[]

[ "<s>", "tree", "d30v_build_va_list", "(", ")", "{", "tree", "f_arg_ptr", ",", "f_arg_num", ",", "record", ",", "type_decl", ";", "tree", "int_type_node", ";", "record", "=", "make_lang_type", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "int_type_node", "=", "make_signed_type", "(", "INT_TYPE_SIZE", ")", ";", "f_arg_ptr", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_arg_ptr\"", ")", ",", "ptr_type_node", ")", ";", "f_arg_num", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_arg_num\"", ")", ",", "int_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_arg_ptr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_arg_num", ")", "=", "record", ";", "TREE_CHAIN", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_arg_ptr", ";", "TREE_CHAIN", "(", "f_arg_ptr", ")", "=", "f_arg_num", ";", "layout_type", "(", "record", ")", ";", "return", "build_array_type", "(", "record", ",", "build_index_type", "(", "size_zero_node", ")", ")", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", "." ]

[ "d30v", "\"__va_list_tag\"", "\"__va_arg_ptr\"", "\"__va_arg_num\"" ]

[]

[ "<s>", "bool", "aarch_mm_needs_acquire", "(", "rtx", "const_int", ")", "{", "enum", "memmodel", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "const_int", ")", ")", ";", "return", "!", "(", "is_mm_relaxed", "(", "model", ")", "||", "is_mm_consume", "(", "model", ")", "||", "is_mm_release", "(", "model", ")", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "the", "RTX", "representing", "a", "memory", "model", "is", "a", "memory", "model", "that", "needs", "acquire", "semantics", "." ]

[ "arm" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "RC", "->", "getSize", "(", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "vectorize_vec_perm_const_1", "(", "const", "struct", "expand_vec_perm_d", "&", "d", ")", "{", "if", "(", "expand_perm_with_merge", "(", "d", ")", ")", "return", "true", ";", "if", "(", "expand_perm_with_vster", "(", "d", ")", ")", "return", "true", ";", "if", "(", "expand_perm_with_vstbrq", "(", "d", ")", ")", "return", "true", ";", "if", "(", "expand_perm_with_vpdi", "(", "d", ")", ")", "return", "true", ";", "if", "(", "expand_perm_with_rot", "(", "d", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Try", "to", "find", "the", "best", "sequence", "for", "the", "vector", "permute", "operation", "described", "by", "D.", "Return", "true", "if", "the", "operation", "could", "be", "expanded", "." ]

[ "s390" ]

[]

[ "<s>", "static", "bool", "match_auli_pcrel", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "high", ";", "rtx", "unspec", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "SET", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "PLUS", ")", "return", "false", ";", "high", "=", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "high", ")", "!=", "HIGH", "||", "GET_CODE", "(", "XEXP", "(", "high", ",", "0", ")", ")", "!=", "CONST", ")", "return", "false", ";", "unspec", "=", "XEXP", "(", "XEXP", "(", "high", ",", "0", ")", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", "&&", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_PCREL_SYM", ")", ";", "}", "</s>" ]

[ "Returns", "whether", "INSN", "is", "a", "pc-relative", "auli", "insn", "." ]

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

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", ")", "return", "nullptr", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "assert", "(", "Src0Idx", "!=", "-", "1", "&&", "\"Should always have src0 operand\"", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "!", "Src0", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "nullptr", ";", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "if", "(", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "(", "!", "isOperandLegal", "(", "MI", ",", "Src0Idx", ",", "&", "Src1", ")", "||", "!", "isOperandLegal", "(", "MI", ",", "Src1Idx", ",", "&", "Src0", ")", ")", ")", "return", "nullptr", ";", "if", "(", "!", "Src1", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "(", "!", "Src1", ".", "isImm", "(", ")", "&&", "!", "Src1", ".", "isFPImm", "(", ")", ")", "||", "(", "!", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "!", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "hasModifiersSet", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ")", "return", "nullptr", ";", "if", "(", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ")", "{", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "int", "Src0ModsVal", "=", "Src0Mods", "->", "getImm", "(", ")", ";", "if", "(", "!", "Src1Mods", "&&", "Src0ModsVal", "!=", "0", ")", "return", "nullptr", ";", "int", "Src1ModsVal", "=", "Src1Mods", "->", "getImm", "(", ")", ";", "assert", "(", "(", "Src1ModsVal", "==", "0", ")", "&&", "\"Not expecting modifiers with immediates\"", ")", ";", "Src1Mods", "->", "setImm", "(", "Src0ModsVal", ")", ";", "Src0Mods", "->", "setImm", "(", "Src1ModsVal", ")", ";", "}", "unsigned", "Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "Src0", ".", "getSubReg", "(", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "Src0", ".", "ChangeToImmediate", "(", "Src1", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "Src1", ".", "isFPImm", "(", ")", ")", "Src0", ".", "ChangeToFPImmediate", "(", "Src1", ".", "getFPImm", "(", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Should only have immediates\"", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "Src1", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "commuteOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "R600", "SI", "3", "1", "\"Should always have src0 operand\"", "1", "0", "0", "\"Not expecting modifiers with immediates\"", "\"Should only have immediates\"" ]

[]

[ "<s>", "rtx", "spu_const", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "val", ")", "{", "rtx", "inner", ";", "rtvec", "v", ";", "int", "units", ",", "i", ";", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", "return", "immed_double_const", "(", "val", ",", "0", ",", "mode", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "hwint_to_const_double", "(", "mode", ",", "val", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "inner", "=", "immed_double_const", "(", "val", ",", "0", ",", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "else", "inner", "=", "hwint_to_const_double", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "val", ")", ";", "units", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "v", "=", "rtvec_alloc", "(", "units", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "inner", ";", "return", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "v", ")", ";", "}", "</s>" ]

[ "Given", "VAL", ",", "generate", "a", "constant", "appropriate", "for", "MODE", ".", "If", "MODE", "is", "a", "vector", "mode", ",", "every", "element", "will", "be", "VAL", ".", "For", "TImode", ",", "VAL", "will", "be", "zero", "extended", "to", "128", "bits", "." ]

[ "spu", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "TeakInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "unsigned", "NumInserted", "=", "0", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "if", "(", "Cond", ".", "size", "(", ")", ">", "0", ")", "{", "const", "MachineInstrBuilder", "&", "builder", "=", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "Teak", "::", "BRRCond_rel7", ")", ")", ";", "builder", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ";", "NumInserted", "++", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "1", ";", "}", "if", "(", "Cond", ".", "empty", "(", ")", "||", "FBB", ")", "{", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "Teak", "::", "BRR_rel7", ")", ")", ".", "addMBB", "(", "Cond", ".", "empty", "(", ")", "?", "TBB", ":", "FBB", ")", ";", "NumInserted", "++", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "1", ";", "}", "return", "NumInserted", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "0", "0", "0", "Teak::BRRCond_rel7", "0", "1", "Teak::BRR_rel7", "1" ]

[]

[ "<s>", "int", "call_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "call_address_operand", "(", "op", ",", "mode", ")", ";", "}", "</s>" ]

[ "Call", "insn", "on", "SPARC", "can", "take", "a", "PC-relative", "constant", "address", ",", "or", "any", "regular", "memory", "address", "." ]

[ "m32r", "0", "0" ]

[]

[ "<s>", "void", "rs6000_aix_asm_output_dwarf_table_ref", "(", "char", "*", "frame_table_label", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.ref %s\\n\"", ",", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "frame_table_label", ")", ")", ";", "}", "</s>" ]

[ "Issue", "assembly", "directives", "that", "create", "a", "reference", "to", "the", "given", "DWARF", "FRAME_TABLE_LABEL", "from", "the", "current", "function", "section", "." ]

[ "rs6000", "\"\\t.ref %s\\n\"" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "assert", "(", "!", "RegAllocPass", "&&", "\"WebAssembly uses no regalloc!\"", ")", ";", "addRegAllocPasses", "(", "true", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

[ "WebAssembly", "WebAssembly", "\"WebAssembly uses no regalloc!\"" ]

[]

[ "<s>", "static", "bool", "nios2_fpu_compare_enabled", "(", "enum", "rtx_code", "cond", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "switch", "(", "cond", ")", "{", "case", "EQ", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpeqs", ")", ";", "case", "NE", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpnes", ")", ";", "case", "GT", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpgts", ")", ";", "case", "GE", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpges", ")", ";", "case", "LT", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmplts", ")", ";", "case", "LE", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmples", ")", ";", "default", ":", "break", ";", "}", "else", "if", "(", "mode", "==", "DFmode", ")", "switch", "(", "cond", ")", "{", "case", "EQ", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpeqd", ")", ";", "case", "NE", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpned", ")", ";", "case", "GT", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpgtd", ")", ";", "case", "GE", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpged", ")", ";", "case", "LT", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpltd", ")", ";", "case", "LE", ":", "return", "N2FPU_OP_ENABLED_P", "(", "fcmpled", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "COND", "comparison", "for", "mode", "MODE", "is", "enabled", "under", "current", "settings", "." ]

[ "nios2" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "override", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "Sparc", "MVT::i32" ]

[]

[ "<s>", "rtx", "pa_legitimize_reload_address", "(", "rtx", "ad", ",", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "long", "offset", ",", "newoffset", ",", "mask", ";", "rtx", "new_rtx", ",", "temp", "=", "NULL_RTX", ";", "mask", "=", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "!", "INT14_OK_STRICT", "?", "0x1f", ":", "0x3fff", ")", ";", "if", "(", "optimize", "&&", "GET_CODE", "(", "ad", ")", "==", "PLUS", ")", "temp", "=", "simplify_binary_operation", "(", "PLUS", ",", "Pmode", ",", "XEXP", "(", "ad", ",", "0", ")", ",", "XEXP", "(", "ad", ",", "1", ")", ")", ";", "new_rtx", "=", "temp", "?", "temp", ":", "ad", ";", "if", "(", "optimize", "&&", "GET_CODE", "(", "new_rtx", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "new_rtx", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "new_rtx", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "offset", "=", "INTVAL", "(", "XEXP", "(", "(", "new_rtx", ")", ",", "1", ")", ")", ";", "if", "(", "(", "offset", "&", "mask", ")", ">=", "(", "(", "mask", "+", "1", ")", "/", "2", ")", ")", "newoffset", "=", "(", "offset", "&", "~", "mask", ")", "+", "mask", "+", "1", ";", "else", "newoffset", "=", "offset", "&", "~", "mask", ";", "if", "(", "mask", "==", "0x3fff", "&&", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "(", "TARGET_64BIT", "&&", "(", "mode", ")", "==", "DImode", ")", ")", ")", "newoffset", "&=", "~", "(", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ";", "if", "(", "newoffset", "!=", "0", "&&", "VAL_14_BITS_P", "(", "newoffset", ")", ")", "{", "temp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "new_rtx", ",", "0", ")", ",", "GEN_INT", "(", "newoffset", ")", ")", ";", "ad", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp", ",", "GEN_INT", "(", "offset", "-", "newoffset", ")", ")", ";", "push_reload", "(", "XEXP", "(", "ad", ",", "0", ")", ",", "0", ",", "&", "XEXP", "(", "ad", ",", "0", ")", ",", "0", ",", "BASE_REG_CLASS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "ad", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Look", "for", "machine", "dependent", "ways", "to", "make", "the", "invalid", "address", "AD", "a", "valid", "address", ".", "For", "the", "PA", ",", "transform", ":", "memory", "(", "X", "+", "<", "large", "int", ">", ")", "into", ":", "if", "(", "<", "large", "int", ">", "&", "mask", ")", ">", "=", "16", "Y", "=", "(", "<", "large", "int", ">", "&", "~mask", ")", "+", "mask", "+", "1", "Round", "up", ".", "else", "Y", "=", "(", "<", "large", "int", ">", "&", "~mask", ")", "Round", "down", ".", "Z", "=", "X", "+", "Y", "memory", "(", "Z", "+", "(", "<", "large", "int", ">", "-", "Y", ")", ")", ";", "This", "makes", "reload", "inheritance", "and", "reload_cse", "work", "better", "since", "Z", "can", "be", "reused", ".", "There", "may", "be", "more", "opportunities", "to", "improve", "code", "with", "this", "hook", "." ]

[ "pa", "0x1f", "0x3fff", "0", "1", "0", "1", "1", "1", "2", "1", "0x3fff", "1", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI prepare scratch registers\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI prepare scratch registers\"" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "R600Subtarget", "&", "ST", "=", "Fn", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "&", "*", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "R600", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "It", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "&", "MI", ")", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", ".", "dump", "(", ")", ";", "}", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">>", "RemapChan", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "R600::REG_SEQUENCE", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "rtx", "mips_loongson_ext2_prefetch_cookie", "(", "rtx", "write", ",", "rtx", ")", "{", "if", "(", "INTVAL", "(", "write", ")", "==", "1", ")", "return", "GEN_INT", "(", "INTVAL", "(", "write", ")", ")", ";", "if", "(", "INTVAL", "(", "write", ")", "==", "0", ")", "return", "GEN_INT", "(", "INTVAL", "(", "write", ")", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Loongson", "EXT2", "only", "implements", "pref", "hint=0", "(", "prefetch", "for", "load", ")", "and", "hint=1", "(", "prefetch", "for", "store", ")", ",", "other", "hint", "just", "scale", "to", "hint", "=", "0", "and", "hint", "=", "1", "." ]

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

[]

[ "<s>", "bool", "RISCVTTIImpl", "::", "isLoweredToCall", "(", "const", "Function", "*", "F", ")", "{", "if", "(", "F", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.riscv.pulp\"", ")", ")", "return", "false", ";", "return", "BaseT", "::", "isLoweredToCall", "(", "F", ")", ";", "}", "</s>" ]

[ "Test", "whether", "calls", "to", "a", "function", "lower", "to", "actual", "program", "function", "calls", "." ]

[ "RI5CY", "RISCV", "\"llvm.riscv.pulp\"" ]

[]

[ "<s>", "void", "altivec_expand_vec_perm_le", "(", "rtx", "operands", "[", "4", "]", ")", "{", "rtx", "notx", ",", "iorx", ",", "unspec", ";", "rtx", "target", "=", "operands", "[", "0", "]", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "sel", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", "=", "target", ";", "rtx", "norreg", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "!", "REG_P", "(", "op1", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "if", "(", "!", "REG_P", "(", "sel", ")", ")", "sel", "=", "force_reg", "(", "V16QImode", ",", "sel", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", ")", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "TARGET_P9_VECTOR", ")", "{", "unspec", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op0", ",", "op1", ",", "sel", ")", ",", "UNSPEC_VPERMR", ")", ";", "}", "else", "{", "notx", "=", "gen_rtx_NOT", "(", "V16QImode", ",", "sel", ")", ";", "iorx", "=", "(", "TARGET_P8_VECTOR", "?", "gen_rtx_IOR", "(", "V16QImode", ",", "notx", ",", "notx", ")", ":", "gen_rtx_AND", "(", "V16QImode", ",", "notx", ",", "notx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "norreg", ",", "iorx", ")", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op1", ",", "op0", ",", "norreg", ")", ",", "UNSPEC_VPERM", ")", ";", "}", "if", "(", "!", "REG_P", "(", "target", ")", ")", "{", "emit_move_insn", "(", "tmp", ",", "unspec", ")", ";", "unspec", "=", "tmp", ";", "}", "emit_move_insn", "(", "target", ",", "unspec", ")", ";", "}", "</s>" ]

[ "Similarly", "to", "altivec_expand_vec_perm_const_le", ",", "we", "must", "adjust", "the", "permute", "control", "vector", ".", "But", "here", "it", "'s", "not", "a", "constant", ",", "so", "we", "must", "generate", "a", "vector", "NAND", "or", "NOR", "to", "do", "the", "adjustment", "." ]

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

[]

[ "<s>", "static", "bool", "nios2_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "!", "frame_pointer_needed", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_ELIMINATE", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "bool", "arm_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "prev_tree", "=", "target_option_current_node", ";", "tree", "cur_tree", ";", "struct", "cl_target_option", "*", "prev_opt", ";", "struct", "cl_target_option", "*", "cur_opt", ";", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "(", "pop_target", ")", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "cur_tree", "=", "arm_valid_target_attribute_tree", "(", "args", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "cur_tree", "==", "NULL_TREE", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ")", ";", "return", "false", ";", "}", "target_option_current_node", "=", "cur_tree", ";", "arm_configure_build_target", "(", "&", "arm_active_target", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ",", "false", ")", ";", "arm_option_reconfigure_globals", "(", ")", ";", "}", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ";", "gcc_assert", "(", "prev_opt", ")", ";", "gcc_assert", "(", "cur_opt", ")", ";", "if", "(", "cur_opt", "!=", "prev_opt", ")", "{", "cpp_options", "*", "cpp_opts", "=", "cpp_get_options", "(", "parse_in", ")", ";", "unsigned", "char", "saved_warn_unused_macros", "=", "cpp_opts", "->", "warn_unused_macros", ";", "cpp_opts", "->", "warn_unused_macros", "=", "0", ";", "gcc_assert", "(", "cur_opt", "->", "x_target_flags", "==", "target_flags", ")", ";", "tree", "acond_macro", "=", "get_identifier", "(", "\"__ARM_NEON_FP\"", ")", ";", "C_CPP_HASHNODE", "(", "acond_macro", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "acond_macro", "=", "get_identifier", "(", "\"__ARM_FP\"", ")", ";", "C_CPP_HASHNODE", "(", "acond_macro", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "acond_macro", "=", "get_identifier", "(", "\"__ARM_FEATURE_LDREX\"", ")", ";", "C_CPP_HASHNODE", "(", "acond_macro", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "cpp_force_token_locations", "(", "parse_in", ",", "BUILTINS_LOCATION", ")", ";", "arm_cpu_builtins", "(", "parse_in", ")", ";", "cpp_stop_forcing_token_locations", "(", "parse_in", ")", ";", "cpp_opts", "->", "warn_unused_macros", "=", "saved_warn_unused_macros", ";", "arm_reset_previous_fndecl", "(", ")", ";", "if", "(", "cur_tree", "==", "target_option_default_node", ")", "save_restore_target_globals", "(", "cur_tree", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "arch", "custom", "mode", "state", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "arm", "0", "\"__ARM_NEON_FP\"", "\"__ARM_FP\"", "\"__ARM_FEATURE_LDREX\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SIC Del Useless jump\"", ";", "}", "</s>" ]

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

[ "SIC", "\"SIC Del Useless jump\"" ]

[]

[ "<s>", "SDValue", "SNESTargetLowering", "::", "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", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCFunction", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "if", "(", "e", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "unsigned", "RetOpc", "=", "SNESISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "ISD::OutputArg", "16", "1", "4", "1", "0", "\"Can only return in registers!\"", "1", "SNESISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "unsigned", "AMDGPUTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPUISD", "::", "BFE_I32", ":", "{", "ConstantSDNode", "*", "Width", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "Width", ")", "return", "1", ";", "unsigned", "SignBits", "=", "32", "-", "Width", "->", "getZExtValue", "(", ")", "+", "1", ";", "if", "(", "!", "isNullConstant", "(", "Op", ".", "getOperand", "(", "1", ")", ")", ")", "return", "SignBits", ";", "unsigned", "Op0SignBits", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "return", "std", "::", "max", "(", "SignBits", ",", "Op0SignBits", ")", ";", "}", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "Width", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "return", "Width", "?", "32", "-", "(", "Width", "->", "getZExtValue", "(", ")", "&", "0x1f", ")", ":", "1", ";", "}", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "return", "31", ";", "case", "AMDGPUISD", "::", "FP_TO_FP16", ":", "case", "AMDGPUISD", "::", "FP16_ZEXT", ":", "return", "16", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPUISD::BFE_I32", "2", "1", "32", "1", "1", "0", "1", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "1", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "31", "AMDGPUISD::FP_TO_FP16", "AMDGPUISD::FP16_ZEXT", "16", "1" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "CodeGenOpt", "::", "Level", "OptLevel", "=", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "FADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "STI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "PerformSHLCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "UREM", ":", "case", "ISD", "::", "SREM", ":", "return", "PerformREMCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::FADD", "ISD::MUL", "ISD::SHL", "ISD::AND", "ISD::UREM", "ISD::SREM" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "rewriteIntrinsicWithAddressSpace", "(", "IntrinsicInst", "*", "II", ",", "Value", "*", "OldV", ",", "Value", "*", "NewV", ")", "const", "{", "auto", "IntrID", "=", "II", "->", "getIntrinsicID", "(", ")", ";", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "const", "ConstantInt", "*", "IsVolatile", "=", "cast", "<", "ConstantInt", ">", "(", "II", "->", "getArgOperand", "(", "4", ")", ")", ";", "if", "(", "!", "IsVolatile", "->", "isZero", "(", ")", ")", "return", "false", ";", "Module", "*", "M", "=", "II", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "DestTy", "=", "II", "->", "getType", "(", ")", ";", "Type", "*", "SrcTy", "=", "NewV", "->", "getType", "(", ")", ";", "Function", "*", "NewDecl", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "II", "->", "getIntrinsicID", "(", ")", ",", "{", "DestTy", ",", "SrcTy", "}", ")", ";", "II", "->", "setArgOperand", "(", "0", ",", "NewV", ")", ";", "II", "->", "setCalledFunction", "(", "NewDecl", ")", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "amdgcn_is_shared", ":", "case", "Intrinsic", "::", "amdgcn_is_private", ":", "{", "unsigned", "TrueAS", "=", "IntrID", "==", "Intrinsic", "::", "amdgcn_is_shared", "?", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ";", "unsigned", "NewAS", "=", "NewV", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "NewV", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "ConstantInt", "*", "NewVal", "=", "(", "TrueAS", "==", "NewAS", ")", "?", "ConstantInt", "::", "getTrue", "(", "Ctx", ")", ":", "ConstantInt", "::", "getFalse", "(", "Ctx", ")", ";", "II", "->", "replaceAllUsesWith", "(", "NewVal", ")", ";", "II", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Rewrite", "intrinsic", "call", "II", "such", "that", "OldV", "will", "be", "replaced", "with", "NewV", ",", "which", "has", "a", "different", "address", "space", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "4", "Intrinsic::getDeclaration", "0", "Intrinsic::amdgcn_is_shared", "Intrinsic::amdgcn_is_private", "Intrinsic::amdgcn_is_shared", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "nios2_validate_compare", "(", "machine_mode", "mode", ",", "rtx", "*", "cmp", ",", "rtx", "*", "op1", ",", "rtx", "*", "op2", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "*", "cmp", ")", ";", "enum", "rtx_code", "alt_code", ";", "rtx", "alt_op2", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "nios2_validate_fpu_compare", "(", "mode", ",", "cmp", ",", "op1", ",", "op2", ",", "true", ")", ";", "if", "(", "CONST_INT_P", "(", "*", "op2", ")", "&&", "*", "op2", "!=", "const0_rtx", ")", "{", "nios2_alternate_compare_const", "(", "code", ",", "*", "op2", ",", "&", "alt_code", ",", "&", "alt_op2", ",", "mode", ")", ";", "if", "(", "alt_op2", "==", "const0_rtx", ")", "{", "code", "=", "alt_code", ";", "*", "op2", "=", "alt_op2", ";", "goto", "check_rebuild_cmp", ";", "}", "if", "(", "nios2_valid_compare_const_p", "(", "code", ",", "*", "op2", ")", ")", "return", "true", ";", "else", "if", "(", "nios2_valid_compare_const_p", "(", "alt_code", ",", "alt_op2", ")", ")", "{", "code", "=", "alt_code", ";", "*", "op2", "=", "alt_op2", ";", "goto", "rebuild_cmp", ";", "}", "if", "(", "!", "nios2_simple_const_p", "(", "*", "op2", ")", "&&", "nios2_simple_const_p", "(", "alt_op2", ")", ")", "{", "code", "=", "alt_code", ";", "*", "op2", "=", "alt_op2", ";", "}", "*", "op2", "=", "force_reg", "(", "mode", ",", "*", "op2", ")", ";", "}", "else", "if", "(", "!", "reg_or_0_operand", "(", "*", "op2", ",", "mode", ")", ")", "*", "op2", "=", "force_reg", "(", "mode", ",", "*", "op2", ")", ";", "check_rebuild_cmp", ":", "if", "(", "code", "==", "GT", "||", "code", "==", "GTU", "||", "code", "==", "LE", "||", "code", "==", "LEU", ")", "{", "rtx", "t", "=", "*", "op1", ";", "*", "op1", "=", "*", "op2", ";", "*", "op2", "=", "t", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "}", "rebuild_cmp", ":", "*", "cmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "*", "op1", ",", "*", "op2", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Checks", "and", "modifies", "the", "comparison", "in", "*", "CMP", ",", "*", "OP1", ",", "and", "*", "OP2", "into", "valid", "nios2", "supported", "form", ".", "Returns", "true", "if", "success", "." ]

[ "nios2" ]

[]

[ "<s>", "bool", "GBZ80SectionData", "::", "get", "(", "StringRef", "Specifier", ",", "GBZ80SectionData", "&", "Data", ")", "{", "Data", ".", "Type", "=", "ST_NONE", ";", "Data", ".", "Address", "=", "0", ";", "Data", ".", "Bank", "=", "~", "0U", ";", "Data", ".", "Alignment", "=", "1", ";", "return", "false", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

[ "GBZ80", "GB", "GB", "0", "0U", "1" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "os16", "(", ")", ")", "addPass", "(", "createMipsOs16Pass", "(", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "inMips16HardFloat", "(", ")", ")", "addPass", "(", "createMips16HardFloatPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "assert", "(", "0", "&&", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SDIV", ":", "return", "LowerSDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SREM", ":", "return", "LowerSREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

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

[ "R600", "0", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SDIV", "ISD::SREM", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::BRCOND", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::STORE", "ISD::UDIVREM", "ISD::UINT_TO_FP" ]

[]

[ "<s>", "static", "int", "try_constant_tricks", "(", "long", "value", ",", "int", "*", "x", ",", "int", "*", "y", ")", "{", "int", "i", ";", "unsigned", "bit", ",", "shf", ",", "rot", ";", "if", "(", "const_ok_for_mcore", "(", "value", ")", ")", "return", "1", ";", "if", "(", "TARGET_HARDLIT", ")", "{", "if", "(", "const_ok_for_mcore", "(", "~", "value", ")", ")", "{", "*", "x", "=", "~", "value", ";", "return", "2", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<=", "32", ";", "i", "++", ")", "{", "if", "(", "const_ok_for_mcore", "(", "value", "-", "i", ")", ")", "{", "*", "x", "=", "value", "-", "i", ";", "*", "y", "=", "i", ";", "return", "3", ";", "}", "if", "(", "const_ok_for_mcore", "(", "value", "+", "i", ")", ")", "{", "*", "x", "=", "value", "+", "i", ";", "*", "y", "=", "i", ";", "return", "4", ";", "}", "}", "bit", "=", "0x80000000L", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "31", ";", "i", "++", ")", "{", "if", "(", "const_ok_for_mcore", "(", "i", "-", "value", ")", ")", "{", "*", "x", "=", "i", "-", "value", ";", "*", "y", "=", "i", ";", "return", "5", ";", "}", "if", "(", "const_ok_for_mcore", "(", "value", "&", "~", "bit", ")", ")", "{", "*", "y", "=", "bit", ";", "*", "x", "=", "value", "&", "~", "bit", ";", "return", "6", ";", "}", "if", "(", "const_ok_for_mcore", "(", "value", "|", "bit", ")", ")", "{", "*", "y", "=", "~", "bit", ";", "*", "x", "=", "value", "|", "bit", ";", "return", "7", ";", "}", "bit", ">>=", "1", ";", "}", "shf", "=", "value", ";", "rot", "=", "value", ";", "for", "(", "i", "=", "1", ";", "i", "<", "31", ";", "i", "++", ")", "{", "int", "c", ";", "c", "=", "rot", "<<", "31", ";", "rot", ">>=", "1", ";", "rot", "&=", "0x7FFFFFFF", ";", "rot", "|=", "c", ";", "if", "(", "const_ok_for_mcore", "(", "rot", ")", ")", "{", "*", "y", "=", "i", ";", "*", "x", "=", "rot", ";", "return", "8", ";", "}", "if", "(", "shf", "&", "1", ")", "shf", "=", "0", ";", "shf", ">>=", "1", ";", "if", "(", "shf", "!=", "0", "&&", "const_ok_for_mcore", "(", "shf", ")", ")", "{", "*", "y", "=", "i", ";", "*", "x", "=", "shf", ";", "return", "9", ";", "}", "}", "if", "(", "(", "value", "%", "3", ")", "==", "0", "&&", "const_ok_for_mcore", "(", "value", "/", "3", ")", ")", "{", "*", "x", "=", "value", "/", "3", ";", "return", "10", ";", "}", "if", "(", "(", "value", "%", "5", ")", "==", "0", "&&", "const_ok_for_mcore", "(", "value", "/", "5", ")", ")", "{", "*", "x", "=", "value", "/", "5", ";", "return", "11", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Try", "tricks", "to", "load", "a", "constant", "inline", "and", "return", "the", "trick", "number", "if", "success", "(", "0", "is", "non-inlinable", ")", ".", "0", ":", "not", "inlinable", "1", ":", "single", "instruction", "(", "do", "the", "usual", "thing", ")", "2", ":", "single", "insn", "followed", "by", "a", "'not", "'", "3", ":", "single", "insn", "followed", "by", "a", "subi", "4", ":", "single", "insn", "followed", "by", "an", "addi", "5", ":", "single", "insn", "followed", "by", "rsubi", "6", ":", "single", "insn", "followed", "by", "bseti", "7", ":", "single", "insn", "followed", "by", "bclri", "8", ":", "single", "insn", "followed", "by", "rotli", "9", ":", "single", "insn", "followed", "by", "lsli", "10", ":", "single", "insn", "followed", "by", "ixh", "11", ":", "single", "insn", "followed", "by", "ixw", "." ]

[ "mcore", "1", "2", "1", "32", "3", "4", "0x80000000L", "0", "31", "5", "6", "7", "1", "1", "31", "31", "1", "0x7FFFFFFF", "8", "1", "0", "1", "0", "9", "3", "0", "3", "3", "10", "5", "0", "5", "5", "11", "0" ]

[]

[ "<s>", "void", "MetadataStreamer", "::", "end", "(", ")", "{", "std", "::", "string", "HSAMetadataString", ";", "if", "(", "toString", "(", "HSAMetadata", ",", "HSAMetadataString", ")", ")", "return", ";", "if", "(", "DumpHSAMetadata", ")", "dump", "(", "HSAMetadataString", ")", ";", "if", "(", "VerifyHSAMetadata", ")", "verify", "(", "HSAMetadataString", ")", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "SCC", "&&", "SrcReg", "!=", "AMDGPU", "::", "SCC", ")", ";", "if", "(", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "AMDGPU", "::", "VReg_32RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "VReg_32RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "assert", "(", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "DestReg", ")", ")", ";", "assert", "(", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "R600", "SI" ]

[]

[ "<s>", "void", "AArch64InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AArch64", "::", "TLSDESCCALL", ")", "{", "O", "<<", "\"\\t.tlsdesccall \"", "<<", "*", "MI", "->", "getOperand", "(", "0", ")", ".", "getExpr", "(", ")", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::TLSDESCCALL", "\"\\t.tlsdesccall \"", "0" ]

[]

[ "<s>", "void", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "override", "{", "}", "</s>" ]

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

[ "SPIRV" ]

[]

[ "<s>", "bool", "PatmosSinglePathInfo", "::", "isEnabled", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "PatmosSinglePathInfo", "::", "isEnabled", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "enable", "flag", ";", "'+", "'", "." ]

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

[]