Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "TargetTransformInfo", "X86TargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "X86TTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

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

[]

[ "<s>", "void", "NVPTXRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "NVPTX", "::", "VRFrame", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "NVPTX::VRFrame", "1" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasReservedCallFrame", "(", "MF", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasPreallocatedCall", "(", ")", "||", "(", "hasFP", "(", "MF", ")", "&&", "!", "TRI", "->", "hasStackRealignment", "(", "MF", ")", ")", "||", "TRI", "->", "hasBasePointer", "(", "MF", ")", ";", "}", "</s>" ]

[ "canSimplifyCallFramePseudos", "-", "If", "there", "is", "a", "reserved", "call", "frame", ",", "the", "call", "frame", "pseudos", "can", "be", "simplified", "." ]

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

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", ">", "&", "Patterns", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "Aggressive", ")", "return", "false", ";", "if", "(", "getFMAPatterns", "(", "Root", ",", "Patterns", ")", ")", "return", "true", ";", "return", "TargetInstrInfo", "::", "getMachineCombinerPatterns", "(", "Root", ",", "Patterns", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "inline", "bool", "libcall_hasher", "::", "equal", "(", "const", "value_type", "*", "p1", ",", "const", "compare_type", "*", "p2", ")", "{", "return", "rtx_equal_p", "(", "p1", ",", "p2", ")", ";", "}", "</s>" ]

[ "Compare", "H1", "and", "H2", "for", "equivalence", "." ]

[ "arm" ]

[]

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

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

[ "CAHP", "CAHP", "\"Unhandled expression!\"", "0" ]

[]

[ "<s>", "static", "bool", "arm_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "machine_mode", "mode", ";", "if", "(", "size", "==", "UNITS_PER_WORD", "&&", "aligned_p", ")", "{", "fputs", "(", "\"\\t.word\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "if", "(", "NEED_GOT_RELOC", "&&", "flag_pic", "&&", "making_const_table", "&&", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ")", "{", "if", "(", "!", "arm_pic_data_is_text_relative", "||", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ")", "fputs", "(", "\"(GOT)\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"(GOTOFF)\"", ",", "asm_out_file", ")", ";", "}", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "arm_vector_mode_supported_p", "(", "mode", ")", ")", "{", "int", "i", ",", "units", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", ";", "units", "=", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ")", "{", "rtx", "elt", "=", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ";", "assemble_integer", "(", "elt", ",", "size", ",", "i", "==", "0", "?", "BIGGEST_ALIGNMENT", ":", "size", "*", "BITS_PER_UNIT", ",", "1", ")", ";", "}", "else", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ")", "{", "rtx", "elt", "=", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ";", "REAL_VALUE_TYPE", "rval", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "rval", ",", "elt", ")", ";", "assemble_real", "(", "rval", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "i", "==", "0", "?", "BIGGEST_ALIGNMENT", ":", "size", "*", "BITS_PER_UNIT", ")", ";", "}", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "ARM", "version", "needs", "to", "handle", "word-sized", "values", "specially", "." ]

[ "arm", "\"\\t.word\\t\"", "\"(GOT)\"", "\"(GOTOFF)\"", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "AARCH64_SPECULATION_HARDENING_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "run", "(", "Controls", "&", "F", ",", "Controls", "&", "R", ")", "{", "if", "(", "!", "route", "(", "Order", ".", "data", "(", ")", ",", "Table", ".", "data", "(", ")", ",", "size", "(", ")", ",", "0", ")", ")", "return", "false", ";", "getControls", "(", "F", ",", "0", ",", "Forward", ")", ";", "getControls", "(", "R", ",", "Log", ",", "Reverse", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

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

[]

[ "<s>", "static", "addr_space_t", "avr_nonconst_pointer_addrspace", "(", "tree", "typ", ")", "{", "while", "(", "ARRAY_TYPE", "==", "TREE_CODE", "(", "typ", ")", ")", "typ", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "typ", ")", ")", "{", "addr_space_t", "as", ";", "tree", "target", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "FUNCTION_TYPE", "==", "TREE_CODE", "(", "target", ")", ")", "return", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "target", ")", ")", ";", "while", "(", "TREE_CODE", "(", "target", ")", "==", "ARRAY_TYPE", ")", "target", "=", "TREE_TYPE", "(", "target", ")", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "target", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", "&&", "(", "!", "TYPE_READONLY", "(", "target", ")", "||", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", "||", "(", "!", "AVR_HAVE_LPM", "&&", "avr_addrspace", "[", "as", "]", ".", "pointer_size", ">", "2", ")", ")", ")", "{", "return", "as", ";", "}", "return", "avr_nonconst_pointer_addrspace", "(", "target", ")", ";", "}", "return", "ADDR_SPACE_GENERIC", ";", "}", "</s>" ]

[ "Scan", "type", "TYP", "for", "pointer", "references", "to", "address", "space", "ASn", ".", "Return", "ADDR_SPACE_GENERIC", "(", "i.e", ".", "0", ")", "if", "all", "pointers", "targeting", "the", "AS", "are", "also", "declared", "to", "be", "CONST", ".", "Otherwise", ",", "return", "the", "respective", "address", "space", ",", "i.e", ".", "a", "value", "!", "=", "0", "." ]

[ "avr", "2" ]

[]

[ "<s>", "bool", "csky_legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "tls_unspec_mentioned_p", "(", "x", ")", ")", "return", "true", ";", "if", "(", "csky_symbol_mentioned_p", "(", "x", ")", "||", "csky_label_mentioned_p", "(", "x", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "LEGITIMATE_PIC_OPERAND_P", "." ]

[ "csky" ]

[]

[ "<s>", "const", "char", "*", "Cpu0AsmPrinter", "::", "getCurrentABIString", "(", ")", "const", "{", "switch", "(", "Subtarget", "->", "getTargetABI", "(", ")", ")", "{", "case", "Cpu0Subtarget", "::", "O32", ":", "return", "\"abi32\"", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown Cpu0 ABI\"", ")", ";", ";", "}", "}", "</s>" ]

[ "Emit", "Set", "directives", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "\"abi32\"", "\"Unknown Cpu0 ABI\"" ]

[]

[ "<s>", "BitVector", "BPFRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "BPF", "::", "R10", ")", ";", "Reserved", ".", "set", "(", "BPF", "::", "R11", ")", ";", "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", "." ]

[ "BPF", "BPF", "BPF::R10", "BPF::R11" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isSplatValueForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "APInt", "&", "UndefElts", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "NumElts", "=", "DemandedElts", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "X86ISD", "::", "VBROADCAST", ":", "case", "X86ISD", "::", "VBROADCAST_LOAD", ":", "UndefElts", "=", "APInt", "::", "getNullValue", "(", "NumElts", ")", ";", "return", "true", ";", "}", "return", "TargetLowering", "::", "isSplatValueForTargetNode", "(", "Op", ",", "DemandedElts", ",", "UndefElts", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "vector", "Op", "has", "the", "same", "value", "across", "all", "DemandedElts", ",", "indicating", "any", "elements", "which", "may", "be", "undef", "in", "the", "output", "UndefElts", "." ]

[ "X86", "X86", "X86ISD::VBROADCAST", "X86ISD::VBROADCAST_LOAD" ]

[]

[ "<s>", "bool", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "override", "{", "assert", "(", "DirectiveID", ".", "getKind", "(", ")", "==", "AsmToken", "::", "Identifier", ")", ";", "auto", "&", "Out", "=", "getStreamer", "(", ")", ";", "auto", "&", "TOut", "=", "reinterpret_cast", "<", "WebAssemblyTargetStreamer", "&", ">", "(", "*", "Out", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".type\"", ")", "{", "if", "(", "!", "(", "IsNext", "(", "AsmToken", "::", "Identifier", ")", "&&", "IsNext", "(", "AsmToken", "::", "Comma", ")", "&&", "IsNext", "(", "AsmToken", "::", "At", ")", "&&", "Lexer", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", ")", "return", "Error", "(", "\"Expected label,@type declaration, got: \"", ",", "Lexer", ".", "getTok", "(", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "else", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".param\"", "||", "DirectiveID", ".", "getString", "(", ")", "==", "\".local\"", ")", "{", "std", "::", "vector", "<", "MVT", ">", "Params", ";", "std", "::", "vector", "<", "MVT", ">", "Locals", ";", "while", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "auto", "RegType", "=", "ParseRegType", "(", "Lexer", ".", "getTok", "(", ")", ".", "getString", "(", ")", ")", ";", "if", "(", "RegType", "==", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ")", "return", "true", ";", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".param\"", ")", "{", "Params", ".", "push_back", "(", "RegType", ")", ";", "}", "else", "{", "Locals", ".", "push_back", "(", "RegType", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "!", "IsNext", "(", "AsmToken", "::", "Comma", ")", ")", "break", ";", "}", "assert", "(", "LastLabel", ")", ";", "TOut", ".", "emitParam", "(", "LastLabel", ",", "Params", ")", ";", "TOut", ".", "emitLocal", "(", "Locals", ")", ";", "}", "else", "{", "while", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "Expect", "(", "AsmToken", "::", "EndOfStatement", ",", "\"EOL\"", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\".type\"", "\"Expected label,@type declaration, got: \"", "\".param\"", "\".local\"", "MVT::INVALID_SIMPLE_VALUE_TYPE", "\".param\"", "\"EOL\"" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "if", "(", "IsLittleEndian", "&&", "Size", "==", "4", "&&", "isMicroMips", "(", "STI", ")", ")", "{", "EmitInstruction", "(", "Val", ">>", "16", ",", "2", ",", "STI", ",", "OS", ")", ";", "EmitInstruction", "(", "Val", ",", "2", ",", "STI", ",", "OS", ")", ";", "}", "else", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "8", ":", "(", "Size", "-", "1", "-", "i", ")", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "4", "Mips", "16", "2", "2", "0", "8", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isLegalFLATOffset", "(", "int64_t", "Offset", ",", "unsigned", "AddrSpace", ",", "uint64_t", "FlatVariant", ")", "const", "{", "if", "(", "!", "ST", ".", "hasFlatInstOffsets", "(", ")", ")", "return", "false", ";", "if", "(", "ST", ".", "hasFlatSegmentOffsetBug", "(", ")", "&&", "FlatVariant", "==", "SIInstrFlags", "::", "FLAT", "&&", "(", "AddrSpace", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", ")", "return", "false", ";", "bool", "Signed", "=", "FlatVariant", "!=", "SIInstrFlags", "::", "FLAT", ";", "if", "(", "ST", ".", "hasNegativeScratchOffsetBug", "(", ")", "&&", "FlatVariant", "==", "SIInstrFlags", "::", "FlatScratch", ")", "Signed", "=", "false", ";", "if", "(", "ST", ".", "hasNegativeUnalignedScratchOffsetBug", "(", ")", "&&", "FlatVariant", "==", "SIInstrFlags", "::", "FlatScratch", "&&", "Offset", "<", "0", "&&", "(", "Offset", "%", "4", ")", "!=", "0", ")", "{", "return", "false", ";", "}", "unsigned", "N", "=", "AMDGPU", "::", "getNumFlatOffsetBits", "(", "ST", ",", "Signed", ")", ";", "return", "Signed", "?", "isIntN", "(", "N", ",", "Offset", ")", ":", "isUIntN", "(", "N", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "if", "Offset", "is", "legal", "for", "the", "subtarget", "as", "the", "offset", "to", "a", "FLAT", "encoded", "instruction", "." ]

[ "AMDGPU", "SI", "SIInstrFlags::FLAT", "AMDGPU", "AMDGPU", "SIInstrFlags::FLAT", "SIInstrFlags::FlatScratch", "SIInstrFlags::FlatScratch", "0", "4", "0", "AMDGPU::getNumFlatOffsetBits" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"IA64 (Itanium) Bundling Pass\"", ";", "}", "</s>" ]

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

[ "IA64", "\"IA64 (Itanium) Bundling Pass\"" ]

[]

[ "<s>", "static", "const", "char", "*", "ix86_mangle_type", "(", "const_tree", "type", ")", "{", "type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "VOID_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "BOOLEAN_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "INTEGER_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "REAL_TYPE", ")", "return", "NULL", ";", "if", "(", "type", "==", "float128_type_node", "||", "type", "==", "float64x_type_node", ")", "return", "NULL", ";", "switch", "(", "TYPE_MODE", "(", "type", ")", ")", "{", "case", "E_BFmode", ":", "return", "\"DF16b\"", ";", "case", "E_HFmode", ":", "return", "\"DF16_\"", ";", "case", "E_TFmode", ":", "return", "\"g\"", ";", "case", "E_XFmode", ":", "return", "\"e\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

[ "Return", "the", "mangling", "of", "TYPE", "if", "it", "is", "an", "extended", "fundamental", "type", "." ]

[ "i386", "\"DF16b\"", "\"DF16_\"", "\"g\"", "\"e\"" ]

[]

[ "<s>", "bool", "X86ATTAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "this", "->", "MF", "=", "&", "MF", ";", "unsigned", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "if", "(", "CC", "==", "CallingConv", "::", "X86_StdCall", "||", "CC", "==", "CallingConv", "::", "X86_FastCall", ")", "FunctionInfoMap", "[", "F", "]", "=", "*", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "if", "(", "F", "->", "hasDLLExportLinkage", "(", ")", ")", "DLLExportedFns", ".", "insert", "(", "Mang", "->", "makeNameProper", "(", "F", "->", "getName", "(", ")", ",", "\"\"", ")", ")", ";", "emitFunctionHeader", "(", "MF", ")", ";", "if", "(", "TAI", "->", "doesSupportDebugInformation", "(", ")", "||", "TAI", "->", "doesSupportExceptionHandling", "(", ")", ")", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "bool", "hasAnyRealCode", "=", "false", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "pred_empty", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ",", "VerboseAsm", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "IE", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "IE", ";", "++", "II", ")", "{", "if", "(", "!", "II", "->", "isLabel", "(", ")", ")", "hasAnyRealCode", "=", "true", ";", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", "&&", "!", "hasAnyRealCode", ")", "{", "O", "<<", "\"\\tnop\\n\"", ";", "}", "if", "(", "TAI", "->", "hasDotTypeDotSizeDirective", "(", ")", ")", "O", "<<", "\"\\t.size\\t\"", "<<", "CurrentFnName", "<<", "\", .-\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "if", "(", "TAI", "->", "doesSupportDebugInformation", "(", ")", ")", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "O", ".", "flush", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"\\n\\n\"", "X86", "X86", "X86", "\"\"", "\"\\tnop\\n\"", "\"\\t.size\\t\"", "\", .-\"" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ")", "const", "{", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "Arg", ".", "hasPassPointeeByValueCopyAttr", "(", ")", ")", "return", "false", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArgInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArgInfo", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArgInfo", ",", "SplitArgInfos", ",", "MF", ")", ";", "Idx", "++", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "8", "0" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::X3", "PPC::R3" ]

[]

[ "<s>", "static", "void", "aarch64_pragma_aarch64", "(", "cpp_reader", "*", ")", "{", "tree", "x", ";", "if", "(", "pragma_lex", "(", "&", "x", ")", "!=", "CPP_STRING", ")", "{", "error", "(", "\"%<#pragma GCC aarch64%> requires a string parameter\"", ")", ";", "return", ";", "}", "const", "char", "*", "name", "=", "TREE_STRING_POINTER", "(", "x", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\"arm_sve.h\"", ")", "==", "0", ")", "aarch64_sve", "::", "handle_arm_sve_h", "(", ")", ";", "else", "if", "(", "strcmp", "(", "name", ",", "\"arm_neon.h\"", ")", "==", "0", ")", "handle_arm_neon_h", "(", ")", ";", "else", "if", "(", "strcmp", "(", "name", ",", "\"arm_acle.h\"", ")", "==", "0", ")", "handle_arm_acle_h", "(", ")", ";", "else", "error", "(", "\"unknown %<#pragma GCC aarch64%> option %qs\"", ",", "name", ")", ";", "}", "</s>" ]

[ "Implement", "``", "#", "pragma", "GCC", "aarch64", "''", "." ]

[ "aarch64", "\"%<#pragma GCC aarch64%> requires a string parameter\"", "\"arm_sve.h\"", "0", "aarch64_sve::handle_arm_sve_h", "\"arm_neon.h\"", "0", "\"arm_acle.h\"", "0", "\"unknown %<#pragma GCC aarch64%> option %qs\"" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "(", "!", "IsMemset", "||", "ZeroMemset", ")", "&&", "!", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "!", "Subtarget", "->", "isUnalignedMem16Slow", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", ")", "{", "if", "(", "Size", ">=", "32", ")", "{", "if", "(", "Subtarget", "->", "hasInt256", "(", ")", ")", "return", "MVT", "::", "v8i32", ";", "if", "(", "Subtarget", "->", "hasFp256", "(", ")", ")", "return", "MVT", "::", "v8f32", ";", "}", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "32", "MVT::v8i32", "MVT::v8f32", "MVT::v4i32", "MVT::v4f32", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "void", "xstormy16_expand_casesi", "(", "rtx", "index", ",", "rtx", "lower_bound", ",", "rtx", "range", ",", "rtx", "table", ",", "rtx", "default_label", ")", "{", "HOST_WIDE_INT", "range_i", "=", "INTVAL", "(", "range", ")", ";", "rtx", "int_index", ";", "if", "(", "range_i", ">=", "8192", ")", "sorry", "(", "\"switch statement of size %lu entries too large\"", ",", "(", "unsigned", "long", ")", "range_i", ")", ";", "index", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "index", ",", "lower_bound", ",", "NULL_RTX", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ";", "emit_cmp_and_jump_insns", "(", "index", ",", "range", ",", "GTU", ",", "NULL_RTX", ",", "SImode", ",", "1", ",", "default_label", ")", ";", "int_index", "=", "gen_lowpart_common", "(", "HImode", ",", "index", ")", ";", "emit_insn", "(", "gen_ashlhi3", "(", "int_index", ",", "int_index", ",", "const2_rtx", ")", ")", ";", "emit_jump_insn", "(", "gen_tablejump_pcrel", "(", "int_index", ",", "table", ")", ")", ";", "}", "</s>" ]

[ "Expander", "for", "the", "`", "casesi", "'", "pattern", ".", "INDEX", "is", "the", "index", "of", "the", "switch", "statement", ".", "LOWER_BOUND", "is", "a", "CONST_INT", "that", "is", "the", "value", "of", "INDEX", "corresponding", "to", "the", "first", "table", "entry", ".", "RANGE", "is", "the", "number", "of", "table", "entries", ".", "TABLE", "is", "an", "ADDR_VEC", "that", "is", "the", "jump", "table", ".", "DEFAULT_LABEL", "is", "the", "address", "to", "branch", "to", "if", "INDEX", "is", "outside", "the", "range", "LOWER_BOUND", "to", "LOWER_BOUND+RANGE-1", "." ]

[ "stormy16", "8192", "\"switch statement of size %lu entries too large\"", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips OptimizePICCall\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips OptimizePICCall\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "SystemZXPLINK64Registers", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_SystemZ_XPLINK64_RegMask", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZXPLINK64Registers::getCallPreservedMask", "SystemZ" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"CSKY Constant Islands\"", ";", "}", "</s>" ]

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

[ "CSKY", "\"CSKY Constant Islands\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "AArch64RegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "AArch64", "::", "FlagClassRegClass", ")", "return", "&", "AArch64", "::", "GPR64RegClass", ";", "return", "RC", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::FlagClassRegClass", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "X86RegisterInfo", "*", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", "->", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "TRI", "->", "getGPRsForTailCall", "(", "*", "MF", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "switch", "(", "MBBI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETL", ":", "case", "X86", "::", "RETQ", ":", "case", "X86", "::", "RETIL", ":", "case", "X86", "::", "RETIQ", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", "&&", "CS", "!=", "X86", "::", "RIP", "&&", "CS", "!=", "X86", "::", "RSP", "&&", "CS", "!=", "X86", "::", "ESP", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "X86", "0", "0", "0", "X86::RET", "X86::RETL", "X86::RETQ", "X86::RETIL", "X86::RETIQ", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "X86::RIP", "X86::RSP", "X86::ESP", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "LowerADD", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::ADD" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "&", "SIFixVGPRCopiesID", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "SIOptimizeExecMaskingID", ")", ";", "TargetPassConfig", "::", "addPostRegAlloc", "(", ")", ";", "addPass", "(", "&", "SILowerSGPRSpillsID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "IA64InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "IA64", "::", "FPRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "STF_SPILL", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "IA64", "::", "GRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "ST8", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "IA64", "::", "PRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "MOV", ")", ",", "IA64", "::", "r2", ")", ".", "addReg", "(", "IA64", "::", "r0", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "CADDIMM22", ")", ",", "IA64", "::", "r2", ")", ".", "addReg", "(", "IA64", "::", "r2", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "IA64", "::", "ST8", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "IA64", "::", "r2", ")", ";", "}", "else", "assert", "(", "0", "&&", "\"sorry, I don't know how to store this sort of reg in the stack\\n\"", ")", ";", "}", "</s>" ]

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

[ "IA64", "IA64", "IA64::FPRegisterClass", "IA64::STF_SPILL", "IA64::GRRegisterClass", "IA64::ST8", "IA64::PRRegisterClass", "IA64::MOV", "IA64::r2", "IA64::r0", "IA64::CADDIMM22", "IA64::r2", "IA64::r2", "1", "IA64::ST8", "IA64::r2", "0", "\"sorry, I don't know how to store this sort of reg in the stack\\n\"" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "if", "(", "DarwinDirective", "==", "PPC", "::", "DIR_440", ")", "return", "false", ";", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_CRITICAL", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "if", "(", "isPPC64", "(", ")", ")", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "G8RCRegClass", ")", ";", "else", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "return", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC::DIR_440", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass" ]

[]

[ "<s>", "static", "bool", "r10k_safe_mem_expr_p", "(", "tree", "expr", ",", "unsigned", "HOST_WIDE_INT", "offset", ")", "{", "poly_int64", "bitoffset", ",", "bitsize", ";", "tree", "inner", ",", "var_offset", ";", "machine_mode", "mode", ";", "int", "unsigned_p", ",", "reverse_p", ",", "volatile_p", ";", "inner", "=", "get_inner_reference", "(", "expr", ",", "&", "bitsize", ",", "&", "bitoffset", ",", "&", "var_offset", ",", "&", "mode", ",", "&", "unsigned_p", ",", "&", "reverse_p", ",", "&", "volatile_p", ")", ";", "if", "(", "!", "DECL_P", "(", "inner", ")", "||", "!", "DECL_SIZE_UNIT", "(", "inner", ")", "||", "var_offset", ")", "return", "false", ";", "offset", "+=", "bitoffset", "/", "BITS_PER_UNIT", ";", "return", "offset", "<", "tree_to_uhwi", "(", "DECL_SIZE_UNIT", "(", "inner", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "MEM", "with", "MEM_EXPR", "EXPR", "and", "MEM_OFFSET", "OFFSET", "is", "an", "in-range", "access", "to", "an", "automatic", "variable", ",", "or", "to", "an", "object", "with", "a", "link-time-constant", "address", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "MBlazeAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "SMLoc", "ErrorLoc", ";", "unsigned", "ErrorInfo", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_ConversionFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unable to convert operands to instruction\"", ")", ";", "case", "Match_InvalidOperand", ":", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MBlazeOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "\"unable to convert operands to instruction\"", "0U", "\"too few operands for instruction\"", "MBlaze", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "ia64_expand_widen_sum", "(", "rtx", "operands", "[", "3", "]", ",", "bool", "unsignedp", ")", "{", "machine_mode", "wmode", ";", "rtx", "l", ",", "h", ",", "t", ",", "sign", ";", "sign", "=", "ia64_unpack_sign", "(", "operands", "[", "1", "]", ",", "unsignedp", ")", ";", "wmode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "l", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "h", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "ia64_unpack_assemble", "(", "l", ",", "operands", "[", "1", "]", ",", "sign", ",", "false", ")", ";", "ia64_unpack_assemble", "(", "h", ",", "operands", "[", "1", "]", ",", "sign", ",", "true", ")", ";", "t", "=", "expand_binop", "(", "wmode", ",", "add_optab", ",", "l", ",", "operands", "[", "2", "]", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "t", "=", "expand_binop", "(", "wmode", ",", "add_optab", ",", "h", ",", "t", ",", "operands", "[", "0", "]", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "t", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "t", ")", ";", "}", "</s>" ]

[ "Emit", "an", "integral", "vector", "widening", "sum", "operations", "." ]

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

[]

[ "<s>", "static", "void", "nios2_asm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "if", "(", "flag_pic", ")", "nios2_load_pic_register", "(", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIRST_ARG_REGNO", "+", "1", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIRST_ARG_REGNO", ")", ";", "nios2_emit_add_constant", "(", "this_rtx", ",", "delta", ")", ";", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "nios2_emit_add_constant", "(", "tmp", ",", "vcall_offset", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "nios2_adjust_call_address", "(", "&", "funexp", ",", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall_internal", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_MI_THUNK", "." ]

[ "nios2", "1", "1", "2", "1", "0", "2", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "expand_set_or_movmem_via_rep", "(", "rtx", "destmem", ",", "rtx", "srcmem", ",", "rtx", "destptr", ",", "rtx", "srcptr", ",", "rtx", "value", ",", "rtx", "orig_value", ",", "rtx", "count", ",", "machine_mode", "mode", ",", "bool", "issetmem", ")", "{", "rtx", "destexp", ";", "rtx", "srcexp", ";", "rtx", "countreg", ";", "HOST_WIDE_INT", "rounded_count", ";", "if", "(", "mode", "==", "QImode", "&&", "CONST_INT_P", "(", "count", ")", "&&", "!", "(", "INTVAL", "(", "count", ")", "&", "3", ")", "&&", "(", "!", "issetmem", "||", "orig_value", "==", "const0_rtx", ")", ")", "mode", "=", "SImode", ";", "if", "(", "destptr", "!=", "XEXP", "(", "destmem", ",", "0", ")", "||", "GET_MODE", "(", "destmem", ")", "!=", "BLKmode", ")", "destmem", "=", "adjust_automodify_address_nv", "(", "destmem", ",", "BLKmode", ",", "destptr", ",", "0", ")", ";", "countreg", "=", "ix86_zero_extend_to_Pmode", "(", "scale_counter", "(", "count", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "if", "(", "mode", "!=", "QImode", ")", "{", "destexp", "=", "gen_rtx_ASHIFT", "(", "Pmode", ",", "countreg", ",", "GEN_INT", "(", "exact_log2", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ";", "destexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "destexp", ",", "destptr", ")", ";", "}", "else", "destexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "destptr", ",", "countreg", ")", ";", "if", "(", "(", "!", "issetmem", "||", "orig_value", "==", "const0_rtx", ")", "&&", "CONST_INT_P", "(", "count", ")", ")", "{", "rounded_count", "=", "(", "INTVAL", "(", "count", ")", "&", "~", "(", "(", "HOST_WIDE_INT", ")", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ")", ";", "destmem", "=", "shallow_copy_rtx", "(", "destmem", ")", ";", "set_mem_size", "(", "destmem", ",", "rounded_count", ")", ";", "}", "else", "if", "(", "MEM_SIZE_KNOWN_P", "(", "destmem", ")", ")", "clear_mem_size", "(", "destmem", ")", ";", "if", "(", "issetmem", ")", "{", "value", "=", "force_reg", "(", "mode", ",", "gen_lowpart", "(", "mode", ",", "value", ")", ")", ";", "emit_insn", "(", "gen_rep_stos", "(", "destptr", ",", "countreg", ",", "destmem", ",", "value", ",", "destexp", ")", ")", ";", "}", "else", "{", "if", "(", "srcptr", "!=", "XEXP", "(", "srcmem", ",", "0", ")", "||", "GET_MODE", "(", "srcmem", ")", "!=", "BLKmode", ")", "srcmem", "=", "adjust_automodify_address_nv", "(", "srcmem", ",", "BLKmode", ",", "srcptr", ",", "0", ")", ";", "if", "(", "mode", "!=", "QImode", ")", "{", "srcexp", "=", "gen_rtx_ASHIFT", "(", "Pmode", ",", "countreg", ",", "GEN_INT", "(", "exact_log2", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ";", "srcexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "srcexp", ",", "srcptr", ")", ";", "}", "else", "srcexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "srcptr", ",", "countreg", ")", ";", "if", "(", "CONST_INT_P", "(", "count", ")", ")", "{", "rounded_count", "=", "(", "INTVAL", "(", "count", ")", "&", "~", "(", "(", "HOST_WIDE_INT", ")", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ")", ";", "srcmem", "=", "shallow_copy_rtx", "(", "srcmem", ")", ";", "set_mem_size", "(", "srcmem", ",", "rounded_count", ")", ";", "}", "else", "{", "if", "(", "MEM_SIZE_KNOWN_P", "(", "srcmem", ")", ")", "clear_mem_size", "(", "srcmem", ")", ";", "}", "emit_insn", "(", "gen_rep_mov", "(", "destptr", ",", "destmem", ",", "srcptr", ",", "srcmem", ",", "countreg", ",", "destexp", ",", "srcexp", ")", ")", ";", "}", "}", "</s>" ]

[ "Output", "``", "rep", ";", "mov", "''", "or", "``", "rep", ";", "stos", "''", "instruction", "depending", "on", "ISSETMEM", "argument", ".", "When", "ISSETMEM", "is", "true", ",", "arguments", "SRCMEM", "and", "SRCPTR", "are", "ignored", ".", "When", "ISSETMEM", "is", "false", ",", "arguments", "VALUE", "and", "ORIG_VALUE", "are", "ignored", ".", "For", "setmem", "case", ",", "VALUE", "is", "a", "promoted", "to", "a", "wider", "size", "ORIG_VALUE", ".", "ORIG_VALUE", "is", "the", "original", "value", "passed", "to", "memset", "to", "fill", "the", "memory", "with", ".", "Other", "arguments", "have", "same", "meaning", "as", "for", "previous", "function", "." ]

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

[]

[ "<s>", "static", "rtx", "s390_got_symbol", "(", "void", ")", "{", "if", "(", "!", "got_symbol", ")", "{", "got_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "SYMBOL_REF_FLAGS", "(", "got_symbol", ")", "=", "SYMBOL_FLAG_LOCAL", ";", "}", "return", "got_symbol", ";", "}", "</s>" ]

[ "Return", "the", "GOT", "table", "symbol", ".", "The", "symbol", "will", "be", "created", "when", "the", "function", "is", "invoked", "for", "the", "first", "time", "." ]

[ "s390", "\"_GLOBAL_OFFSET_TABLE_\"" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "RISCV", "::", "SB", ":", "case", "RISCV", "::", "SH", ":", "case", "RISCV", "::", "SW", ":", "case", "RISCV", "::", "FSW", ":", "case", "RISCV", "::", "SD", ":", "case", "RISCV", "::", "FSD", ":", "case", "RISCV", "::", "VSE_V_um", ":", "break", ";", "}", "if", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VSE_V_um", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "}", "else", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "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", "." ]

[ "RISCV", "RISCV", "0", "RISCV::SB", "RISCV::SH", "RISCV::SW", "RISCV::FSW", "RISCV::SD", "RISCV::FSD", "RISCV::VSE_V_um", "RISCV::VSE_V_um", "0", "0", "1", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "static", "void", "aarch64_restore_callee_saves", "(", "machine_mode", "mode", ",", "poly_int64", "start_offset", ",", "unsigned", "start", ",", "unsigned", "limit", ",", "bool", "skip_wb", ",", "rtx", "*", "cfi_ops", ")", "{", "rtx", "base_rtx", "=", "stack_pointer_rtx", ";", "unsigned", "regno", ";", "unsigned", "regno2", ";", "poly_int64", "offset", ";", "for", "(", "regno", "=", "aarch64_next_callee_save", "(", "start", ",", "limit", ")", ";", "regno", "<=", "limit", ";", "regno", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno", "]", ")", "continue", ";", "rtx", "reg", ",", "mem", ";", "int", "offset_diff", ";", "if", "(", "skip_wb", "&&", "(", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "||", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ")", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "regno2", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ";", "offset_diff", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", "-", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "if", "(", "regno2", "<=", "limit", "&&", "!", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno2", "]", "&&", "known_eq", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "offset_diff", ")", ")", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "rtx", "mem2", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "mem2", "=", "gen_frame_mem", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "emit_insn", "(", "aarch64_gen_load_pair", "(", "mode", ",", "reg", ",", "mem", ",", "reg2", ",", "mem2", ")", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg2", ",", "*", "cfi_ops", ")", ";", "regno", "=", "regno2", ";", "}", "else", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "*", "cfi_ops", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "the", "callee", "registers", "of", "mode", "MODE", "from", "register", "number", "START", "up", "to", "and", "including", "LIMIT", ".", "Restore", "from", "the", "stack", "offset", "START_OFFSET", ",", "skipping", "any", "write-back", "candidates", "if", "SKIP_WB", "is", "true", ".", "Write", "the", "appropriate", "REG_CFA_RESTORE", "notes", "into", "CFI_OPS", "." ]

[ "aarch64", "1", "1" ]

[]

[ "<s>", "unsigned", "MipsFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "unsigned", "Op1", ")", "{", "if", "(", "MachineInstOpcode", "==", "Mips", "::", "MUL", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "II", ".", "getNumDefs", "(", ")", ")", ";", "Op1", "=", "constrainOperandRegClass", "(", "II", ",", "Op1", ",", "II", ".", "getNumDefs", "(", ")", "+", "1", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ".", "addReg", "(", "Mips", "::", "HI0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ".", "addReg", "(", "Mips", "::", "LO0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "return", "ResultReg", ";", "}", "return", "FastISel", "::", "fastEmitInst_rr", "(", "MachineInstOpcode", ",", "RC", ",", "Op0", ",", "Op1", ")", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "two", "register", "operands", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

[ "Mips", "Mips", "Mips::MUL", "1", "Mips::HI0", "Mips::LO0" ]

[]

[ "<s>", "void", "SystemZAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSzOS", "(", ")", ")", "{", "MCContext", "&", "OutContext", "=", "OutStreamer", "->", "getContext", "(", ")", ";", "std", "::", "string", "N", "(", "MF", "->", "getFunction", "(", ")", ".", "hasName", "(", ")", "?", "Twine", "(", "MF", "->", "getFunction", "(", ")", ".", "getName", "(", ")", ")", ".", "concat", "(", "\"_\"", ")", ".", "str", "(", ")", ":", "\"\"", ")", ";", "CurrentFnEPMarkerSym", "=", "OutContext", ".", "createTempSymbol", "(", "Twine", "(", "\"EPM_\"", ")", ".", "concat", "(", "N", ")", ".", "str", "(", ")", ",", "true", ")", ";", "CurrentFnPPA1Sym", "=", "OutContext", ".", "createTempSymbol", "(", "Twine", "(", "\"PPA1_\"", ")", ".", "concat", "(", "N", ")", ".", "str", "(", ")", ",", "true", ")", ";", "const", "MachineFrameInfo", "&", "MFFrame", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "bool", "IsUsingAlloca", "=", "MFFrame", ".", "hasVarSizedObjects", "(", ")", ";", "uint8_t", "Flags", "=", "0", ";", "if", "(", "IsUsingAlloca", ")", "Flags", "|=", "0x04", ";", "uint32_t", "DSASize", "=", "MFFrame", ".", "getStackSize", "(", ")", ";", "uint32_t", "DSAAndFlags", "=", "DSASize", "&", "0xFFFFFFE0", ";", "DSAAndFlags", "|=", "Flags", ";", "OutStreamer", "->", "AddComment", "(", "\"XPLINK Routine Layout Entry\"", ")", ";", "OutStreamer", "->", "emitLabel", "(", "CurrentFnEPMarkerSym", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"Eyecatcher 0x00C300C500C500\"", ")", ";", "OutStreamer", "->", "emitIntValueInHex", "(", "0x00C300C500C500", ",", "7", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"Mark Type C'1'\"", ")", ";", "OutStreamer", "->", "emitInt8", "(", "0xF1", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"Offset to PPA1\"", ")", ";", "OutStreamer", "->", "emitAbsoluteSymbolDiff", "(", "CurrentFnPPA1Sym", ",", "CurrentFnEPMarkerSym", ",", "4", ")", ";", "if", "(", "OutStreamer", "->", "isVerboseAsm", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"DSA Size 0x\"", "+", "Twine", "::", "utohexstr", "(", "DSASize", ")", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"Entry Flags\"", ")", ";", "if", "(", "Flags", "&", "0x04", ")", "OutStreamer", "->", "AddComment", "(", "\" Bit 2: 1 = Uses alloca\"", ")", ";", "else", "OutStreamer", "->", "AddComment", "(", "\" Bit 2: 0 = Does not use alloca\"", ")", ";", "}", "OutStreamer", "->", "emitInt32", "(", "DSAAndFlags", ")", ";", "}", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"_\"", "\"\"", "\"EPM_\"", "\"PPA1_\"", "0", "0x04", "0xFFFFFFE0", "\"XPLINK Routine Layout Entry\"", "\"Eyecatcher 0x00C300C500C500\"", "0x00C300C500C500", "7", "\"Mark Type C'1'\"", "0xF1", "\"Offset to PPA1\"", "4", "\"DSA Size 0x\"", "\"Entry Flags\"", "0x04", "\" Bit 2: 1 = Uses alloca\"", "\" Bit 2: 0 = Does not use alloca\"" ]

[]

[ "<s>", "unsigned", "ARCompactRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "ARC", "::", "BLINK", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "ARCompact", "ARC", "ARC::BLINK" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "createTPCPostMachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "TPC", "TPC" ]

[]

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

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

[ "PowerPC", "0" ]

[]

[ "<s>", "static", "bool", "ix86_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "bool", "ret", "=", "false", ";", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "if", "(", "!", "callee_tree", ")", "ret", "=", "true", ";", "else", "if", "(", "!", "caller_tree", ")", "ret", "=", "false", ";", "else", "{", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "if", "(", "(", "caller_opts", "->", "x_ix86_isa_flags", "&", "callee_opts", "->", "x_ix86_isa_flags", ")", "!=", "callee_opts", "->", "x_ix86_isa_flags", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "x_target_flags", "!=", "callee_opts", "->", "x_target_flags", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "arch", "!=", "callee_opts", "->", "arch", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "tune", "!=", "callee_opts", "->", "tune", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "x_ix86_fpmath", "!=", "callee_opts", "->", "x_ix86_fpmath", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "branch_cost", "!=", "callee_opts", "->", "branch_cost", ")", "ret", "=", "false", ";", "else", "ret", "=", "true", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "determine", "if", "one", "function", "can", "safely", "inline", "another", "." ]

[ "i386" ]

[]

[ "<s>", "static", "inline", "tree", "def_builtin_const", "(", "HOST_WIDE_INT", "mask", ",", "HOST_WIDE_INT", "mask2", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "def_builtin", "(", "mask", ",", "mask2", ",", "name", ",", "tcode", ",", "code", ")", ";", "if", "(", "decl", ")", "TREE_READONLY", "(", "decl", ")", "=", "1", ";", "else", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "const_p", "=", "true", ";", "return", "decl", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "also", "marks", "the", "function", "as", "``", "const", "''", "." ]

[ "i386", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SIFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "MBB", ".", "erase", "(", "I", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "assert", "(", "isUInt", "<", "32", ">", "(", "Amount", ")", "&&", "\"exceeded stack address space size\"", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Register", "SPReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "Amount", "*=", "getScratchScaleFactor", "(", "ST", ")", ";", "if", "(", "IsDestroy", ")", "Amount", "=", "-", "Amount", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_I32", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "llvm_unreachable", "(", "\"is this used?\"", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "0", "SI", "1", "0", "32", "\"exceeded stack address space size\"", "SI", "SI", "AMDGPU::S_ADD_I32", "0", "\"is this used?\"" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "DL", "=", "CLI", ".", "DL", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "if", "(", "CallConv", "!=", "CallingConv", "::", "C", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "if", "(", "CLI", ".", "IsTailCall", "||", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support tail call yet\"", ")", ";", "if", "(", "CLI", ".", "IsPatchPoint", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support patch point yet\"", ")", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "bool", "IsStructRet", "=", "(", "Outs", ".", "empty", "(", ")", ")", "?", "false", ":", "Outs", "[", "0", "]", ".", "Flags", ".", "isSRet", "(", ")", ";", "if", "(", "IsStructRet", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support struct return yet\"", ")", ";", "if", "(", "Outs", ".", "size", "(", ")", ">", "1", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support more than 1 returned value yet\"", ")", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "IsVarArg", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support varargs yet\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "unsigned", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "auto", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "auto", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "PtrVT", ",", "true", ")", ";", "auto", "NB", "=", "DAG", ".", "getConstant", "(", "NumBytes", ",", "DL", ",", "PtrVT", ",", "true", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "NB", ",", "DL", ")", ";", "SmallVector", "<", "SDValue", ",", "16", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "Ops", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "SmallVector", "<", "EVT", ",", "8", ">", "Tys", ";", "for", "(", "const", "auto", "&", "In", ":", "Ins", ")", "Tys", ".", "push_back", "(", "In", ".", "VT", ")", ";", "Tys", ".", "push_back", "(", "MVT", "::", "Other", ")", ";", "SDVTList", "TyList", "=", "DAG", ".", "getVTList", "(", "Tys", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "CALL", ",", "DL", ",", "TyList", ",", "Ops", ")", ";", "if", "(", "Ins", ".", "empty", "(", ")", ")", "{", "Chain", "=", "Res", ";", "}", "else", "{", "InVals", ".", "push_back", "(", "Res", ")", ";", "Chain", "=", "Res", ".", "getValue", "(", "1", ")", ";", "}", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "NB", ",", "Zero", ",", "SDValue", "(", ")", ",", "DL", ")", ";", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "WebAssembly", "WebAssembly", "\"WebAssembly doesn't support non-C calling conventions\"", "\"WebAssembly doesn't support tail call yet\"", "\"WebAssembly doesn't support patch point yet\"", "ISD::OutputArg", "0", "\"WebAssembly doesn't support struct return yet\"", "1", "\"WebAssembly doesn't support more than 1 returned value yet\"", "ISD::InputArg", "\"WebAssembly doesn't support varargs yet\"", "16", "0", "16", "8", "MVT::Other", "WebAssemblyISD::CALL", "1" ]

[]

[ "<s>", "InstructionCost", "HexagonTTIImpl", "::", "getScalarizationOverhead", "(", "VectorType", "*", "Ty", ",", "const", "APInt", "&", "DemandedElts", ",", "bool", "Insert", ",", "bool", "Extract", ")", "{", "return", "BaseT", "::", "getScalarizationOverhead", "(", "Ty", ",", "DemandedElts", ",", "Insert", ",", "Extract", ")", ";", "}", "</s>" ]

[ "Estimate", "the", "overhead", "of", "scalarizing", "an", "instruction", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "int", "iq2000_initial_elimination_offset", "(", "int", "from", ",", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "int", "offset", ";", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "(", "from", ")", "==", "FRAME_POINTER_REGNUM", ")", "(", "offset", ")", "=", "0", ";", "else", "if", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", ")", "(", "offset", ")", "=", "(", "cfun", "->", "machine", "->", "total_size", ")", ";", "else", "if", "(", "(", "from", ")", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", "{", "if", "(", "leaf_function_p", "(", ")", ")", "(", "offset", ")", "=", "0", ";", "else", "(", "offset", ")", "=", "cfun", "->", "machine", "->", "gp_sp_offset", "+", "(", "(", "UNITS_PER_WORD", "-", "(", "POINTER_SIZE", "/", "BITS_PER_UNIT", ")", ")", "*", "(", "BYTES_BIG_ENDIAN", "!=", "0", ")", ")", ";", "}", "return", "offset", ";", "}", "</s>" ]

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

[ "iq2000", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "ia64_gen_spec_check", "(", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "label", ",", "ds_t", "ds", ")", "{", "rtx", "op1", ",", "pat", ",", "check_pat", ";", "gen_func_t", "gen_check", ";", "int", "mode_no", ";", "mode_no", "=", "get_mode_no_for_insn", "(", "insn", ")", ";", "gcc_assert", "(", "mode_no", ">=", "0", ")", ";", "if", "(", "label", ")", "op1", "=", "label", ";", "else", "{", "gcc_assert", "(", "!", "ia64_needs_block_p", "(", "ds", ")", ")", ";", "op1", "=", "copy_rtx", "(", "recog_data", ".", "operand", "[", "1", "]", ")", ";", "}", "gen_check", "=", "get_spec_check_gen_function", "(", "ds", ",", "mode_no", ",", "label", "==", "NULL_RTX", ",", "true", ")", ";", "check_pat", "=", "gen_check", "(", "copy_rtx", "(", "recog_data", ".", "operand", "[", "0", "]", ")", ",", "op1", ")", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "check_pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "copy_rtx", "(", "COND_EXEC_TEST", "(", "pat", ")", ")", ",", "check_pat", ")", ";", "return", "check_pat", ";", "}", "</s>" ]

[ "Generate", "(", "or", "regenerate", ")", "a", "recovery", "check", "for", "INSN", "." ]

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

[]

[ "<s>", "void", "UnwindOpcodeAssembler", "::", "EmitSetSP", "(", "uint16_t", "Reg", ")", "{", "EmitInt8", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_SET_VSP", "|", "Reg", ")", ";", "}", "</s>" ]

[ "Emit", "unwind", "opcodes", "to", "copy", "address", "from", "source", "register", "to", "$", "sp", "." ]

[ "ARM", "ARM::EHABI" ]

[]

[ "<s>", "int", "get_sequence_length", "(", "rtx_insn", "*", "insns", ")", "{", "rtx_insn", "*", "insn", ";", "int", "length", ";", "for", "(", "insn", "=", "insns", ",", "length", "=", "0", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "length", "+=", "get_attr_length", "(", "insn", ")", ";", "return", "length", ";", "}", "</s>" ]

[ "Obtain", "the", "length", "sequence", "of", "insns", "." ]

[ "avr", "0" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"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", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "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", "\"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::FrameIndex", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::UDIVREM", "ISD::UINT_TO_FP" ]

[]

[ "<s>", "void", "MipsFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "int", "FPOffset", "=", "MipsFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MipsFI", "->", "getRAStackOffset", "(", ")", ";", "unsigned", "NewReg", "=", "0", ";", "int", "NewImm", "=", "0", ";", "bool", "ATUsed", "=", "false", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "ATUsed", "=", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "FPOffset", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "LW", ")", ",", "Mips", "::", "FP", ")", ".", "addImm", "(", "NewImm", ")", ".", "addReg", "(", "NewReg", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "}", "if", "(", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "RAOffset", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "LW", ")", ",", "Mips", "::", "RA", ")", ".", "addImm", "(", "NewImm", ")", ".", "addReg", "(", "NewReg", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "}", "if", "(", "NumBytes", ")", "{", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "NumBytes", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "NewReg", ")", ".", "addImm", "(", "NewImm", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "0", "Mips::ADDu", "Mips::SP", "Mips::FP", "Mips::ZERO", "Mips::SP", "Mips::LW", "Mips::FP", "Mips::ATMACRO", "Mips::SP", "Mips::LW", "Mips::RA", "Mips::ATMACRO", "Mips::SP", "Mips::ADDiu", "Mips::SP", "Mips::ATMACRO" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FMul", ")", "return", "true", ";", "if", "(", "!", "I", "->", "hasOneUse", "(", ")", ")", "return", "true", ";", "Instruction", "*", "User", "=", "I", "->", "user_back", "(", ")", ";", "if", "(", "!", "(", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FSub", "||", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FAdd", ")", ")", "return", "true", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "const", "Function", "*", "F", "=", "I", "->", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "F", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "Type", "*", "Ty", "=", "User", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "return", "!", "(", "isFMAFasterThanFMulAndFAdd", "(", "*", "F", ",", "Ty", ")", "&&", "isOperationLegalOrCustom", "(", "ISD", "::", "FMA", ",", "getValueType", "(", "DL", ",", "Ty", ")", ")", "&&", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "AArch64", "AArch64", "0", "ISD::FMA" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MF", ".", "hasMSInlineAsm", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getForceFramePointer", "(", ")", "||", "MMI", ".", "callsUnwindInit", "(", ")", "||", "MMI", ".", "callsEHReturn", "(", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

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

[]

[ "<s>", "static", "void", "mips_for_each_saved_gpr_and_fpr", "(", "HOST_WIDE_INT", "sp_offset", ",", "mips_save_restore_fn", "fn", ")", "{", "machine_mode", "fpr_mode", ";", "int", "regno", ";", "const", "struct", "mips_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "HOST_WIDE_INT", "offset", ";", "unsigned", "int", "mask", ";", "offset", "=", "frame", "->", "gp_sp_offset", "-", "sp_offset", ";", "mask", "=", "frame", "->", "mask", ";", "if", "(", "TARGET_MICROMIPS", ")", "umips_build_save_restore", "(", "fn", ",", "&", "mask", ",", "&", "offset", ")", ";", "for", "(", "regno", "=", "GP_REG_LAST", ";", "regno", ">=", "GP_REG_FIRST", ";", "regno", "--", ")", "if", "(", "BITSET_P", "(", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "{", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", "cfun", "->", "machine", "->", "frame", ".", "ra_fp_offset", "=", "offset", "+", "sp_offset", ";", "mips_save_restore_reg", "(", "word_mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "fp_sp_offset", "-", "sp_offset", ";", "fpr_mode", "=", "(", "TARGET_SINGLE_FLOAT", "?", "SFmode", ":", "DFmode", ")", ";", "for", "(", "regno", "=", "FP_REG_LAST", "-", "MAX_FPRS_PER_FMT", "+", "1", ";", "regno", ">=", "FP_REG_FIRST", ";", "regno", "-=", "MAX_FPRS_PER_FMT", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "fmask", ",", "regno", "-", "FP_REG_FIRST", ")", ")", "{", "if", "(", "!", "TARGET_FLOAT64", "&&", "TARGET_DOUBLE_FLOAT", "&&", "(", "fixed_regs", "[", "regno", "]", "||", "fixed_regs", "[", "regno", "+", "1", "]", ")", ")", "{", "if", "(", "fixed_regs", "[", "regno", "]", ")", "mips_save_restore_reg", "(", "SFmode", ",", "regno", "+", "1", ",", "offset", ",", "fn", ")", ";", "else", "mips_save_restore_reg", "(", "SFmode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "}", "else", "mips_save_restore_reg", "(", "fpr_mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "GET_MODE_SIZE", "(", "fpr_mode", ")", ";", "}", "}", "</s>" ]

[ "Call", "FN", "for", "each", "register", "that", "is", "saved", "by", "the", "current", "function", ".", "SP_OFFSET", "is", "the", "offset", "of", "the", "current", "stack", "pointer", "from", "the", "start", "of", "the", "frame", "." ]

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

[]

[ "<s>", "inline", "bool", "vgpr_1reg_mode_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", "||", "mode", "==", "HImode", "||", "mode", "==", "HFmode", "||", "mode", "==", "QImode", "||", "mode", "==", "BImode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "valid", "for", "1", "VGPR", "register", "." ]

[ "gcn" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "SetupMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "CurrentFnDescSym", "=", "getSymbol", "(", "&", "MF", ".", "getFunction", "(", ")", ")", ";", "MCSectionXCOFF", "*", "FnDescSec", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getXCOFFSection", "(", "CurrentFnDescSym", "->", "getName", "(", ")", ",", "XCOFF", "::", "XMC_DS", ",", "XCOFF", "::", "XTY_SD", ",", "XCOFF", "::", "C_HIDEXT", ",", "SectionKind", "::", "getData", "(", ")", ")", ";", "cast", "<", "MCSymbolXCOFF", ">", "(", "CurrentFnDescSym", ")", "->", "setContainingCsect", "(", "FnDescSec", ")", ";", "return", "AsmPrinter", "::", "SetupMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

[ "This", "should", "be", "called", "when", "a", "new", "MachineFunction", "is", "being", "processed", "from", "runOnMachineFunction", "." ]

[ "PowerPC", "PPC" ]

[]

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

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

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

[]

[ "<s>", "void", "SITargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "{", "reservePrivateMemoryRegs", "(", "getTargetMachine", "(", ")", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "}", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ")", ";", "if", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", "!=", "AMDGPU", "::", "SP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SP_REG", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getScratchRSrcReg", "(", ")", "!=", "AMDGPU", "::", "PRIVATE_RSRC_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "PRIVATE_RSRC_REG", ",", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getFrameOffsetReg", "(", ")", "!=", "AMDGPU", "::", "FP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "FP_REG", ",", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "Info", "->", "limitOccupancy", "(", "MF", ")", ";", "if", "(", "ST", ".", "isWave32", "(", ")", "&&", "!", "MF", ".", "empty", "(", ")", ")", "{", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "TII", "->", "fixImplicitOperands", "(", "MI", ")", ";", "}", "}", "}", "if", "(", "ST", ".", "needsAlignedVGPRs", "(", ")", ")", "{", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "Register", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClassOrNull", "(", "Reg", ")", ";", "if", "(", "!", "RC", ")", "continue", ";", "int", "NewClassID", "=", "getAlignedAGPRClassID", "(", "RC", "->", "getID", "(", ")", ")", ";", "if", "(", "NewClassID", "!=", "-", "1", ")", "MRI", ".", "setRegClass", "(", "Reg", ",", "TRI", "->", "getRegClass", "(", "NewClassID", ")", ")", ";", "}", "}", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "}", "</s>" ]

[ "Execute", "target", "specific", "actions", "to", "finalize", "target", "lowering", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::SP_REG", "AMDGPU::SP_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::FP_REG", "AMDGPU::FP_REG", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "output_move_quad", "(", "rtx", "*", "operands", ")", "{", "if", "(", "REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "{", "switch", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ")", "{", "case", "REG", ":", "output_asm_insn", "(", "\"ldm%(ia%)\\t%m1, %M0\"", ",", "operands", ")", ";", "break", ";", "case", "LABEL_REF", ":", "case", "CONST", ":", "output_asm_insn", "(", "\"adr%?\\t%0, %1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldm%(ia%)\\t%0, %M0\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "rtx", "ops", "[", "2", "]", ";", "int", "dest", ",", "src", ",", "i", ";", "gcc_assert", "(", "REG_P", "(", "operands", "[", "1", "]", ")", ")", ";", "dest", "=", "REGNO", "(", "operands", "[", "0", "]", ")", ";", "src", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "dest", "<", "src", ")", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "ops", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "dest", "+", "i", ")", ";", "ops", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "src", "+", "i", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%0, %1\"", ",", "ops", ")", ";", "}", "else", "for", "(", "i", "=", "3", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "ops", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "dest", "+", "i", ")", ";", "ops", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "src", "+", "i", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%0, %1\"", ",", "ops", ")", ";", "}", "}", "}", "else", "{", "gcc_assert", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", ";", "gcc_assert", "(", "REG_P", "(", "operands", "[", "1", "]", ")", ")", ";", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "switch", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ")", "{", "case", "REG", ":", "output_asm_insn", "(", "\"stm%(ia%)\\t%m0, %M1\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "perform", "a", "quadword", "move", "insn", "with", "operands", "OPERANDS", "." ]

[ "arm", "0", "1", "1", "0", "\"ldm%(ia%)\\t%m1, %M0\"", "\"adr%?\\t%0, %1\"", "\"ldm%(ia%)\\t%0, %M0\"", "2", "1", "0", "1", "0", "4", "0", "1", "\"mov%?\\t%0, %1\"", "3", "0", "0", "1", "\"mov%?\\t%0, %1\"", "0", "1", "1", "0", "0", "0", "\"stm%(ia%)\\t%m0, %M1\"", "\"\"" ]

[]

[ "<s>", "long", "compute_frame_size", "(", "int", "size", ")", "{", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "size", "+=", "(", "1", "*", "UNITS_PER_WORD", ")", ";", "xtensa_current_frame_size", "=", "XTENSA_STACK_ALIGN", "(", "size", "+", "current_function_outgoing_args_size", "+", "(", "WINDOW_SIZE", "*", "UNITS_PER_WORD", ")", ")", ";", "return", "xtensa_current_frame_size", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

[ "xtensa", "1" ]

[]

[ "<s>", "rtx", "sh_try_omit_signzero_extend", "(", "rtx", "extended_op", ",", "rtx_insn", "*", "insn", ")", "{", "if", "(", "REG_P", "(", "extended_op", ")", ")", "extended_op", "=", "extended_op", ";", "else", "if", "(", "GET_CODE", "(", "extended_op", ")", "==", "SUBREG", "&&", "REG_P", "(", "SUBREG_REG", "(", "extended_op", ")", ")", ")", "extended_op", "=", "SUBREG_REG", "(", "extended_op", ")", ";", "else", "return", "NULL_RTX", ";", "if", "(", "GET_MODE", "(", "extended_op", ")", "!=", "SImode", ")", "return", "NULL_RTX", ";", "set_of_reg", "s", "=", "sh_find_set_of_reg", "(", "extended_op", ",", "insn", ",", "prev_nonnote_nondebug_insn_bb", ")", ";", "if", "(", "s", ".", "set_src", "==", "NULL_RTX", ")", "return", "NULL_RTX", ";", "if", "(", "t_reg_operand", "(", "s", ".", "set_src", ",", "VOIDmode", ")", "||", "negt_reg_operand", "(", "s", ".", "set_src", ",", "VOIDmode", ")", ")", "return", "extended_op", ";", "else", "if", "(", "sh_is_logical_t_store_expr", "(", "s", ".", "set_src", ",", "s", ".", "insn", ")", ")", "return", "extended_op", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Given", "the", "operand", "that", "is", "extended", "in", "a", "sign/zero", "extend", "insn", ",", "and", "the", "insn", ",", "try", "to", "figure", "out", "whether", "the", "sign/zero", "extension", "can", "be", "replaced", "by", "a", "simple", "reg-reg", "copy", ".", "If", "so", ",", "the", "replacement", "reg", "rtx", "is", "returned", ",", "NULL_RTX", "otherwise", "." ]

[ "sh" ]

[]

[ "<s>", "FastISel", "*", "MipsTargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "const", "{", "const", "MipsTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "funcInfo", ".", "MF", "->", "getTarget", "(", ")", ")", ";", "bool", "UseFastISel", "=", "TM", ".", "Options", ".", "EnableFastISel", "&&", "Subtarget", ".", "hasMips32", "(", ")", "&&", "!", "Subtarget", ".", "hasMips32r6", "(", ")", "&&", "!", "Subtarget", ".", "inMips16Mode", "(", ")", "&&", "!", "Subtarget", ".", "inMicroMipsMode", "(", ")", ";", "if", "(", "!", "TM", ".", "isPositionIndependent", "(", ")", "||", "!", "TM", ".", "getABI", "(", ")", ".", "IsO32", "(", ")", "||", "LargeGOT", ")", "UseFastISel", "=", "false", ";", "return", "UseFastISel", "?", "Mips", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ":", "nullptr", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::createFastISel" ]

[]

[ "<s>", "bool", "isGlobal", "(", ")", "const", "{", "return", "Kind", "==", "MachineOperand", "::", "MO_GlobalAddress", ";", "}", "</s>" ]

[ "isGlobal", "-", "Tests", "if", "this", "is", "a", "MO_GlobalAddress", "operand", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Immed", ")", "const", "{", "if", "(", "(", "Immed", ">>", "12", ")", "==", "0", "||", "(", "(", "Immed", "&", "0xfff", ")", "==", "0", "&&", "Immed", ">>", "24", "==", "0", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "AArch64", "AArch64", "12", "0", "0xfff", "0", "24", "0" ]

[]

[ "<s>", "static", "sbitmap", "rs6000_get_separate_components", "(", "void", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "WORLD_SAVE_P", "(", "info", ")", ")", "return", "NULL", ";", "if", "(", "TARGET_SPE_ABI", ")", "return", "NULL", ";", "sbitmap", "components", "=", "sbitmap_alloc", "(", "32", ")", ";", "bitmap_clear", "(", "components", ")", ";", "gcc_assert", "(", "!", "(", "info", "->", "savres_strategy", "&", "SAVE_MULTIPLE", ")", "&&", "!", "(", "info", "->", "savres_strategy", "&", "REST_MULTIPLE", ")", ")", ";", "if", "(", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_GPRS", ")", ")", "{", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "int", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_gp_reg_save", ";", "regno", "<", "32", ";", "regno", "++", ")", "{", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", "&&", "rs6000_reg_live_or_pic_offset_p", "(", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "offset", "+=", "reg_size", ";", "}", "}", "if", "(", "frame_pointer_needed", ")", "bitmap_clear_bit", "(", "components", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "||", "(", "flag_pic", "==", "1", "&&", "DEFAULT_ABI", "==", "ABI_V4", ")", "||", "(", "flag_pic", "&&", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", ")", "bitmap_clear_bit", "(", "components", ",", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "info", "->", "lr_save_p", "&&", "!", "(", "flag_pic", "&&", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_VRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_VRS", ")", ")", "{", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "bitmap_set_bit", "(", "components", ",", "0", ")", ";", "}", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS", "." ]

[ "rs6000", "32", "4", "8", "32", "0x8000", "0x7fff", "1", "0x8000", "0x7fff", "0" ]

[]

[ "<s>", "static", "bool", "sh_pass_in_reg_p", "(", "const", "CUMULATIVE_ARGS", "&", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "return", "(", "(", "type", "==", "0", "||", "(", "!", "TREE_ADDRESSABLE", "(", "type", ")", "&&", "(", "!", "(", "TARGET_HITACHI", "||", "cum", ".", "renesas_abi", ")", "||", "!", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "(", "!", "TARGET_FPU_ANY", "&&", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "GET_MODE_SIZE", "(", "SFmode", ")", ")", ")", ")", ")", ")", ")", "&&", "!", "cum", ".", "force_mem", "&&", "(", "TARGET_SH2E", "?", "(", "(", "mode", ")", "==", "BLKmode", "?", "(", "(", "cum", ".", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "*", "UNITS_PER_WORD", "+", "int_size_in_bytes", "(", "type", ")", ")", "<=", "NPARM_REGS", "(", "SImode", ")", "*", "UNITS_PER_WORD", ")", ":", "(", "(", "sh_round_reg", "(", "cum", ",", "mode", ")", "+", "sh_hard_regno_nregs", "(", "BASE_ARG_REG", "(", "mode", ")", ",", "mode", ")", ")", "<=", "NPARM_REGS", "(", "mode", ")", ")", ")", ":", "sh_round_reg", "(", "cum", ",", "mode", ")", "<", "NPARM_REGS", "(", "mode", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "arg", "of", "the", "specified", "mode", "should", "be", "be", "passed", "in", "a", "register", "or", "false", "otherwise", "." ]

[ "sh", "0" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "RISCVISD", "::", "RET_FLAG", ":", "return", "\"RISCVISD::RET_FLAG\"", ";", "case", "RISCVISD", "::", "URET_FLAG", ":", "return", "\"RISCVISD::URET_FLAG\"", ";", "case", "RISCVISD", "::", "SRET_FLAG", ":", "return", "\"RISCVISD::SRET_FLAG\"", ";", "case", "RISCVISD", "::", "MRET_FLAG", ":", "return", "\"RISCVISD::MRET_FLAG\"", ";", "case", "RISCVISD", "::", "CALL", ":", "return", "\"RISCVISD::CALL\"", ";", "case", "RISCVISD", "::", "SELECT_CC", ":", "return", "\"RISCVISD::SELECT_CC\"", ";", "case", "RISCVISD", "::", "BuildPairF64", ":", "return", "\"RISCVISD::BuildPairF64\"", ";", "case", "RISCVISD", "::", "SplitF64", ":", "return", "\"RISCVISD::SplitF64\"", ";", "case", "RISCVISD", "::", "TAIL", ":", "return", "\"RISCVISD::TAIL\"", ";", "case", "RISCVISD", "::", "SLLW", ":", "return", "\"RISCVISD::SLLW\"", ";", "case", "RISCVISD", "::", "SRAW", ":", "return", "\"RISCVISD::SRAW\"", ";", "case", "RISCVISD", "::", "SRLW", ":", "return", "\"RISCVISD::SRLW\"", ";", "case", "RISCVISD", "::", "DIVW", ":", "return", "\"RISCVISD::DIVW\"", ";", "case", "RISCVISD", "::", "DIVUW", ":", "return", "\"RISCVISD::DIVUW\"", ";", "case", "RISCVISD", "::", "REMUW", ":", "return", "\"RISCVISD::REMUW\"", ";", "case", "RISCVISD", "::", "FMV_W_X_RV64", ":", "return", "\"RISCVISD::FMV_W_X_RV64\"", ";", "case", "RISCVISD", "::", "FMV_X_ANYEXTW_RV64", ":", "return", "\"RISCVISD::FMV_X_ANYEXTW_RV64\"", ";", "case", "RISCVISD", "::", "READ_CYCLE_WIDE", ":", "return", "\"RISCVISD::READ_CYCLE_WIDE\"", ";", "case", "RISCVISD", "::", "VINSERTT64_W", ":", "return", "\"RISCVISD::VINSERTT64_W\"", ";", "case", "RISCVISD", "::", "VINSERTB64_W", ":", "return", "\"RISCVISD::VINSERTB64_W\"", ";", "case", "RISCVISD", "::", "VEXTRACTT64_W", ":", "return", "\"RISCVISD::VEXTRACTT64_W\"", ";", "case", "RISCVISD", "::", "VEXTRACTB64_W", ":", "return", "\"RISCVISD::VEXTRACTB64_W\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER", "RISCVISD::RET_FLAG", "\"RISCVISD::RET_FLAG\"", "RISCVISD::URET_FLAG", "\"RISCVISD::URET_FLAG\"", "RISCVISD::SRET_FLAG", "\"RISCVISD::SRET_FLAG\"", "RISCVISD::MRET_FLAG", "\"RISCVISD::MRET_FLAG\"", "RISCVISD::CALL", "\"RISCVISD::CALL\"", "RISCVISD::SELECT_CC", "\"RISCVISD::SELECT_CC\"", "RISCVISD::BuildPairF64", "\"RISCVISD::BuildPairF64\"", "RISCVISD::SplitF64", "\"RISCVISD::SplitF64\"", "RISCVISD::TAIL", "\"RISCVISD::TAIL\"", "RISCVISD::SLLW", "\"RISCVISD::SLLW\"", "RISCVISD::SRAW", "\"RISCVISD::SRAW\"", "RISCVISD::SRLW", "\"RISCVISD::SRLW\"", "RISCVISD::DIVW", "\"RISCVISD::DIVW\"", "RISCVISD::DIVUW", "\"RISCVISD::DIVUW\"", "RISCVISD::REMUW", "\"RISCVISD::REMUW\"", "RISCVISD::FMV_W_X_RV64", "\"RISCVISD::FMV_W_X_RV64\"", "RISCVISD::FMV_X_ANYEXTW_RV64", "\"RISCVISD::FMV_X_ANYEXTW_RV64\"", "RISCVISD::READ_CYCLE_WIDE", "\"RISCVISD::READ_CYCLE_WIDE\"", "RISCVISD::VINSERTT64_W", "\"RISCVISD::VINSERTT64_W\"", "RISCVISD::VINSERTB64_W", "\"RISCVISD::VINSERTB64_W\"", "RISCVISD::VEXTRACTT64_W", "\"RISCVISD::VEXTRACTT64_W\"", "RISCVISD::VEXTRACTB64_W", "\"RISCVISD::VEXTRACTB64_W\"" ]

[]

[ "<s>", "bool", "isMem", "(", "RegisterKind", "RegKind", ",", "bool", "HasIndex", ")", "const", "{", "return", "(", "Kind", "==", "KindMem", "&&", "Mem", ".", "RegKind", "==", "RegKind", "&&", "(", "HasIndex", "||", "!", "Mem", ".", "Index", ")", ")", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "SystemZ" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIa", ")", "&&", "MIb", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIb", ")", ")", "return", "true", ";", "unsigned", "BasePosA", ",", "OffsetPosA", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIa", ",", "BasePosA", ",", "OffsetPosA", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseA", "=", "MIa", ".", "getOperand", "(", "BasePosA", ")", ";", "unsigned", "BaseRegA", "=", "BaseA", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubA", "=", "BaseA", ".", "getSubReg", "(", ")", ";", "unsigned", "BasePosB", ",", "OffsetPosB", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIb", ",", "BasePosB", ",", "OffsetPosB", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseB", "=", "MIb", ".", "getOperand", "(", "BasePosB", ")", ";", "unsigned", "BaseRegB", "=", "BaseB", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubB", "=", "BaseB", ".", "getSubReg", "(", ")", ";", "if", "(", "BaseRegA", "!=", "BaseRegB", "||", "BaseSubA", "!=", "BaseSubB", ")", "return", "false", ";", "unsigned", "SizeA", "=", "getMemAccessSize", "(", "MIa", ")", ";", "unsigned", "SizeB", "=", "getMemAccessSize", "(", "MIb", ")", ";", "const", "MachineOperand", "&", "OffA", "=", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ";", "const", "MachineOperand", "&", "OffB", "=", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ";", "if", "(", "!", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ".", "isImm", "(", ")", "||", "!", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "int", "OffsetA", "=", "isPostIncrement", "(", "MIa", ")", "?", "0", ":", "OffA", ".", "getImm", "(", ")", ";", "int", "OffsetB", "=", "isPostIncrement", "(", "MIb", ")", "?", "0", ":", "OffB", ".", "getImm", "(", ")", ";", "if", "(", "OffsetA", ">", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetA", "-", "(", "int64_t", ")", "OffsetB", ")", ";", "return", "SizeB", "<=", "OffDiff", ";", "}", "if", "(", "OffsetA", "<", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetB", "-", "(", "int64_t", ")", "OffsetA", ")", ";", "return", "SizeA", "<=", "OffDiff", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

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

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ",", "is64Bit", ")", ",", "FrameInfo", "(", "*", "this", ",", "Subtarget", ")", ",", "ELFWriterInfo", "(", "is64Bit", ",", "true", ")", "{", "DefRelocModel", "=", "getRelocationModel", "(", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Default", ")", "{", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "setRelocationModel", "(", "Reloc", "::", "DynamicNoPIC", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "assert", "(", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "&&", "\"Relocation mode not picked\"", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{", "if", "(", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", "&&", "Subtarget", ".", "isTargetDarwin", "(", ")", "&&", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Subtarget", ".", "getPICStyle", "(", ")", "==", "PICStyles", "::", "None", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Relocation mode not picked\"" ]

[]

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

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

[ "Nios2" ]

[]

[ "<s>", "SDValue", "ARM64TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_ARM64_WebKit_JS", ":", "RetCC_ARM64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "realRVLocIdx", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ",", "++", "realRVLocIdx", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "realRVLocIdx", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "ARM64ISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ISD::OutputArg", "ARM64", "ARM64", "16", "4", "1", "0", "0", "\"Can only return in registers!\"", "\"Unknown loc info!\"", "ISD::BITCAST", "1", "0", "ARM64ISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "void", "ix86_output_indirect_branch_via_reg", "(", "rtx", "call_op", ",", "bool", "sibcall_p", ")", "{", "char", "thunk_name_buf", "[", "32", "]", ";", "char", "*", "thunk_name", ";", "enum", "indirect_thunk_prefix", "need_prefix", "=", "indirect_thunk_need_prefix", "(", "current_output_insn", ")", ";", "int", "regno", "=", "REGNO", "(", "call_op", ")", ";", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "!=", "indirect_branch_thunk_inline", ")", "{", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk", ")", "SET_HARD_REG_BIT", "(", "indirect_thunks_used", ",", "regno", ")", ";", "indirect_thunk_name", "(", "thunk_name_buf", ",", "regno", ",", "need_prefix", ",", "false", ")", ";", "thunk_name", "=", "thunk_name_buf", ";", "}", "else", "thunk_name", "=", "NULL", ";", "if", "(", "sibcall_p", ")", "ix86_output_jmp_thunk_or_indirect", "(", "thunk_name", ",", "regno", ")", ";", "else", "{", "if", "(", "thunk_name", "!=", "NULL", ")", "{", "if", "(", "REX_INT_REGNO_P", "(", "regno", ")", "&&", "ix86_indirect_branch_cs_prefix", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tcs\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tcall\\t\"", ")", ";", "assemble_name", "(", "asm_out_file", ",", "thunk_name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", ";", "}", "char", "indirectlabel1", "[", "32", "]", ";", "char", "indirectlabel2", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel1", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel2", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "fputs", "(", "\"\\tjmp\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "ix86_output_jmp_thunk_or_indirect", "(", "thunk_name", ",", "regno", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputs", "(", "\"\\tcall\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "}", "</s>" ]

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

[ "i386", "32", "\"\\tcs\\n\"", "\"\\tcall\\t\"", "32", "32", "\"\\tjmp\\t\"", "\"\\tcall\\t\"" ]

[]

[ "<s>", "Optional", "<", "Value", "*", ">", "X86TTIImpl", "::", "simplifyDemandedUseBitsIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ",", "APInt", "DemandedMask", ",", "KnownBits", "&", "Known", ",", "bool", "&", "KnownBitsComputed", ")", "const", "{", "switch", "(", "II", ".", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "x86_mmx_pmovmskb", ":", "case", "Intrinsic", "::", "x86_sse_movmsk_ps", ":", "case", "Intrinsic", "::", "x86_sse2_movmsk_pd", ":", "case", "Intrinsic", "::", "x86_sse2_pmovmskb_128", ":", "case", "Intrinsic", "::", "x86_avx_movmsk_ps_256", ":", "case", "Intrinsic", "::", "x86_avx_movmsk_pd_256", ":", "case", "Intrinsic", "::", "x86_avx2_pmovmskb", ":", "{", "unsigned", "ArgWidth", ";", "if", "(", "II", ".", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "x86_mmx_pmovmskb", ")", "{", "ArgWidth", "=", "8", ";", "}", "else", "{", "auto", "*", "ArgType", "=", "cast", "<", "FixedVectorType", ">", "(", "II", ".", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "ArgWidth", "=", "ArgType", "->", "getNumElements", "(", ")", ";", "}", "APInt", "DemandedElts", "=", "DemandedMask", ".", "zextOrTrunc", "(", "ArgWidth", ")", ";", "Type", "*", "VTy", "=", "II", ".", "getType", "(", ")", ";", "if", "(", "DemandedElts", ".", "isNullValue", "(", ")", ")", "{", "return", "ConstantInt", "::", "getNullValue", "(", "VTy", ")", ";", "}", "Known", ".", "Zero", ".", "setBitsFrom", "(", "ArgWidth", ")", ";", "KnownBitsComputed", "=", "true", ";", "break", ";", "}", "}", "return", "None", ";", "}", "</s>" ]

[ "Can", "be", "used", "to", "implement", "target-specific", "instruction", "combining", "." ]

[ "X86", "X86", "Intrinsic::x86_mmx_pmovmskb", "Intrinsic::x86_sse_movmsk_ps", "Intrinsic::x86_sse2_movmsk_pd", "Intrinsic::x86_sse2_pmovmskb_128", "Intrinsic::x86_avx_movmsk_ps_256", "Intrinsic::x86_avx_movmsk_pd_256", "Intrinsic::x86_avx2_pmovmskb", "Intrinsic::x86_mmx_pmovmskb", "8", "0" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "const", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "if", "(", "!", "DisableHexagonCFGOpt", ")", "addPass", "(", "createHexagonCFGOptimizer", "(", "TM", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "Register", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "LoadOpcode", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "TVMContinuationsHoist", "::", "optimize", "(", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "MI", ":", "DeleteMIs", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Erasing unused: \"", "<<", "*", "MI", "<<", "\"\\n\"", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "for", "(", "const", "auto", "&", "Pair", ":", "Info", ")", "{", "auto", "TargetMBB", "=", "Pair", ".", "first", ";", "const", "auto", "&", "Instrs", "=", "Pair", ".", "second", ".", "Instructions", ";", "if", "(", "Instrs", ".", "size", "(", ")", "<", "2", ")", "continue", ";", "Changed", "=", "true", ";", "auto", "CommonDom", "=", "Instrs", ".", "front", "(", ")", "->", "getParent", "(", ")", ";", "for", "(", "auto", "CurNextMI", ":", "drop_begin", "(", "Instrs", ",", "1", ")", ")", "{", "assert", "(", "CommonDom", "&&", "\"PUSHCONT_MBB with null parent\"", ")", ";", "assert", "(", "CurNextMI", "->", "getParent", "(", ")", "&&", "\"PUSHCONT_MBB with null parent\"", ")", ";", "CommonDom", "=", "MDT", "->", "findNearestCommonDominator", "(", "CommonDom", ",", "CurNextMI", "->", "getParent", "(", ")", ")", ";", "}", "MachineInstr", "*", "FoundMI", "=", "nullptr", ";", "for", "(", "auto", "I", "=", "CommonDom", "->", "instr_rbegin", "(", ")", ",", "E", "=", "CommonDom", "->", "instr_rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TVM", "::", "PUSHCONT_MBB", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", "==", "TargetMBB", ")", "{", "FoundMI", "=", "&", "MI", ";", "break", ";", "}", "}", "unsigned", "MBBReg", "=", "0", ";", "if", "(", "FoundMI", ")", "{", "MBBReg", "=", "FoundMI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "FoundMI", "->", "clearRegisterDeads", "(", "MBBReg", ")", ";", "}", "else", "{", "MachineInstr", "*", "InsertBefore", "=", "&", "*", "CommonDom", "->", "getFirstInstrTerminator", "(", ")", ";", "unsigned", "FirstOpReg", "=", "InsertBefore", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "FirstOpReg", ")", "&&", "MRI", "->", "hasOneDef", "(", "FirstOpReg", ")", ")", "{", "MachineInstr", "*", "I", "=", "MRI", "->", "getVRegDef", "(", "FirstOpReg", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "TVM", "::", "PHI", "&&", "I", "->", "getParent", "(", ")", "==", "InsertBefore", "->", "getParent", "(", ")", ")", "InsertBefore", "=", "I", ";", "}", "MBBReg", "=", "MRI", "->", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "*", "CommonDom", ",", "InsertBefore", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TVM", "::", "PUSHCONT_MBB", ")", ",", "MBBReg", ")", ".", "addMBB", "(", "TargetMBB", ")", ".", "addImm", "(", "0", ")", ";", "}", "for", "(", "auto", "CurDefMI", ":", "Instrs", ")", "{", "if", "(", "FoundMI", "&&", "FoundMI", "==", "CurDefMI", ")", "continue", ";", "auto", "OldDefMO", "=", "CurDefMI", "->", "getOperand", "(", "0", ")", ";", "assert", "(", "OldDefMO", ".", "isReg", "(", ")", "&&", "\"PUSHCONT_MBB def is not reg\"", ")", ";", "CurDefMI", "->", "eraseFromParent", "(", ")", ";", "MRI", "->", "replaceRegWith", "(", "OldDefMO", ".", "getReg", "(", ")", ",", "MBBReg", ")", ";", "}", "MRI", "->", "clearKillFlags", "(", "MBBReg", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Apply", "VPlan-to-VPlan", "optimizations", "to", "Plan", ",", "including", "induction", "recipe", "optimizations", ",", "dead", "recipe", "removal", ",", "replicate", "region", "optimizations", "and", "block", "merging", "." ]

[ "TVM", "TVM", "\"Erasing unused: \"", "\"\\n\"", "2", "1", "\"PUSHCONT_MBB with null parent\"", "\"PUSHCONT_MBB with null parent\"", "TVM::PUSHCONT_MBB", "1", "0", "0", "0", "TVM::PHI", "TVM::I257RegClass", "TVM::PUSHCONT_MBB", "0", "0", "\"PUSHCONT_MBB def is not reg\"" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "static", "void", "aarch64_update_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "aarch64_def_or_undef", "(", "flag_unsafe_math_optimizations", ",", "\"__ARM_FP_FAST\"", ",", "pfile", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ARCH\"", ",", "aarch64_architecture_version", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_SIZEOF_MINIMAL_ENUM\"", ",", "flag_short_enums", "?", "1", ":", "4", ")", ";", "aarch64_def_or_undef", "(", "TARGET_BIG_END", ",", "\"__AARCH64EB__\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_BIG_END", ",", "\"__ARM_BIG_ENDIAN\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "!", "TARGET_BIG_END", ",", "\"__AARCH64EL__\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_FLOAT", ",", "\"__ARM_FEATURE_FMA\"", ",", "pfile", ")", ";", "if", "(", "TARGET_FLOAT", "||", "TARGET_SIMD", ")", "{", "builtin_define_with_int_value", "(", "\"__ARM_FP\"", ",", "0x0E", ")", ";", "builtin_define", "(", "\"__ARM_FP16_FORMAT_IEEE\"", ")", ";", "builtin_define", "(", "\"__ARM_FP16_ARGS\"", ")", ";", "}", "else", "cpp_undef", "(", "pfile", ",", "\"__ARM_FP\"", ")", ";", "aarch64_def_or_undef", "(", "TARGET_FP_F16INST", ",", "\"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD_F16INST", ",", "\"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD", ",", "\"__ARM_FEATURE_NUMERIC_MAXMIN\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD", ",", "\"__ARM_NEON\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_CRC32", ",", "\"__ARM_FEATURE_CRC32\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_DOTPROD", ",", "\"__ARM_FEATURE_DOTPROD\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_COMPLEX", ",", "\"__ARM_FEATURE_COMPLEX\"", ",", "pfile", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__AARCH64_CMODEL_TINY__\"", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__AARCH64_CMODEL_SMALL__\"", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__AARCH64_CMODEL_LARGE__\"", ")", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "case", "AARCH64_CMODEL_TINY_PIC", ":", "builtin_define", "(", "\"__AARCH64_CMODEL_TINY__\"", ")", ";", "break", ";", "case", "AARCH64_CMODEL_SMALL", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "builtin_define", "(", "\"__AARCH64_CMODEL_SMALL__\"", ")", ";", "break", ";", "case", "AARCH64_CMODEL_LARGE", ":", "builtin_define", "(", "\"__AARCH64_CMODEL_LARGE__\"", ")", ";", "break", ";", "default", ":", "break", ";", "}", "aarch64_def_or_undef", "(", "TARGET_ILP32", ",", "\"_ILP32\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_ILP32", ",", "\"__ILP32__\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_CRYPTO", ",", "\"__ARM_FEATURE_CRYPTO\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD_RDMA", ",", "\"__ARM_FEATURE_QRDMX\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SVE", ",", "\"__ARM_FEATURE_SVE\"", ",", "pfile", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__ARM_FEATURE_SVE_BITS\"", ")", ";", "if", "(", "TARGET_SVE", ")", "{", "int", "bits", ";", "if", "(", "!", "BITS_PER_SVE_VECTOR", ".", "is_constant", "(", "&", "bits", ")", ")", "bits", "=", "0", ";", "builtin_define_with_int_value", "(", "\"__ARM_FEATURE_SVE_BITS\"", ",", "bits", ")", ";", "}", "aarch64_def_or_undef", "(", "TARGET_LSE", ",", "\"__ARM_FEATURE_ATOMICS\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_AES", ",", "\"__ARM_FEATURE_AES\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SHA2", ",", "\"__ARM_FEATURE_SHA2\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SHA3", ",", "\"__ARM_FEATURE_SHA3\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SHA3", ",", "\"__ARM_FEATURE_SHA512\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SM4", ",", "\"__ARM_FEATURE_SM3\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SM4", ",", "\"__ARM_FEATURE_SM4\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_F16FML", ",", "\"__ARM_FEATURE_FP16_FML\"", ",", "pfile", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__FLT_EVAL_METHOD__\"", ")", ";", "builtin_define_with_int_value", "(", "\"__FLT_EVAL_METHOD__\"", ",", "c_flt_eval_method", "(", "true", ")", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__FLT_EVAL_METHOD_C99__\"", ")", ";", "builtin_define_with_int_value", "(", "\"__FLT_EVAL_METHOD_C99__\"", ",", "c_flt_eval_method", "(", "false", ")", ")", ";", "}", "</s>" ]

[ "Undefine/redefine", "macros", "that", "depend", "on", "the", "current", "backend", "state", "and", "may", "need", "to", "change", "when", "a", "target", "pragma", "modifies", "the", "backend", "state", "." ]

[ "aarch64", "\"__ARM_FP_FAST\"", "\"__ARM_ARCH\"", "\"__ARM_SIZEOF_MINIMAL_ENUM\"", "1", "4", "\"__AARCH64EB__\"", "\"__ARM_BIG_ENDIAN\"", "\"__AARCH64EL__\"", "\"__ARM_FEATURE_FMA\"", "\"__ARM_FP\"", "0x0E", "\"__ARM_FP16_FORMAT_IEEE\"", "\"__ARM_FP16_ARGS\"", "\"__ARM_FP\"", "\"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC\"", "\"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC\"", "\"__ARM_FEATURE_NUMERIC_MAXMIN\"", "\"__ARM_NEON\"", "\"__ARM_FEATURE_CRC32\"", "\"__ARM_FEATURE_DOTPROD\"", "\"__ARM_FEATURE_COMPLEX\"", "\"__AARCH64_CMODEL_TINY__\"", "\"__AARCH64_CMODEL_SMALL__\"", "\"__AARCH64_CMODEL_LARGE__\"", "\"__AARCH64_CMODEL_TINY__\"", "\"__AARCH64_CMODEL_SMALL__\"", "\"__AARCH64_CMODEL_LARGE__\"", "\"_ILP32\"", "\"__ILP32__\"", "\"__ARM_FEATURE_CRYPTO\"", "\"__ARM_FEATURE_QRDMX\"", "\"__ARM_FEATURE_SVE\"", "\"__ARM_FEATURE_SVE_BITS\"", "0", "\"__ARM_FEATURE_SVE_BITS\"", "\"__ARM_FEATURE_ATOMICS\"", "\"__ARM_FEATURE_AES\"", "\"__ARM_FEATURE_SHA2\"", "\"__ARM_FEATURE_SHA3\"", "\"__ARM_FEATURE_SHA512\"", "\"__ARM_FEATURE_SM3\"", "\"__ARM_FEATURE_SM4\"", "\"__ARM_FEATURE_FP16_FML\"", "\"__FLT_EVAL_METHOD__\"", "\"__FLT_EVAL_METHOD__\"", "\"__FLT_EVAL_METHOD_C99__\"", "\"__FLT_EVAL_METHOD_C99__\"" ]

[]

[ "<s>", "void", "ix86_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", ")", "{", "HOST_WIDE_INT", "words", ",", "n_gpr", ",", "n_fpr", ";", "tree", "f_gpr", ",", "f_fpr", ",", "f_ovf", ",", "f_sav", ";", "tree", "gpr", ",", "fpr", ",", "ovf", ",", "sav", ",", "t", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "std_expand_builtin_va_start", "(", "valist", ",", "nextarg", ")", ";", "return", ";", "}", "f_gpr", "=", "TYPE_FIELDS", "(", "TREE_TYPE", "(", "va_list_type_node", ")", ")", ";", "f_fpr", "=", "TREE_CHAIN", "(", "f_gpr", ")", ";", "f_ovf", "=", "TREE_CHAIN", "(", "f_fpr", ")", ";", "f_sav", "=", "TREE_CHAIN", "(", "f_ovf", ")", ";", "valist", "=", "build1", "(", "INDIRECT_REF", ",", "TREE_TYPE", "(", "TREE_TYPE", "(", "valist", ")", ")", ",", "valist", ")", ";", "gpr", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_gpr", ")", ",", "valist", ",", "f_gpr", ",", "NULL_TREE", ")", ";", "fpr", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_fpr", ")", ",", "valist", ",", "f_fpr", ",", "NULL_TREE", ")", ";", "ovf", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ovf", ")", ",", "valist", ",", "f_ovf", ",", "NULL_TREE", ")", ";", "sav", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_sav", ")", ",", "valist", ",", "f_sav", ",", "NULL_TREE", ")", ";", "words", "=", "current_function_args_info", ".", "words", ";", "n_gpr", "=", "current_function_args_info", ".", "regno", ";", "n_fpr", "=", "current_function_args_info", ".", "sse_regno", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"va_start: words = %d, n_gpr = %d, n_fpr = %d\\n\"", ",", "(", "int", ")", "words", ",", "(", "int", ")", "n_gpr", ",", "(", "int", ")", "n_fpr", ")", ";", "if", "(", "cfun", "->", "va_list_gpr_size", ")", "{", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "gpr", ")", ",", "gpr", ",", "build_int_cst", "(", "NULL_TREE", ",", "n_gpr", "*", "8", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", ")", "{", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "fpr", ")", ",", "fpr", ",", "build_int_cst", "(", "NULL_TREE", ",", "n_fpr", "*", "16", "+", "8", "*", "REGPARM_MAX", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovf", ")", ",", "virtual_incoming_args_rtx", ")", ";", "if", "(", "words", "!=", "0", ")", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "words", "*", "UNITS_PER_WORD", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "ovf", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "cfun", "->", "va_list_gpr_size", "||", "cfun", "->", "va_list_fpr_size", ")", "{", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "sav", ")", ",", "frame_pointer_rtx", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "sav", ")", ",", "sav", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "}", "</s>" ]

[ "Implement", "va_start", "." ]

[ "i386", "\"va_start: words = %d, n_gpr = %d, n_fpr = %d\\n\"", "8", "1", "16", "8", "1", "0", "1", "1" ]

[]

[ "<s>", "rtx", "mcore_function_arg", "(", "CUMULATIVE_ARGS", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "int", "arg_reg", ";", "if", "(", "!", "named", "||", "mode", "==", "VOIDmode", ")", "return", "0", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "arg_reg", "=", "ROUND_REG", "(", "cum", ",", "mode", ")", ";", "if", "(", "arg_reg", "<", "NPARM_REGS", ")", "return", "handle_structs_in_regs", "(", "mode", ",", "type", ",", "FIRST_PARM_REG", "+", "arg_reg", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "MCore", "the", "first", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", ".", "Any", "arg", "that", "starts", "within", "the", "first", "NPARM_REGS", "words", "is", "at", "least", "partially", "passed", "in", "a", "register", "unless", "its", "data", "type", "forbids", "." ]

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

[]

[ "<s>", "unsigned", "getSize", "(", ")", "const", "{", "return", "CurType", ".", "Size", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "in", "the", "encoding", "of", "this", "instruction", ",", "or", "zero", "if", "the", "encoding", "size", "can", "not", "be", "known", "from", "the", "opcode", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "NumBits1", "=", "VT1", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "VT2", ".", "getSizeInBits", "(", ")", ";", "if", "(", "NumBits1", "<=", "NumBits2", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "ARM64", "ARM64" ]

[]

[ "<s>", "static", "bool", "arc_symbol_binds_local_p", "(", "const_rtx", "x", ")", "{", "return", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL_REF", "X", "binds", "locally", "." ]

[ "arc" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillSaveOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ";", "if", "(", "RI", ".", "hasAGPRs", "(", "RC", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "MIB", ".", "addReg", "(", "Tmp", ",", "RegState", "::", "Define", ")", ";", "}", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "AMDGPU::VGPR_32RegClass", "0" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "mips_call_may_need_jalx_p", "(", "tree", "decl", ")", "{", "if", "(", "mips_get_compress_mode", "(", "decl", ")", "!=", "TARGET_COMPRESSION", ")", "return", "true", ";", "if", "(", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "targetm", ".", "binds_local_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_INTERLINK_COMPRESSED", ")", "{", "if", "(", "!", "TARGET_COMPRESSION", "&&", "mips_get_compress_off_flags", "(", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "==", "0", ")", "return", "true", ";", "if", "(", "TARGET_COMPRESSION", "&&", "mips_get_compress_on_flags", "(", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "==", "0", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "call", "to", "DECL", "may", "need", "to", "use", "JALX", "." ]

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

[]

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

[ "Handle", "a", "``", "longcall", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MSP430TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "MSP430", "::", "GR8RegisterClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "MSP430", "::", "GR16RegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "1", "0", "MVT::i8", "0U", "MSP430::GR8RegisterClass", "0U", "MSP430::GR16RegisterClass" ]

[]

[ "<s>", "static", "bool", "indirect_call_p", "(", "rtx", "pat", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "pat", "=", "SET_SRC", "(", "pat", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "CALL", ")", ";", "pat", "=", "XEXP", "(", "pat", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "MEM", ")", ";", "pat", "=", "XEXP", "(", "pat", ",", "0", ")", ";", "return", "REG_P", "(", "pat", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "PAT", "is", "an", "indirect", "call", "pattern", "." ]

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

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "Align", ",", "bool", "isSrcConst", ",", "bool", "isSrcStr", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "Function", "*", "F", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "bool", "NoImplicitFloatOps", "=", "F", "->", "hasFnAttr", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "!", "NoImplicitFloatOps", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "16", ")", "{", "if", "(", "(", "isSrcConst", "||", "isSrcStr", ")", "&&", "Subtarget", "->", "hasSSE2", "(", ")", "&&", "Size", ">=", "16", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "(", "isSrcConst", "||", "isSrcStr", ")", "&&", "Subtarget", "->", "hasSSE1", "(", ")", "&&", "Size", ">=", "16", ")", "return", "MVT", "::", "v4f32", ";", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "16", "MVT::v4i32", "16", "MVT::v4f32", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "static", "rtx", "alignment_mask", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "!=", "AND", "||", "!", "REG_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", ")", "return", "0", ";", "rtx", "mask", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "mask", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "mask", ")", "==", "-", "16", ")", "return", "alignment_with_canonical_addr", "(", "SET_SRC", "(", "body", ")", ")", ";", "else", "return", "0", ";", "}", "if", "(", "!", "REG_P", "(", "mask", ")", ")", "return", "0", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "use", ";", "rtx", "real_mask", "=", "0", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "use", ")", ",", "mask", ")", ")", "continue", ";", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "def_link", "||", "def_link", "->", "next", ")", "return", "0", ";", "rtx_insn", "*", "const_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "rtx", "const_body", "=", "PATTERN", "(", "const_insn", ")", ";", "if", "(", "GET_CODE", "(", "const_body", ")", "!=", "SET", ")", "return", "0", ";", "real_mask", "=", "SET_SRC", "(", "const_body", ")", ";", "if", "(", "GET_CODE", "(", "real_mask", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "real_mask", ")", "!=", "-", "16", ")", "return", "0", ";", "}", "if", "(", "real_mask", "==", "0", ")", "return", "0", ";", "return", "alignment_with_canonical_addr", "(", "SET_SRC", "(", "body", ")", ")", ";", "}", "</s>" ]

[ "Check", "whether", "an", "rtx", "is", "an", "alignment", "mask", ",", "and", "if", "so", ",", "return", "a", "fully-expanded", "rtx", "for", "the", "masking", "operation", "." ]

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

[]