Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "first_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "13", ";", "first_reg", "<=", "31", ";", "first_reg", "++", ")", "if", "(", "save_reg_p", "(", "first_reg", ")", ")", "break", ";", "if", "(", "first_reg", ">", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "!=", "0", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "||", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", ")", "&&", "rs6000_reg_live_or_pic_offset_p", "(", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ")", "first_reg", "=", "RS6000_PIC_OFFSET_TABLE_REGNUM", ";", "if", "(", "flag_pic", "&&", "crtl", "->", "uses_pic_offset_table", "&&", "first_reg", ">", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", "return", "RS6000_PIC_OFFSET_TABLE_REGNUM", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Return", "the", "first", "register", "that", "is", "required", "to", "be", "saved", ".", "16", "if", "none", "." ]

[ "powerpcspe", "13", "31", "0" ]

[]

[ "<s>", "static", "bool", "isShiftedMask", "(", "uint64_t", "I", ",", "uint64_t", "&", "Pos", ",", "uint64_t", "&", "Size", ")", "{", "if", "(", "!", "isShiftedMask_64", "(", "I", ")", ")", "return", "false", ";", "Size", "=", "CountPopulation_64", "(", "I", ")", ";", "Pos", "=", "CountTrailingZeros_64", "(", "I", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "APInt", "value", "contains", "a", "non-empty", "sequence", "of", "ones", "with", "the", "remainder", "zero", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "BitcodeWriter", "::", "writeModule", "(", "const", "Module", "&", "M", ")", "{", "assert", "(", "!", "WroteStrtab", ")", ";", "assert", "(", "M", ".", "isMaterialized", "(", ")", ")", ";", "Mods", ".", "push_back", "(", "const_cast", "<", "Module", "*", ">", "(", "&", "M", ")", ")", ";", "DXILBitcodeWriter", "ModuleWriter", "(", "M", ",", "Buffer", ",", "StrtabBuilder", ",", "*", "Stream", ")", ";", "ModuleWriter", ".", "write", "(", ")", ";", "}", "</s>" ]

[ "Write", "the", "specified", "module", "to", "the", "buffer", "specified", "at", "construction", "time", "." ]

[ "DirectX", "DXIL" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", "&", "TM", ")", ")", ";", "addPass", "(", "&", "AMDGPUUnifyDivergentExitNodesID", ")", ";", "addPass", "(", "createStructurizeCFGPass", "(", "true", ")", ")", ";", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "CAHPSubtarget", "&", "CAHPSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP", "\"generic\"" ]

[]

[ "<s>", "BitVector", "SystemZRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R11W", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R10P", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R10Q", ")", ";", "}", "Reserved", ".", "set", "(", "SystemZ", "::", "R14D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R14W", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R15W", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R14P", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R14Q", ")", ";", "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", "." ]

[ "SystemZ", "SystemZ", "SystemZ::R11D", "SystemZ::R11W", "SystemZ::R10P", "SystemZ::R10Q", "SystemZ::R14D", "SystemZ::R15D", "SystemZ::R14W", "SystemZ::R15W", "SystemZ::R14P", "SystemZ::R14Q" ]

[]

[ "<s>", "unsigned", "MipsABIInfo", "::", "GetCalleeAllocdArgSizeInBytes", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "CC", "!=", "CallingConv", "::", "Fast", "?", "16", ":", "0", ";", "if", "(", "IsN32", "(", ")", "||", "IsN64", "(", ")", "||", "IsEABI", "(", ")", ")", "return", "0", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "Obtain", "the", "size", "of", "the", "area", "allocated", "by", "the", "callee", "for", "arguments", "." ]

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

[]

[ "<s>", "void", "XCoreInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getAddressSpaceForPseudoSourceKind", "(", "PseudoSourceValue", "::", "PSVKind", "Kind", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "PseudoSourceValue", "::", "Stack", ":", "case", "PseudoSourceValue", "::", "FixedStack", ":", "return", "AMDGPUASI", ".", "PRIVATE_ADDRESS", ";", "case", "PseudoSourceValue", "::", "ConstantPool", ":", "case", "PseudoSourceValue", "::", "GOT", ":", "case", "PseudoSourceValue", "::", "JumpTable", ":", "case", "PseudoSourceValue", "::", "GlobalValueCallEntry", ":", "case", "PseudoSourceValue", "::", "ExternalSymbolCallEntry", ":", "case", "PseudoSourceValue", "::", "TargetCustom", ":", "return", "AMDGPUASI", ".", "CONSTANT_ADDRESS", ";", "}", "return", "AMDGPUASI", ".", "FLAT_ADDRESS", ";", "}", "</s>" ]

[ "getAddressSpaceForPseudoSourceKind", "-", "Given", "the", "kind", "of", "memory", "(", "e.g", "." ]

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

[]

[ "<s>", "void", "PTXMCAsmStreamer", "::", "AddComment", "(", "const", "Twine", "&", "T", ")", "{", "if", "(", "!", "IsVerboseAsm", ")", "return", ";", "CommentStream", ".", "flush", "(", ")", ";", "T", ".", "toVector", "(", "CommentToEmit", ")", ";", "CommentToEmit", ".", "push_back", "(", "'\\n'", ")", ";", "CommentStream", ".", "resync", "(", ")", ";", "}", "</s>" ]

[ "Add", "a", "textual", "comment", "." ]

[ "PTX", "PTX" ]

[]

[ "<s>", "static", "section", "*", "c6x_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "c6x_sdata_mode", "==", "C6X_SDATA_ALL", "||", "(", "c6x_sdata_mode", "!=", "C6X_SDATA_NONE", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "8", ")", ")", "return", "sdata_section", ";", "else", "return", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>" ]

[ "Return", "a", "section", "for", "X", ".", "The", "only", "special", "thing", "we", "do", "here", "is", "to", "honor", "small", "data", ".", "We", "do", "n't", "have", "a", "tree", "type", ",", "so", "we", "ca", "n't", "use", "the", "PLACE_IN_SDATA_P", "macro", "we", "use", "everywhere", "else", ";", "we", "choose", "to", "place", "everything", "sized", "8", "bytes", "or", "smaller", "into", "small", "data", "." ]

[ "c6x", "8" ]

[]

[ "<s>", "const", "char", "*", "nvptx_ptx_type_from_mode", "(", "machine_mode", "mode", ",", "bool", "promote", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_BLKmode", ":", "return", "\".b8\"", ";", "case", "E_BImode", ":", "return", "\".pred\"", ";", "case", "E_QImode", ":", "if", "(", "promote", ")", "return", "\".u32\"", ";", "else", "return", "\".u8\"", ";", "case", "E_HImode", ":", "return", "\".u16\"", ";", "case", "E_SImode", ":", "return", "\".u32\"", ";", "case", "E_DImode", ":", "return", "\".u64\"", ";", "case", "E_HFmode", ":", "return", "\".f16\"", ";", "case", "E_SFmode", ":", "return", "\".f32\"", ";", "case", "E_DFmode", ":", "return", "\".f64\"", ";", "case", "E_V2SImode", ":", "return", "\".v2.u32\"", ";", "case", "E_V2DImode", ":", "return", "\".v2.u64\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "ptx", "type", "for", "MODE", ".", "If", "PROMOTE", ",", "then", "use", ".u32", "for", "QImode", "to", "deal", "with", "ptx", "ideosyncracies", "." ]

[ "nvptx", "\".b8\"", "\".pred\"", "\".u32\"", "\".u8\"", "\".u16\"", "\".u32\"", "\".u64\"", "\".f16\"", "\".f32\"", "\".f64\"", "\".v2.u32\"", "\".v2.u64\"" ]

[]

[ "<s>", "static", "void", "rs6000_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "first", "+", "size", "<=", "32768", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "rounded_size", ";", "rtx", "r12", "=", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "rtx", "r0", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "gcc_assert", "(", "first", "<=", "32768", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "PROBE_INTERVAL", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r12", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "first", ")", ")", ")", ";", "if", "(", "rounded_size", ">", "32768", ")", "{", "emit_move_insn", "(", "r0", ",", "GEN_INT", "(", "-", "rounded_size", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r0", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "r12", ",", "r0", ")", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "r0", ",", "plus_constant", "(", "Pmode", ",", "r12", ",", "-", "rounded_size", ")", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_probe_stack_rangedi", "(", "r12", ",", "r12", ",", "stack_pointer_rtx", ",", "r0", ")", ")", ";", "else", "emit_insn", "(", "gen_probe_stack_rangesi", "(", "r12", ",", "r12", ",", "stack_pointer_rtx", ",", "r0", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "r12", ",", "rounded_size", "-", "size", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "rs6000", "32768", "12", "0", "32768", "32768" ]

[]

[ "<s>", "static", "rtx_insn", "*", "get_next_active_insn", "(", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "tail", ")", "{", "if", "(", "insn", "==", "NULL_RTX", "||", "insn", "==", "tail", ")", "return", "NULL", ";", "while", "(", "1", ")", "{", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "insn", "==", "NULL_RTX", "||", "insn", "==", "tail", ")", "return", "NULL", ";", "if", "(", "CALL_P", "(", "insn", ")", "||", "JUMP_P", "(", "insn", ")", "||", "JUMP_TABLE_DATA_P", "(", "insn", ")", "||", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", "&&", "INSN_CODE", "(", "insn", ")", "!=", "CODE_FOR_stack_tie", ")", ")", "break", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "Return", "the", "next", "insn", "after", "INSN", "that", "is", "found", "before", "TAIL", "is", "reached", ",", "skipping", "any", "``", "non-active", "''", "insns", "-", "insns", "that", "will", "not", "actually", "occupy", "an", "issue", "slot", ".", "Return", "NULL_RTX", "if", "such", "an", "insn", "is", "not", "found", "." ]

[ "powerpcspe", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "BlackfinTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "typedef", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Pair", ";", "using", "namespace", "BF", ";", "if", "(", "Constraint", ".", "size", "(", ")", "!=", "1", ")", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "Pair", "(", "0U", ",", "VT", "==", "MVT", "::", "i16", "?", "D16RegisterClass", ":", "DPRegisterClass", ")", ";", "case", "'a'", ":", "return", "Pair", "(", "0U", ",", "PRegisterClass", ")", ";", "case", "'d'", ":", "return", "Pair", "(", "0U", ",", "DRegisterClass", ")", ";", "case", "'e'", ":", "return", "Pair", "(", "0U", ",", "AccuRegisterClass", ")", ";", "case", "'A'", ":", "return", "Pair", "(", "A0", ",", "AccuRegisterClass", ")", ";", "case", "'B'", ":", "return", "Pair", "(", "A1", ",", "AccuRegisterClass", ")", ";", "case", "'b'", ":", "return", "Pair", "(", "0U", ",", "IRegisterClass", ")", ";", "case", "'v'", ":", "return", "Pair", "(", "0U", ",", "BRegisterClass", ")", ";", "case", "'f'", ":", "return", "Pair", "(", "0U", ",", "MRegisterClass", ")", ";", "case", "'C'", ":", "return", "Pair", "(", "CC", ",", "JustCCRegisterClass", ")", ";", "case", "'x'", ":", "return", "Pair", "(", "0U", ",", "GRRegisterClass", ")", ";", "case", "'w'", ":", "return", "Pair", "(", "0U", ",", "ALLRegisterClass", ")", ";", "case", "'Z'", ":", "return", "Pair", "(", "P3", ",", "PRegisterClass", ")", ";", "case", "'Y'", ":", "return", "Pair", "(", "P1", ",", "PRegisterClass", ")", ";", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF", "1", "0", "0U", "MVT::i16", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "setPersonality", "(", "const", "MCSymbol", "*", "Per", ")", "{", "HasPersonality", "=", "1", ";", "}", "</s>" ]

[ "Set", "the", "personality", "." ]

[ "ARM", "1" ]

[]

[ "<s>", "static", "bool", "isAcceptableChar", "(", "char", "C", ")", "{", "return", "(", "C", ">=", "'a'", "&&", "C", "<=", "'z'", ")", "||", "C", "==", "'F'", "||", "C", "==", "'R'", "||", "C", "==", "'V'", "||", "C", "==", "'X'", "||", "(", "C", ">=", "'0'", "&&", "C", "<=", "'9'", ")", "||", "C", "==", "'\\''", "||", "C", "==", "'_'", "||", "C", "==", "'-'", ";", "}", "</s>" ]

[ "Return", "true", "if", "C", "is", "an", "acceptable", "character", "inside", "a", "symbol", "name", "." ]

[ "F2003f" ]

[]

[ "<s>", "FuncInfo", "(", ")", ":", "MemInstCost", "(", "0", ")", ",", "InstCost", "(", "0", ")", ",", "IAMInstCost", "(", "0", ")", ",", "LSMInstCost", "(", "0", ")", "{", "}", "</s>" ]

[ "Information", "about", "the", "function", "as", "a", "whole", "." ]

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

[]

[ "<s>", "bool", "ix86_target_stack_probe", "(", "void", ")", "{", "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", ")", "return", "false", ";", "return", "TARGET_STACK_PROBE", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "must", "probe", "the", "stack", "before", "any", "space", "allocation", "on", "this", "target", ".", "It", "'s", "essentially", "TARGET_STACK_PROBE", "except", "when", "-fstack-check", "causes", "the", "stack", "to", "be", "already", "probed", "differently", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "originalTypeIsF128", "(", "const", "Type", "*", "Ty", ",", "const", "SDNode", "*", "CallNode", ")", "{", "if", "(", "Ty", "->", "isFP128Ty", "(", ")", ")", "return", "true", ";", "if", "(", "Ty", "->", "isStructTy", "(", ")", "&&", "Ty", "->", "getStructNumElements", "(", ")", "==", "1", "&&", "Ty", "->", "getStructElementType", "(", "0", ")", "->", "isFP128Ty", "(", ")", ")", "return", "true", ";", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast_or_null", "<", "const", "ExternalSymbolSDNode", ">", "(", "CallNode", ")", ";", "return", "(", "ES", "&&", "Ty", "->", "isIntegerTy", "(", "128", ")", "&&", "isF128SoftLibCall", "(", "ES", "->", "getSymbol", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "Ty", "is", "fp128", ",", "{", "f128", "}", "or", "i128", "which", "was", "originally", "a", "fp128", "." ]

[ "Mips", "1", "0", "128" ]

[]

[ "<s>", "static", "rtx", "nios2_expand_custom_builtin", "(", "tree", "exp", ",", "unsigned", "int", "index", ",", "rtx", "target", ")", "{", "bool", "has_target_p", "=", "(", "TREE_TYPE", "(", "exp", ")", "!=", "void_type_node", ")", ";", "machine_mode", "tmode", "=", "VOIDmode", ";", "int", "nargs", ",", "argno", ";", "rtx", "value", ",", "insn", ",", "unspec_args", "[", "3", "]", ";", "tree", "arg", ";", "if", "(", "has_target_p", ")", "{", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "REG_P", "(", "target", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "nargs", "=", "call_expr_nargs", "(", "exp", ")", ";", "for", "(", "argno", "=", "0", ";", "argno", "<", "nargs", ";", "argno", "++", ")", "{", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "argno", ")", ";", "value", "=", "expand_normal", "(", "arg", ")", ";", "unspec_args", "[", "argno", "]", "=", "value", ";", "if", "(", "argno", "==", "0", ")", "{", "if", "(", "!", "custom_insn_opcode", "(", "value", ",", "VOIDmode", ")", ")", "error", "(", "\"custom instruction opcode must be compile time \"", "\"constant in the range 0-255 for __builtin_custom_%s\"", ",", "custom_builtin_name", "[", "index", "]", ")", ";", "}", "else", "unspec_args", "[", "argno", "]", "=", "force_reg", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg", ")", ")", ",", "unspec_args", "[", "argno", "]", ")", ";", "}", "for", "(", ";", "argno", "<", "3", ";", "argno", "++", ")", "unspec_args", "[", "argno", "]", "=", "const0_rtx", ";", "insn", "=", "(", "has_target_p", "?", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "tmode", ",", "gen_rtvec_v", "(", "3", ",", "unspec_args", ")", ",", "UNSPECV_CUSTOM_XNXX", ")", ")", ":", "gen_rtx_UNSPEC_VOLATILE", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "3", ",", "unspec_args", ")", ",", "UNSPECV_CUSTOM_NXX", ")", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", "has_target_p", "?", "target", ":", "const0_rtx", ";", "}", "</s>" ]

[ "Helper", "function", "for", "expanding", "custom", "builtins", "." ]

[ "nios2", "3", "0", "0", "\"custom instruction opcode must be compile time \"", "\"constant in the range 0-255 for __builtin_custom_%s\"", "3", "3", "3" ]

[]

[ "<s>", "PPCSubtarget", "&", "PPCSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initializeEnvironment", "(", ")", ";", "initSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "HexagonSubtarget", "::", "adjustSchedDependency", "(", "SUnit", "*", "Src", ",", "SUnit", "*", "Dst", ",", "SDep", "&", "Dep", ")", "const", "{", "MachineInstr", "*", "SrcInst", "=", "Src", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "DstInst", "=", "Dst", "->", "getInstr", "(", ")", ";", "if", "(", "!", "Src", "->", "isInstr", "(", ")", "||", "!", "Dst", "->", "isInstr", "(", ")", ")", "return", ";", "const", "HexagonInstrInfo", "*", "QII", "=", "getInstrInfo", "(", ")", ";", "SmallSet", "<", "SUnit", "*", ",", "4", ">", "ExclSrc", ";", "SmallSet", "<", "SUnit", "*", ",", "4", ">", "ExclDst", ";", "if", "(", "QII", "->", "canExecuteInBundle", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ",", "ExclSrc", ",", "ExclDst", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "if", "(", "!", "hasV60TOps", "(", ")", ")", "return", ";", "if", "(", "DstInst", "->", "isCopy", "(", ")", ")", "Dep", ".", "setLatency", "(", "0", ")", ";", "if", "(", "(", "DstInst", "->", "isRegSequence", "(", ")", "||", "DstInst", "->", "isCopy", "(", ")", ")", "&&", "Dst", "->", "NumSuccs", "==", "1", ")", "{", "unsigned", "DReg", "=", "DstInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "DDst", "=", "Dst", "->", "Succs", "[", "0", "]", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ";", "unsigned", "UseIdx", "=", "-", "1", ";", "for", "(", "unsigned", "OpNum", "=", "0", ";", "OpNum", "<", "DDst", "->", "getNumOperands", "(", ")", ";", "OpNum", "++", ")", "{", "const", "MachineOperand", "&", "MO", "=", "DDst", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "&&", "MO", ".", "isUse", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "DReg", ")", "{", "UseIdx", "=", "OpNum", ";", "break", ";", "}", "}", "int", "DLatency", "=", "(", "InstrInfo", ".", "getOperandLatency", "(", "&", "InstrItins", ",", "*", "SrcInst", ",", "0", ",", "*", "DDst", ",", "UseIdx", ")", ")", ";", "DLatency", "=", "std", "::", "max", "(", "DLatency", ",", "0", ")", ";", "Dep", ".", "setLatency", "(", "(", "unsigned", ")", "DLatency", ")", ";", "}", "ExclSrc", ".", "clear", "(", ")", ";", "ExclDst", ".", "clear", "(", ")", ";", "if", "(", "EnableDotCurSched", "&&", "QII", "->", "isToBeScheduledASAP", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ",", "ExclSrc", ",", "ExclDst", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "updateLatency", "(", "*", "SrcInst", ",", "*", "DstInst", ",", "Dep", ")", ";", "}", "</s>" ]

[ "Perform", "target", "specific", "adjustments", "to", "the", "latency", "of", "a", "schedule", "dependency", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "4", "4", "0", "0", "1", "0", "0", "1", "0", "0", "0", "0" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "bool", "AMDGPUOpenCLEnqueuedBlockLowering", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "DenseSet", "<", "Function", "*", ">", "Callers", ";", "auto", "&", "C", "=", "M", ".", "getContext", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"enqueued-block\"", ")", ")", "{", "if", "(", "!", "F", ".", "hasName", "(", ")", ")", "{", "SmallString", "<", "64", ">", "Name", ";", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "\"__amdgpu_enqueued_kernel\"", ",", "M", ".", "getDataLayout", "(", ")", ")", ";", "F", ".", "setName", "(", "Name", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"found enqueued kernel: \"", "<<", "F", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "auto", "RuntimeHandle", "=", "(", "F", ".", "getName", "(", ")", "+", "\".runtime_handle\"", ")", ".", "str", "(", ")", ";", "auto", "T", "=", "Type", "::", "getInt8Ty", "(", "C", ")", "->", "getPointerTo", "(", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", ";", "auto", "*", "GV", "=", "new", "GlobalVariable", "(", "M", ",", "T", ",", "false", ",", "GlobalValue", "::", "ExternalLinkage", ",", "Constant", "::", "getNullValue", "(", "T", ")", ",", "RuntimeHandle", ",", "nullptr", ",", "GlobalValue", "::", "NotThreadLocal", ",", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ",", "false", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"runtime handle created: \"", "<<", "*", "GV", "<<", "'\\n'", ")", ";", "for", "(", "auto", "U", ":", "F", ".", "users", "(", ")", ")", "{", "auto", "*", "UU", "=", "&", "*", "U", ";", "if", "(", "!", "isa", "<", "ConstantExpr", ">", "(", "UU", ")", ")", "continue", ";", "collectFunctionUsers", "(", "UU", ",", "Callers", ")", ";", "auto", "*", "BitCast", "=", "cast", "<", "ConstantExpr", ">", "(", "UU", ")", ";", "auto", "*", "NewPtr", "=", "ConstantExpr", "::", "getPointerCast", "(", "GV", ",", "BitCast", "->", "getType", "(", ")", ")", ";", "BitCast", "->", "replaceAllUsesWith", "(", "NewPtr", ")", ";", "F", ".", "addFnAttr", "(", "\"runtime-handle\"", ",", "RuntimeHandle", ")", ";", "F", ".", "setLinkage", "(", "GlobalValue", "::", "ExternalLinkage", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "for", "(", "auto", "F", ":", "Callers", ")", "{", "if", "(", "F", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "AMDGPU_KERNEL", ")", "continue", ";", "F", "->", "addFnAttr", "(", "\"calls-enqueue-kernel\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"mark enqueue_kernel caller:\"", "<<", "F", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU", "\"enqueued-block\"", "64", "\"__amdgpu_enqueued_kernel\"", "\"found enqueued kernel: \"", "\".runtime_handle\"", "AMDGPU", "AMDGPU", "\"runtime handle created: \"", "\"runtime-handle\"", "AMDGPU", "\"calls-enqueue-kernel\"", "\"mark enqueue_kernel caller:\"" ]

[]

[ "<s>", "static", "bool", "mips_cfun_call_saved_reg_p", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "global_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", "&&", "mips_interrupt_extra_call_saved_reg_p", "(", "regno", ")", ")", "return", "true", ";", "return", "(", "regno", "==", "GLOBAL_POINTER_REGNUM", "?", "TARGET_CALL_SAVED_GP", ":", "!", "call_used_regs", "[", "regno", "]", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "should", "treat", "register", "REGNO", "as", "call-saved", "." ]

[ "mips" ]

[]

[ "<s>", "rtx", "h8300_get_index", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ",", "int", "*", "size", ")", "{", "int", "dummy", ",", "factor", ";", "if", "(", "size", "==", "0", ")", "size", "=", "&", "dummy", ";", "factor", "=", "(", "mode", "==", "VOIDmode", "?", "0", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "TARGET_H8300SX", "&&", "factor", "<=", "4", "&&", "(", "mode", "==", "VOIDmode", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", ")", "{", "if", "(", "factor", "<=", "1", "&&", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTEND", ")", "{", "*", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "return", "XEXP", "(", "x", ",", "0", ")", ";", "}", "else", "{", "rtx", "index", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "factor", "==", "0", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "0xff", "*", "factor", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "0xffff", "*", "factor", ")", ")", "{", "index", "=", "XEXP", "(", "x", ",", "0", ")", ";", "*", "size", "=", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0xffff", "?", "2", ":", "1", ")", ";", "}", "else", "{", "index", "=", "x", ";", "*", "size", "=", "4", ";", "}", "if", "(", "GET_CODE", "(", "index", ")", "==", "MULT", "&&", "GET_CODE", "(", "XEXP", "(", "index", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "factor", "==", "0", "||", "factor", "==", "INTVAL", "(", "XEXP", "(", "index", ",", "1", ")", ")", ")", ")", "return", "XEXP", "(", "index", ",", "0", ")", ";", "}", "}", "*", "size", "=", "0", ";", "return", "x", ";", "}", "</s>" ]

[ "Given", "that", "X", "occurs", "in", "an", "address", "of", "the", "form", "(", "plus", "X", "constant", ")", ",", "return", "the", "part", "of", "X", "that", "is", "expected", "to", "be", "a", "register", ".", "There", "are", "four", "kinds", "of", "addressing", "mode", "to", "recognize", ":", "@", "(", "dd", ",", "Rn", ")", "@", "(", "dd", ",", "RnL.b", ")", "@", "(", "dd", ",", "Rn.w", ")", "@", "(", "dd", ",", "ERn.l", ")", "If", "SIZE", "is", "nonnull", ",", "and", "the", "address", "is", "one", "of", "the", "last", "three", "forms", ",", "set", "*", "SIZE", "to", "the", "index", "multiplication", "factor", ".", "Set", "it", "to", "0", "for", "plain", "@", "(", "dd", ",", "Rn", ")", "addresses", ".", "MODE", "is", "the", "mode", "of", "the", "value", "being", "accessed", ".", "It", "can", "be", "VOIDmode", "if", "the", "address", "is", "known", "to", "be", "valid", ",", "but", "its", "mode", "is", "unknown", "." ]

[ "h8300", "0", "0", "4", "1", "0", "0", "1", "0", "1", "0xff", "1", "0xffff", "0", "1", "0xffff", "2", "1", "4", "1", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "READ_REGISTER", ":", "ExpandREAD_REGISTER", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "Res", "=", "LowerREM", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SDIV", ":", "assert", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "\"can only expand DIV on Windows\"", ")", ";", "return", "ExpandDIV_Windows", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ",", "Results", ")", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::SREM", "ISD::UREM", "ISD::READCYCLECOUNTER", "ISD::UDIV", "ISD::SDIV", "\"can only expand DIV on Windows\"", "0", "ISD::SDIV" ]

[]

[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "AArch64GISelActualAccessor", "*", "GISel", "=", "new", "AArch64GISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "createAArch64InstructionSelector", "(", "*", "this", ",", "*", "I", ",", "*", "RBI", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"target-features\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "LanaiFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LanaiRegisterInfo", "*", "LRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "LRI", "->", "hasStackRealignment", "(", "MF", ")", "?", "MFI", ".", "getMaxAlign", "(", ")", ":", "getStackAlign", "(", ")", ";", "unsigned", "MaxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "MaxCallFrameSize", "=", "alignTo", "(", "MaxCallFrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallFrameSize", ")", ";", "if", "(", "!", "(", "hasReservedCallFrame", "(", "MF", ")", "&&", "MFI", ".", "adjustsStack", "(", ")", ")", ")", "FrameSize", "+=", "MaxCallFrameSize", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

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

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "Nios2" ]

[]

[ "<s>", "static", "bool", "const_vector_equal_evenodd_p", "(", "rtx", "op", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "int", "i", ",", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_VECTOR", "||", "nunits", "!=", "CONST_VECTOR_NUNITS", "(", "op", ")", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nunits", ";", "i", "+=", "2", ")", "if", "(", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", "!=", "CONST_VECTOR_ELT", "(", "op", ",", "i", "+", "1", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Helper", "function", "of", "ix86_expand_mul_widen_evenodd", ".", "Return", "true", "if", "op", "is", "CONST_VECTOR", "with", "all", "odd", "elements", "equal", "to", "their", "preceding", "element", "." ]

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

[]

[ "<s>", "static", "void", "block_move_call", "(", "rtx", "dest_reg", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "if", "(", "GET_MODE", "(", "bytes_rtx", ")", "!=", "VOIDmode", "&&", "GET_MODE", "(", "bytes_rtx", ")", "!=", "Pmode", ")", "bytes_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "bytes_rtx", ",", "1", ")", ";", "emit_library_call", "(", "m32r_function_symbol", "(", "\"memcpy\"", ")", ",", "0", ",", "VOIDmode", ",", "3", ",", "dest_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

[ "Use", "a", "library", "function", "to", "move", "some", "bytes", "." ]

[ "m32r", "1", "\"memcpy\"", "0", "3" ]

[]

[ "<s>", "void", "M88kIncomingValueHandler", "::", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "uint64_t", "ValSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getFixedSizeInBits", "(", ")", ";", "uint64_t", "LocSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getFixedSizeInBits", "(", ")", ";", "assert", "(", "ValSize", "<=", "64", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "LocSize", "<=", "64", "&&", "\"Unsupported location size\"", ")", ";", "markPhysRegUsed", "(", "PhysReg", ")", ";", "if", "(", "ValSize", "==", "LocSize", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "else", "{", "assert", "(", "ValSize", "<", "LocSize", "&&", "\"Extensions not supported\"", ")", ";", "auto", "PhysRegToVReg", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "::", "scalar", "(", "LocSize", ")", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "PhysRegToVReg", ")", ";", "}", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "M88k", "M88k", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "64", "\"Unsupported value size\"", "64", "\"Unsupported location size\"", "\"Extensions not supported\"" ]

[]

[ "<s>", "static", "void", "sh_setup_incoming_varargs", "(", "cumulative_args_t", "ca", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_arg_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "gcc_assert", "(", "cfun", "->", "stdarg", ")", ";", "if", "(", "TARGET_VARARGS_PRETEND_ARGS", "(", "current_function_decl", ")", ")", "{", "int", "named_parm_regs", ",", "anon_parm_regs", ";", "named_parm_regs", "=", "(", "sh_round_reg", "(", "*", "get_cumulative_args", "(", "ca", ")", ",", "mode", ")", "+", "(", "mode", "==", "BLKmode", "?", "CEIL", "(", "int_size_in_bytes", "(", "type", ")", ",", "UNITS_PER_WORD", ")", ":", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ")", ")", ";", "anon_parm_regs", "=", "NPARM_REGS", "(", "SImode", ")", "-", "named_parm_regs", ";", "if", "(", "anon_parm_regs", ">", "0", ")", "*", "pretend_arg_size", "=", "anon_parm_regs", "*", "4", ";", "}", "}", "</s>" ]

[ "We", "actually", "emit", "the", "code", "in", "sh_expand_prologue", ".", "We", "used", "to", "use", "a", "static", "variable", "to", "flag", "that", "we", "need", "to", "emit", "this", "code", ",", "but", "that", "does", "n't", "when", "inlining", ",", "when", "functions", "are", "deferred", "and", "then", "emitted", "later", ".", "Fortunately", ",", "we", "already", "have", "two", "flags", "that", "are", "part", "of", "struct", "function", "that", "tell", "if", "a", "function", "uses", "varargs", "or", "stdarg", "." ]

[ "sh", "0", "4" ]

[]

[ "<s>", "bool", "DCPU16FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DCPU16MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "DCPU16MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "DCPU16", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "Dcpu16", "DCPU16", "DCPU16", "DCPU16", "0", "1", "DCPU16::PUSH16r" ]

[]

[ "<s>", "void", "tool_cleanup", "(", "bool", "from_signal", "ATTRIBUTE_UNUSED", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num_temps", ";", "i", "++", ")", "maybe_unlink", "(", "temp_files", "[", "i", "]", ")", ";", "}", "</s>" ]

[ "Delete", "tempfiles", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "addRange", "(", "uint64_t", "Start", ",", "uint64_t", "End", ",", "Instruction", "*", "Inst", ")", "{", "auto", "I", "=", "llvm", "::", "lower_bound", "(", "Ranges", ",", "Start", ",", "[", "]", "(", "const", "Range", "&", "LHS", ",", "uint64_t", "RHS", ")", "{", "return", "LHS", ".", "End", "<=", "RHS", ";", "}", ")", ";", "if", "(", "I", "!=", "Ranges", ".", "end", "(", ")", "&&", "End", ">", "I", "->", "Start", ")", "{", "return", "false", ";", "}", "Ranges", ".", "insert", "(", "I", ",", "{", "Start", ",", "End", ",", "Inst", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "addRange", "-", "Add", "an", "address", "range", "to", "the", "list", "of", "ranges", "for", "this", "unit", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "WebAssemblyReplacePhysRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Replace Physical Registers **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "MRI", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "unsigned", "PReg", "=", "WebAssembly", "::", "NoRegister", "+", "1", ";", "PReg", "<", "WebAssembly", "::", "NUM_TARGET_REGS", ";", "++", "PReg", ")", "{", "if", "(", "PReg", "==", "WebAssembly", "::", "VALUE_STACK", "||", "PReg", "==", "WebAssembly", "::", "ARGUMENTS", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "PReg", ")", ";", "unsigned", "VReg", "=", "WebAssembly", "::", "NoRegister", ";", "for", "(", "auto", "I", "=", "MRI", ".", "reg_begin", "(", "PReg", ")", ",", "E", "=", "MRI", ".", "reg_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", "++", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", ")", "{", "if", "(", "VReg", "==", "WebAssembly", "::", "NoRegister", ")", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MO", ".", "setReg", "(", "VReg", ")", ";", "if", "(", "MO", ".", "getParent", "(", ")", "->", "isDebugValue", "(", ")", ")", "MO", ".", "setIsDebug", "(", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Replace Physical Registers **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "WebAssembly::NoRegister", "1", "WebAssembly::NUM_TARGET_REGS", "WebAssembly::VALUE_STACK", "WebAssembly::ARGUMENTS", "WebAssembly::NoRegister", "WebAssembly::NoRegister" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDE", ":", "return", "PerformADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUBE", ":", "return", "PerformSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "PerformDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::ADDE", "ISD::SUBE", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::SELECT", "ISD::AND", "ISD::OR", "ISD::ADD" ]

[]

[ "<s>", "void", "rs6000_expand_vector_extract", "(", "rtx", "target", ",", "rtx", "vec", ",", "rtx", "elt", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vec", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "mem", ";", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "CONST_INT_P", "(", "elt", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "V1TImode", ":", "gcc_assert", "(", "INTVAL", "(", "elt", ")", "==", "0", "&&", "inner_mode", "==", "TImode", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "TImode", ",", "vec", ")", ")", ";", "break", ";", "case", "V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V16QImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v16qi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "V8HImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v8hi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "V4SImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v4si", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "break", ";", "}", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "CONST_INT_P", "(", "elt", ")", "&&", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "if", "(", "GET_MODE", "(", "elt", ")", "!=", "DImode", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "convert_move", "(", "tmp", ",", "elt", ",", "0", ")", ";", "elt", "=", "tmp", ";", "}", "else", "if", "(", "!", "REG_P", "(", "elt", ")", ")", "elt", "=", "force_reg", "(", "DImode", ",", "elt", ")", ";", "switch", "(", "mode", ")", "{", "case", "V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V4SImode", ":", "emit_insn", "(", "gen_vsx_extract_v4si_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V8HImode", ":", "emit_insn", "(", "gen_vsx_extract_v8hi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "V16QImode", ":", "emit_insn", "(", "gen_vsx_extract_v16qi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "gcc_assert", "(", "CONST_INT_P", "(", "elt", ")", ")", ";", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "vec", ")", ";", "mem", "=", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "INTVAL", "(", "elt", ")", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ";", "emit_move_insn", "(", "target", ",", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Extract", "field", "ELT", "from", "VEC", "into", "TARGET", "." ]

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

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "SubsumesPredicate", "(", "ArrayRef", "<", "MachineOperand", ">", "Pred1", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred2", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "BaseKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "SHUXIAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "if", "(", "!", "Value", ")", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "return", ";", "}", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Value", "%", "4", "==", "0", "&&", "\"The destination address is not aligned to a word\"", ")", ";", "Data", "[", "Offset", "]", "=", "Value", "&", "0xFF", ";", "Data", "[", "Offset", "+", "1", "]", "=", "uint8_t", "(", "(", "Value", ">>", "8", ")", "&", "0xFF", ")", ";", "return", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "4", "0", "\"The destination address is not aligned to a word\"", "0xFF", "1", "8", "0xFF" ]

[]

[ "<s>", "void", "MSP430AsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MSP430MCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "isT", ")", ":", "ARMArchVersion", "(", "V4", ")", ",", "ARMFPUType", "(", "None", ")", ",", "UseNEONForSinglePrecisionFP", "(", "UseNEONFP", ")", ",", "IsThumb", "(", "isT", ")", ",", "ThumbMode", "(", "Thumb1", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "IsR9Reserved", "(", "ReserveR9", ")", ",", "UseMovt", "(", "UseMOVT", ")", ",", "HasFP16", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "\"generic\"", ")", ",", "TargetType", "(", "isELF", ")", ",", "TargetABI", "(", "ARM_ABI_APCS", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "CPUString", "=", "ParseSubtargetFeatures", "(", "FS", ",", "CPUString", ")", ";", "if", "(", "CPUString", "==", "\"generic\"", "&&", "(", "FS", ".", "empty", "(", ")", "||", "FS", "==", "\"generic\"", ")", ")", "ARMArchVersion", "=", "V4T", ";", "unsigned", "Len", "=", "TT", ".", "length", "(", ")", ";", "unsigned", "Idx", "=", "0", ";", "if", "(", "Len", ">=", "5", "&&", "TT", ".", "substr", "(", "0", ",", "4", ")", "==", "\"armv\"", ")", "Idx", "=", "4", ";", "else", "if", "(", "Len", ">=", "6", "&&", "TT", ".", "substr", "(", "0", ",", "5", ")", "==", "\"thumb\"", ")", "{", "IsThumb", "=", "true", ";", "if", "(", "Len", ">=", "7", "&&", "TT", "[", "5", "]", "==", "'v'", ")", "Idx", "=", "6", ";", "}", "if", "(", "Idx", ")", "{", "unsigned", "SubVer", "=", "TT", "[", "Idx", "]", ";", "if", "(", "SubVer", ">=", "'7'", "&&", "SubVer", "<=", "'9'", ")", "{", "ARMArchVersion", "=", "V7A", ";", "}", "else", "if", "(", "SubVer", "==", "'6'", ")", "{", "ARMArchVersion", "=", "V6", ";", "if", "(", "Len", ">=", "Idx", "+", "3", "&&", "TT", "[", "Idx", "+", "1", "]", "==", "'t'", "&&", "TT", "[", "Idx", "+", "2", "]", "==", "'2'", ")", "ARMArchVersion", "=", "V6T2", ";", "}", "else", "if", "(", "SubVer", "==", "'5'", ")", "{", "ARMArchVersion", "=", "V5T", ";", "if", "(", "Len", ">=", "Idx", "+", "3", "&&", "TT", "[", "Idx", "+", "1", "]", "==", "'t'", "&&", "TT", "[", "Idx", "+", "2", "]", "==", "'e'", ")", "ARMArchVersion", "=", "V5TE", ";", "}", "else", "if", "(", "SubVer", "==", "'4'", ")", "{", "if", "(", "Len", ">=", "Idx", "+", "2", "&&", "TT", "[", "Idx", "+", "1", "]", "==", "'t'", ")", "ARMArchVersion", "=", "V4T", ";", "else", "ARMArchVersion", "=", "V4", ";", "}", "}", "if", "(", "ARMArchVersion", ">=", "V6T2", ")", "ThumbMode", "=", "Thumb2", ";", "else", "if", "(", "ThumbMode", ">=", "Thumb2", ")", "ARMArchVersion", "=", "V6T2", ";", "if", "(", "Len", ">=", "10", ")", "{", "if", "(", "TT", ".", "find", "(", "\"-darwin\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetType", "=", "isDarwin", ";", "}", "if", "(", "TT", ".", "find", "(", "\"eabi\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetABI", "=", "ARM_ABI_AAPCS", ";", "if", "(", "isAAPCS_ABI", "(", ")", ")", "stackAlignment", "=", "8", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "IsR9Reserved", "=", "ReserveR9", "|", "(", "ARMArchVersion", "<", "V6", ")", ";", "if", "(", "!", "isThumb", "(", ")", "||", "hasThumb2", "(", ")", ")", "PostRAScheduler", "=", "true", ";", "if", "(", "CPUString", "==", "\"cortex-a8\"", ")", "{", "if", "(", "UseNEONFP", ".", "getPosition", "(", ")", "==", "0", ")", "UseNEONForSinglePrecisionFP", "=", "true", ";", "}", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "4", "\"generic\"", "ARM", "\"generic\"", "\"generic\"", "ARM", "0", "5", "0", "4", "\"armv\"", "4", "6", "0", "5", "\"thumb\"", "7", "5", "6", "ARM", "ARM", "3", "1", "2", "ARM", "ARM", "3", "1", "2", "ARM", "2", "1", "ARM", "ARM", "ARM", "ARM", "10", "\"-darwin\"", "\"eabi\"", "ARM", "8", "ARM", "\"cortex-a8\"", "0" ]

[]

[ "<s>", "TargetTransformInfo", "MipsTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "if", "(", "Subtarget", "->", "allowMixed16_32", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"No Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "}", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "BasicTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"No Target Transform Info Pass Added\\n\"", "\"Target Transform Info Pass Added\\n\"" ]

[]

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

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

[ "JVM", "JVM" ]

[]

[ "<s>", "unsigned", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", "=", "TTI", "::", "TCK_RecipThroughput", ",", "TTI", "::", "OperandValueKind", "Opd1Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueKind", "Opd2Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", "=", "TTI", "::", "OP_None", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", "=", "TTI", "::", "OP_None", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", "=", "ArrayRef", "<", "const", "Value", "*", ">", "(", ")", ",", "const", "Instruction", "*", "CxtI", "=", "nullptr", ")", "{", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "UREM", ":", "return", "64", "*", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "}", "</s>" ]

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

[ "Lanai", "ISD::MUL", "ISD::SDIV", "ISD::UDIV", "ISD::UREM", "64" ]

[]

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

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

[ "RISCV" ]

[]

[ "<s>", "const", "CallLowering", "*", "X86Subtarget", "::", "getCallLowering", "(", ")", "const", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "StringRef", "CPU", "=", "TM", ".", "getTargetCPU", "(", ")", ";", "StringRef", "FS", "=", "TM", ".", "getTargetFeatureString", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "const", "NVPTXSubtarget", "STI", "(", "TT", ",", "CPU", ",", "FS", ",", "NTM", ")", ";", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", ")", ";", "emitHeader", "(", "M", ",", "OS1", ",", "STI", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "!", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"Start of file scope inline assembly\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "StringRef", "(", "M", ".", "getModuleInlineAsm", "(", ")", ")", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"End of file scope inline assembly\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "NVCL", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "GlobalsEmitted", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"" ]

[]

[ "<s>", "void", "update", "(", "unsigned", "R", ",", "const", "LatticeCell", "&", "L", ")", "{", "Map", "[", "R", "]", "=", "L", ";", "}", "</s>" ]

[ "Digest", "more", "data", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "visium_split_cstore", "(", "enum", "rtx_code", "op_code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "enum", "rtx_code", "code", ",", "rtx", "op2", ",", "rtx", "op3", ")", "{", "enum", "machine_mode", "cc_mode", "=", "visium_select_cc_mode", "(", "code", ",", "op2", ",", "op3", ")", ";", "if", "(", "cc_mode", "==", "CCFPEmode", "&&", "(", "op_code", "==", "NEG", "||", "op_code", "==", "MINUS", ")", ")", "cc_mode", "=", "CCFPmode", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "cc_mode", ",", "FLAGS_REGNUM", ")", ";", "rtx", "x", "=", "gen_rtx_COMPARE", "(", "cc_mode", ",", "op2", ",", "op3", ")", ";", "x", "=", "gen_rtx_SET", "(", "flags", ",", "x", ")", ";", "emit_insn", "(", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "flags", ",", "const0_rtx", ")", ";", "switch", "(", "op_code", ")", "{", "case", "SET", ":", "break", ";", "case", "NEG", ":", "x", "=", "gen_rtx_NEG", "(", "SImode", ",", "x", ")", ";", "break", ";", "case", "PLUS", ":", "case", "MINUS", ":", "x", "=", "gen_rtx_fmt_ee", "(", "op_code", ",", "SImode", ",", "op1", ",", "x", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "rtx", "pat", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "op0", ",", "x", ")", ";", "flags", "=", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REGNUM", ")", ";", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "flags", ")", ";", "emit_insn", "(", "pat", ")", ";", "visium_flags_exposed", "=", "true", ";", "}", "</s>" ]

[ "Split", "a", "compare-and-store", "with", "CODE", ",", "operands", "OP2", "and", "OP3", ",", "combined", "with", "operation", "with", "OP_CODE", ",", "operands", "OP0", "and", "OP1", "." ]

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

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsIEEEMode", "=", "ST", "->", "enableIEEEBit", "(", "MF", ")", "||", "!", "MFI", "->", "hasNoSignedZerosFPMath", "(", ")", ";", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "depth_first", "(", "&", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", "->", "begin", "(", ")", ";", "I", "!=", "MBB", "->", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "tryFoldInst", "(", "TII", ",", "&", "MI", ")", ";", "if", "(", "!", "TII", "->", "isFoldableCopy", "(", "MI", ")", ")", "{", "if", "(", "IsIEEEMode", "||", "!", "tryFoldOMod", "(", "MI", ")", ")", "tryFoldClamp", "(", "MI", ")", ";", "continue", ";", "}", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", "||", "OpToFold", ".", "isFI", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Dst", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Dst", ".", "getReg", "(", ")", ")", ")", "continue", ";", "foldInstOperand", "(", "MI", ",", "OpToFold", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "ix86_comp_type_attributes", "(", "tree", "type1", ",", "tree", "type2", ")", "{", "const", "char", "*", "const", "rtdstr", "=", "TARGET_RTD", "?", "\"cdecl\"", ":", "\"stdcall\"", ";", "if", "(", "TREE_CODE", "(", "type1", ")", "!=", "FUNCTION_TYPE", ")", "return", "1", ";", "if", "(", "(", "!", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "||", "(", "ix86_function_regparm", "(", "type1", ",", "NULL", ")", "!=", "ix86_function_regparm", "(", "type2", ",", "NULL", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"sseregparm\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"sseregparm\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "rtdstr", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "rtdstr", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "0", "if", "the", "attributes", "for", "two", "types", "are", "incompatible", ",", "1", "if", "they", "are", "compatible", ",", "and", "2", "if", "they", "are", "nearly", "compatible", "(", "which", "causes", "a", "warning", "to", "be", "generated", ")", "." ]

[ "i386", "\"cdecl\"", "\"stdcall\"", "1", "\"fastcall\"", "\"fastcall\"", "0", "\"sseregparm\"", "\"sseregparm\"", "0", "0", "1" ]

[]

[ "<s>", "bool", "aarch64_simd_check_vect_par_cnst_half", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "high", ")", "{", "rtx", "ideal", "=", "aarch64_simd_vect_par_cnst_half", "(", "mode", ",", "high", ")", ";", "HOST_WIDE_INT", "count_op", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "count_ideal", "=", "XVECLEN", "(", "ideal", ",", "0", ")", ";", "int", "i", "=", "0", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "count_op", "!=", "count_ideal", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count_ideal", ";", "i", "++", ")", "{", "rtx", "elt_op", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "rtx", "elt_ideal", "=", "XVECEXP", "(", "ideal", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elt_op", ")", "||", "INTVAL", "(", "elt_ideal", ")", "!=", "INTVAL", "(", "elt_op", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "OP", "for", "validity", "as", "a", "PARALLEL", "RTX", "vector", "with", "elements", "numbering", "the", "lanes", "of", "either", "the", "high", "(", "HIGH", "==", "TRUE", ")", "or", "low", "lanes", ",", "from", "the", "perspective", "of", "the", "architecture", ".", "See", "the", "diagram", "above", "aarch64_simd_vect_par_cnst_half", "for", "more", "details", "." ]

[ "aarch64", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "bfin_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "if", "(", "bfin_valid_reg_p", "(", "REGNO", "(", "x", ")", ",", "strict", ")", ")", "return", "true", ";", "break", ";", "case", "PLUS", ":", "if", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "bfin_valid_reg_p", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "UNSPEC", "||", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "bfin_valid_add", "(", "mode", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", ")", ")", "return", "true", ";", "break", ";", "case", "POST_INC", ":", "case", "POST_DEC", ":", "if", "(", "LEGITIMATE_MODE_FOR_AUTOINC_P", "(", "mode", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "bfin_valid_reg_p", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ")", ")", "return", "true", ";", "case", "PRE_DEC", ":", "if", "(", "LEGITIMATE_MODE_FOR_AUTOINC_P", "(", "mode", ")", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "stack_pointer_rtx", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "bfin_valid_reg_p", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ")", ")", "return", "true", ";", "break", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Recognize", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "Blackfin", "addressing", "modes", "are", "as", "follows", ":", "[", "preg", "]", "[", "preg", "+", "imm16", "]", "B", "[", "Preg", "+", "uimm15", "]", "W", "[", "Preg", "+", "uimm16m2", "]", "[", "Preg", "+", "uimm17m4", "]", "[", "preg++", "]", "[", "preg", "--", "]", "[", "--", "sp", "]" ]

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

[]

[ "<s>", "void", "SIInstrInfo", "::", "reserveIndirectRegisters", "(", "BitVector", "&", "Reserved", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "int", "End", "=", "getIndirectIndexEnd", "(", "MF", ")", ";", "int", "Begin", "=", "getIndirectIndexBegin", "(", "MF", ")", ";", "if", "(", "End", "==", "-", "1", ")", "return", ";", "for", "(", "int", "Index", "=", "Begin", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "1", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_64RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "2", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_96RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "3", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_128RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "7", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_256RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "15", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_512RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "}", "</s>" ]

[ "Reserve", "the", "registers", "that", "may", "be", "accessed", "using", "indirect", "addressing", "." ]

[ "R600", "SI", "1", "0", "1", "0", "2", "0", "3", "0", "7", "0", "15" ]

[]

[ "<s>", "void", "TPCHazardRecognizer", "::", "Reset", "(", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" *HR* Reset Hazard Recognizer\\n\"", ")", ";", "clearResources", "(", ")", ";", "PacketNum", "=", "0", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "TPC", "TPC", "\" *HR* Reset Hazard Recognizer\\n\"", "0" ]

[]

[ "<s>", "int", "includes_lshift_p", "(", "rtx", "shiftop", ",", "rtx", "andop", ")", "{", "unsigned", "HOST_WIDE_INT", "shift_mask", "=", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0", ";", "shift_mask", "<<=", "INTVAL", "(", "shiftop", ")", ";", "return", "(", "INTVAL", "(", "andop", ")", "&", "0xffffffff", "&", "~", "shift_mask", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "ANDOP", "is", "a", "mask", "that", "has", "no", "bits", "on", "that", "are", "not", "in", "the", "mask", "required", "to", "convert", "the", "result", "of", "a", "rotate", "insn", "into", "a", "shift", "left", "insn", "of", "SHIFTOP", "bits", ".", "Both", "are", "known", "to", "be", "SImode", "CONST_INT", "." ]

[ "rs6000", "0", "0xffffffff", "0" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_vec_init_builtin", "(", "tree", "type", ",", "tree", "arglist", ",", "rtx", "target", ")", "{", "enum", "machine_mode", "tmode", "=", "TYPE_MODE", "(", "type", ")", ";", "enum", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "tmode", ")", ";", "int", "i", ",", "n_elt", "=", "GET_MODE_NUNITS", "(", "tmode", ")", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elt", ";", "++", "i", ",", "arglist", "=", "TREE_CHAIN", "(", "arglist", ")", ")", "{", "rtx", "x", "=", "expand_expr", "(", "TREE_VALUE", "(", "arglist", ")", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_lowpart", "(", "inner_mode", ",", "x", ")", ";", "}", "gcc_assert", "(", "arglist", "==", "NULL", ")", ";", "if", "(", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "rs6000_expand_vector_init", "(", "target", ",", "gen_rtx_PARALLEL", "(", "tmode", ",", "v", ")", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "vec_init", "builtin", "." ]

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

[]

[ "<s>", "static", "bool", "is_leaf_function", "(", "function", "*", "fn", ")", "{", "basic_block", "bb", ";", "gimple_stmt_iterator", "gsi", ";", "if", "(", "fn", "->", "cfg", "==", "NULL", ")", "return", "false", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "fn", ")", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "if", "(", "is_gimple_call", "(", "gsi_stmt", "(", "gsi", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "certain", "that", "this", "is", "a", "leaf", "function", ".", "False", "if", "it", "is", "not", "a", "leaf", "function", "or", "if", "it", "is", "impossible", "to", "tell", "." ]

[ "mips" ]

[]

[ "<s>", "uint64_t", "Mips64GOT", "::", "emit", "(", "MemoryRegion", "&", "pRegion", ")", "{", "uint64_t", "*", "buffer", "=", "reinterpret_cast", "<", "uint64_t", "*", ">", "(", "pRegion", ".", "begin", "(", ")", ")", ";", "uint64_t", "result", "=", "0", ";", "for", "(", "iterator", "it", "=", "begin", "(", ")", ",", "ie", "=", "end", "(", ")", ";", "it", "!=", "ie", ";", "++", "it", ",", "++", "buffer", ")", "{", "Mips64GOTEntry", "*", "got", "=", "&", "(", "llvm", "::", "cast", "<", "Mips64GOTEntry", ">", "(", "(", "*", "it", ")", ")", ")", ";", "*", "buffer", "=", "static_cast", "<", "uint64_t", ">", "(", "got", "->", "getValue", "(", ")", ")", ";", "result", "+=", "got", "->", "size", "(", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

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

[]

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

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

[ "Mips", "Mips::NumTargetFixupKinds" ]

[]

[ "<s>", "virtual", "const", "TargetFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "MBlaze" ]

[]

[ "<s>", "void", "emitBasicBlockEnd", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "override", "{", "AsmPrinter", "::", "emitBasicBlockEnd", "(", "MBB", ")", ";", "SMShadowTracker", ".", "emitShadowPadding", "(", "*", "OutStreamer", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "at", "the", "end", "of", "a", "basic", "block", "." ]

[ "X86" ]

[]

[ "<s>", "static", "enum", "rtx_code", "ix86_prepare_fp_compare_args", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "pop0", ",", "rtx", "*", "pop1", ")", "{", "machine_mode", "fpcmp_mode", "=", "ix86_fp_compare_mode", "(", "code", ")", ";", "rtx", "op0", "=", "*", "pop0", ",", "op1", "=", "*", "pop1", ";", "machine_mode", "op_mode", "=", "GET_MODE", "(", "op0", ")", ";", "int", "is_sse", "=", "TARGET_SSE_MATH", "&&", "SSE_FLOAT_MODE_P", "(", "op_mode", ")", ";", "if", "(", "!", "is_sse", "&&", "(", "fpcmp_mode", "==", "CCFPUmode", "||", "(", "op_mode", "==", "XFmode", "&&", "!", "(", "standard_80387_constant_p", "(", "op0", ")", "==", "1", "||", "standard_80387_constant_p", "(", "op1", ")", "==", "1", ")", "&&", "GET_CODE", "(", "op1", ")", "!=", "FLOAT", ")", "||", "ix86_fp_comparison_strategy", "(", "code", ")", "==", "IX86_FPCMP_COMI", ")", ")", "{", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "else", "{", "if", "(", "standard_80387_constant_p", "(", "op0", ")", "==", "0", "||", "(", "MEM_P", "(", "op0", ")", "&&", "!", "(", "standard_80387_constant_p", "(", "op1", ")", "==", "0", "||", "MEM_P", "(", "op1", ")", ")", ")", ")", "{", "enum", "rtx_code", "new_code", "=", "ix86_fp_swap_condition", "(", "code", ")", ";", "if", "(", "new_code", "!=", "UNKNOWN", ")", "{", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "code", "=", "new_code", ";", "}", "}", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "if", "(", "CONSTANT_P", "(", "op1", ")", ")", "{", "int", "tmp", "=", "standard_80387_constant_p", "(", "op1", ")", ";", "if", "(", "tmp", "==", "0", ")", "op1", "=", "validize_mem", "(", "force_const_mem", "(", "op_mode", ",", "op1", ")", ")", ";", "else", "if", "(", "tmp", "==", "1", ")", "{", "if", "(", "TARGET_CMOVE", ")", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "else", "op1", "=", "force_reg", "(", "op_mode", ",", "op1", ")", ";", "}", "}", "if", "(", "ix86_fp_comparison_cost", "(", "code", ")", ">", "ix86_fp_comparison_cost", "(", "swap_condition", "(", "code", ")", ")", "&&", "(", "REG_P", "(", "op1", ")", "||", "can_create_pseudo_p", "(", ")", ")", ")", "{", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "op_mode", ",", "op0", ")", ";", "}", "*", "pop0", "=", "op0", ";", "*", "pop1", "=", "op1", ";", "return", "code", ";", "}", "</s>" ]

[ "Swap", ",", "force", "into", "registers", ",", "or", "otherwise", "massage", "the", "two", "operands", "to", "a", "fp", "comparison", ".", "The", "operands", "are", "updated", "in", "place", ";", "the", "new", "comparsion", "code", "is", "returned", "." ]

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

[]

[ "<s>", "void", "mips_emit_binary", "(", "enum", "rtx_code", "code", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "target", ")", ",", "op0", ",", "op1", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", "of", "the", "form", "(", "set", "TARGET", "(", "CODE", "OP0", "OP1", ")", ")", "." ]

[ "mips" ]

[]

[ "<s>", "int", "avr_vdump", "(", "FILE", "*", "stream", ",", "const", "char", "*", "caller", ",", "...", ")", "{", "va_list", "ap", ";", "if", "(", "NULL", "==", "stream", "&&", "dump_file", ")", "stream", "=", "dump_file", ";", "va_start", "(", "ap", ",", "caller", ")", ";", "if", "(", "stream", ")", "avr_log_vadump", "(", "stream", ",", "caller", ",", "ap", ")", ";", "va_end", "(", "ap", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Wrapper", "for", "avr_log_vadump", ".", "If", "STREAM", "is", "NULL", "we", "are", "called", "by", "avr_dump", ",", "i.e", ".", "output", "to", "dump_file", "if", "available", ".", "The", "2nd", "argument", "is", "__FUNCTION__", ".", "The", "3rd", "argument", "is", "the", "format", "string", "." ]

[ "avr", "1" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "MCB", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", "->", "getIterator", "(", ")", ";", "unsigned", "IgnoreCount", "=", "0", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "{", "if", "(", "MII", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", "||", "MII", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ")", "++", "IgnoreCount", ";", "else", "{", "HexagonLowerToMC", "(", "&", "*", "MII", ",", "MCB", ",", "*", "this", ")", ";", "}", "}", "}", "else", "{", "HexagonLowerToMC", "(", "MI", ",", "MCB", ",", "*", "this", ")", ";", "HexagonMCInstrInfo", "::", "padEndloop", "(", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ")", ";", "}", "HexagonMCInstrInfo", "::", "tryCompound", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ")", ";", "SmallVector", "<", "DuplexCandidate", ",", "8", ">", "possibleDuplexes", ";", "possibleDuplexes", "=", "HexagonMCInstrInfo", "::", "getDuplexPossibilties", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "MCB", ")", ";", "HexagonMCShuffle", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "*", "Subtarget", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ",", "possibleDuplexes", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MCB", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "WebAssemblyFastISel", "::", "fastLowerArguments", "(", ")", "{", "if", "(", "!", "FuncInfo", ".", "CanLowerReturn", ")", "return", "false", ";", "const", "Function", "*", "F", "=", "FuncInfo", ".", "Fn", ";", "if", "(", "F", "->", "isVarArg", "(", ")", ")", "return", "false", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "const", "AttributeSet", "&", "Attrs", "=", "F", "->", "getAttributes", "(", ")", ";", "if", "(", "Attrs", ".", "hasAttribute", "(", "i", "+", "1", ",", "Attribute", "::", "ByVal", ")", "||", "Attrs", ".", "hasAttribute", "(", "i", "+", "1", ",", "Attribute", "::", "SwiftSelf", ")", "||", "Attrs", ".", "hasAttribute", "(", "i", "+", "1", ",", "Attribute", "::", "SwiftError", ")", "||", "Attrs", ".", "hasAttribute", "(", "i", "+", "1", ",", "Attribute", "::", "InAlloca", ")", "||", "Attrs", ".", "hasAttribute", "(", "i", "+", "1", ",", "Attribute", "::", "Nest", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "unsigned", "Opc", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "getSimpleType", "(", "ArgTy", ")", ")", "{", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_I32", ";", "RC", "=", "&", "WebAssembly", "::", "I32RegClass", ";", "break", ";", "case", "MVT", "::", "i64", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_I64", ";", "RC", "=", "&", "WebAssembly", "::", "I64RegClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_F32", ";", "RC", "=", "&", "WebAssembly", "::", "F32RegClass", ";", "break", ";", "case", "MVT", "::", "f64", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_F64", ";", "RC", "=", "&", "WebAssembly", "::", "F64RegClass", ";", "break", ";", "default", ":", "return", "false", ";", "}", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addImm", "(", "i", ")", ";", "updateValueMap", "(", "&", "Arg", ",", "ResultReg", ")", ";", "++", "i", ";", "}", "MRI", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "auto", "*", "MFI", "=", "MF", "->", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "MFI", "->", "addParam", "(", "getLegalType", "(", "getSimpleType", "(", "Arg", ".", "getType", "(", ")", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "argument", "lowering", "." ]

[ "WebAssembly", "WebAssembly", "0", "1", "1", "1", "1", "1", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i32", "WebAssembly::ARGUMENT_I32", "WebAssembly::I32RegClass", "MVT::i64", "WebAssembly::ARGUMENT_I64", "WebAssembly::I64RegClass", "MVT::f32", "WebAssembly::ARGUMENT_F32", "WebAssembly::F32RegClass", "MVT::f64", "WebAssembly::ARGUMENT_F64", "WebAssembly::F64RegClass", "WebAssembly::ARGUMENTS", "WebAssembly" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", ".", "hasStackProtectorIndex", "(", ")", ")", "{", "for", "(", "unsigned", "int", "i", "=", "0", ",", "e", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "MFI", ".", "getStackID", "(", "i", ")", "==", "TargetStackID", "::", "ScalableVector", "&&", "MFI", ".", "getObjectSSPLayout", "(", "i", ")", "!=", "MachineFrameInfo", "::", "SSPLK_None", ")", "{", "MFI", ".", "setStackID", "(", "MFI", ".", "getStackProtectorIndex", "(", ")", ",", "TargetStackID", "::", "ScalableVector", ")", ";", "MFI", ".", "setObjectAlignment", "(", "MFI", ".", "getStackProtectorIndex", "(", ")", ",", "Align", "(", "16", ")", ")", ";", "break", ";", "}", "}", "}", "MFI", ".", "computeMaxCallFrameSize", "(", "MF", ")", ";", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "16" ]

[]

[ "<s>", "LaneBitmask", "HexagonExpandCondsets", "::", "getLaneMask", "(", "unsigned", "Reg", ",", "unsigned", "Sub", ")", "{", "assert", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", ";", "return", "Sub", "!=", "0", "?", "TRI", "->", "getSubRegIndexLaneMask", "(", "Sub", ")", ":", "MRI", "->", "getMaxLaneMaskForVReg", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Returns", "the", "combination", "of", "all", "lane", "masks", "of", "register", "in", "this", "class", "." ]

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

[]

[ "<s>", "int", "m68hc11_auto_inc_p", "(", "rtx", "x", ")", "{", "return", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "POST_DEC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_INC", ";", "}", "</s>" ]

[ "Returns", "true", "if", "X", "is", "a", "PRE/POST", "increment", "decrement", "(", "same", "as", "auto_inc_p", "(", ")", "in", "rtlanal.c", "but", "do", "not", "take", "into", "account", "the", "stack", ")", "." ]

[ "m68hc11" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ",", "Register", "DstReg", ",", "Register", "TrueReg", ",", "Register", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "STI", ".", "hasLoadStoreOnCond", "(", ")", ")", "return", "false", ";", "if", "(", "Pred", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "(", "STI", ".", "hasLoadStoreOnCond2", "(", ")", "&&", "SystemZ", "::", "GRX32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "||", "SystemZ", "::", "GR32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "SystemZ", "::", "GR64BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "2", ";", "TrueCycles", "=", "2", ";", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "SystemZ", "SystemZ", "2", "SystemZ::GRX32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::GR64BitRegClass", "2", "2", "2" ]

[]

[ "<s>", "static", "pad_direction", "mips_function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "return", "PAD_UPWARD", ";", "if", "(", "type", "!=", "0", "?", "(", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "POINTER_TYPE_P", "(", "type", ")", "||", "FIXED_POINT_TYPE_P", "(", "type", ")", ")", ":", "(", "SCALAR_INT_MODE_P", "(", "mode", ")", "||", "ALL_SCALAR_FIXED_POINT_MODE_P", "(", "mode", ")", ")", ")", "return", "PAD_DOWNWARD", ";", "if", "(", "mips_abi", "==", "ABI_O64", ")", "if", "(", "type", "!=", "0", "?", "FLOAT_TYPE_P", "(", "type", ")", ":", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "PAD_DOWNWARD", ";", "if", "(", "mips_abi", "!=", "ABI_EABI", ")", "return", "PAD_UPWARD", ";", "if", "(", "mode", "!=", "BLKmode", "?", "GET_MODE_BITSIZE", "(", "mode", ")", ">=", "PARM_BOUNDARY", ":", "int_size_in_bytes", "(", "type", ")", ">=", "(", "PARM_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", "return", "PAD_UPWARD", ";", "return", "PAD_DOWNWARD", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_PADDING", ";", "return", "PAD_UPWARD", "if", "the", "first", "byte", "of", "the", "stack", "slot", "has", "useful", "data", ",", "PAD_DOWNWARD", "if", "the", "last", "byte", "does", "." ]

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

[]

[ "<s>", "SDValue", "HSAILTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "HSAILMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "HSAILMachineFunctionInfo", ">", "(", ")", ";", "HSAILParamManager", "&", "PM", "=", "FuncInfo", "->", "getParamManager", "(", ")", ";", "unsigned", "AS", "=", "HSAIL", "::", "isKernelFunc", "(", "MF", ".", "getFunction", "(", ")", ")", "?", "HSAILAS", "::", "KERNARG_ADDRESS", ":", "HSAILAS", "::", "ARG_ADDRESS", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getFunction", "(", ")", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "MVT", "PtrTy", "=", "getPointerTy", "(", "DL", ",", "AS", ")", ";", "Mangler", "Mang", ";", "Function", "::", "const_arg_iterator", "AI", "=", "MF", ".", "getFunction", "(", ")", "->", "arg_begin", "(", ")", ";", "Function", "::", "const_arg_iterator", "AE", "=", "MF", ".", "getFunction", "(", ")", "->", "arg_end", "(", ")", ";", "for", "(", "unsigned", "ArgNo", "=", "0", ";", "AI", "!=", "AE", ";", "++", "AI", ")", "{", "unsigned", "Param", "=", "PM", ".", "addArgumentParam", "(", "AS", ",", "*", "AI", ",", "HSAILParamManager", "::", "mangleArg", "(", "&", "Mang", ",", "AI", "->", "getName", "(", ")", ",", "DL", ")", ")", ";", "const", "char", "*", "ParamName", "=", "PM", ".", "getParamName", "(", "Param", ")", ";", "std", "::", "string", "md", "=", "(", "AI", "->", "getName", "(", ")", "+", "\":\"", "+", "ParamName", "+", "\" \"", ")", ".", "str", "(", ")", ";", "FuncInfo", "->", "addMetadata", "(", "\"argmap:\"", "+", "md", ",", "true", ")", ";", "SDValue", "ParamPtr", "=", "DAG", ".", "getTargetExternalSymbol", "(", "ParamName", ",", "PtrTy", ")", ";", "LowerArgument", "(", "Chain", ",", "SDValue", "(", ")", ",", "false", ",", "&", "Ins", ",", "nullptr", ",", "dl", ",", "DAG", ",", "&", "InVals", ",", "ArgNo", ",", "AI", "->", "getType", "(", ")", ",", "AS", ",", "ParamName", ",", "ParamPtr", ",", "nullptr", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "ISD::InputArg", "HSAIL", "HSAIL", "HSAIL", "HSAIL::isKernelFunc", "HSAILAS::KERNARG_ADDRESS", "HSAILAS::ARG_ADDRESS", "0", "HSAIL", "\":\"", "\" \"", "\"argmap:\"" ]

[]

[ "<s>", "static", "void", "riscv_extend_comparands", "(", "rtx_code", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "word_mode", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "op0", ")", ")", ")", "{", "if", "(", "unsigned_condition", "(", "code", ")", "==", "code", "&&", "GET_MODE", "(", "*", "op0", ")", "==", "QImode", ")", "{", "*", "op0", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "CONST_INT_P", "(", "*", "op1", ")", ")", "*", "op1", "=", "GEN_INT", "(", "(", "uint8_t", ")", "INTVAL", "(", "*", "op1", ")", ")", ";", "else", "*", "op1", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "else", "{", "*", "op0", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "*", "op1", "!=", "const0_rtx", ")", "*", "op1", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "}", "}", "</s>" ]

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

[ "riscv" ]

[]

[ "<s>", "static", "bool", "aarch64_mode_valid_for_sched_fusion_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", "||", "(", "aarch64_vector_mode_supported_p", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "one", "of", "the", "modes", "for", "which", "we", "support", "LDP/STP", "operations", "." ]

[ "aarch64", "8" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "const", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "ByVal", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "InReg", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "StructRet", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftSelf", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftError", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "Nest", ")", "||", "VRegs", "[", "Idx", "]", ".", "size", "(", ")", ">", "1", ")", "return", "false", ";", "ArgInfo", "OrigArg", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ",", "Idx", ")", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "Idx", "++", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "X86OutgoingValueAssigner", "Assigner", "(", "CC_X86", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "Handler", ",", "Assigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "0", "1", "X86", "X86" ]

[]

[ "<s>", "static", "void", "epiphany_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "*", "cum", "=", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "mode", ",", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "epiphany" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "X86Operand", ">", "CreateMem", "(", "unsigned", "ModeSize", ",", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "unsigned", "Size", "=", "0", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "nullptr", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "auto", "Res", "=", "llvm", "::", "make_unique", "<", "X86Operand", ">", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "Res", "->", "Mem", ".", "Size", "=", "Size", ";", "Res", "->", "Mem", ".", "ModeSize", "=", "ModeSize", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "Res", "->", "AddressOf", "=", "false", ";", "return", "Res", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "X86", "X86", "0", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86" ]

[]

[ "<s>", "bool", "rs6000_fndecl_pcrel_p", "(", "const_tree", "fndecl", ")", "{", "if", "(", "DEFAULT_ABI", "!=", "ABI_ELFv2", ")", "return", "false", ";", "struct", "cl_target_option", "*", "opts", "=", "target_opts_for_fn", "(", "fndecl", ")", ";", "return", "(", "(", "opts", "->", "x_rs6000_isa_flags", "&", "OPTION_MASK_PCREL", ")", "!=", "0", "&&", "TARGET_CMODEL", "==", "CMODEL_MEDIUM", ")", ";", "}", "</s>" ]

[ "Return", "whether", "we", "should", "generate", "PC-relative", "code", "for", "FNDECL", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "HexagonHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "||", "TII", "->", "isZeroCost", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "NoHazard", ";", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** Hazard in cycle \"", "<<", "PacketNum", "<<", "\", \"", "<<", "*", "MI", ")", ";", "HazardType", "RetVal", "=", "Hazard", ";", "if", "(", "isNewStore", "(", "*", "MI", ")", ")", "{", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "TII", "->", "getDotNewOp", "(", "*", "MI", ")", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "if", "(", "Resources", "->", "canReserveResources", "(", "*", "NewMI", ")", ")", "RetVal", "=", "NoHazard", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** Try .new version? \"", "<<", "(", "RetVal", "==", "NoHazard", ")", "<<", "\"\\n\"", ")", ";", "MF", "->", "deleteMachineInstr", "(", "NewMI", ")", ";", "}", "return", "RetVal", ";", "}", "if", "(", "SU", "==", "UsesDotCur", "&&", "DotCurPNum", "!=", "(", "int", ")", "PacketNum", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** .cur Hazard in cycle \"", "<<", "PacketNum", "<<", "\", \"", "<<", "*", "MI", ")", ";", "return", "Hazard", ";", "}", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "Hexagon", "Hexagon", "\"*** Hazard in cycle \"", "\", \"", "\"*** Try .new version? \"", "\"\\n\"", "\"*** .cur Hazard in cycle \"", "\", \"" ]

[]

[ "<s>", "MVT", "RISCVTargetLowering", "::", "getPointerTy", "(", "const", "DataLayout", "&", "DL", ",", "uint32_t", "AS", ")", "const", "{", "if", "(", "AS", "==", "UINT32_MAX", ")", "{", "AS", "=", "0", ";", "}", "return", "MVT", "::", "getIntegerVT", "(", "DL", ".", "getPointerSizeInBits", "(", "AS", ")", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "0", "MVT::getIntegerVT" ]

[]

[ "<s>", "bool", "arc_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "if", "(", "flag_pic", ")", "{", "if", "(", "arc_legitimate_pic_addr_p", "(", "x", ")", ")", "return", "true", ";", "}", "return", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "case", "LABEL_REF", ":", "if", "(", "flag_pic", ")", "return", "false", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "true", ";", "case", "NEG", ":", "return", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "PLUS", ":", "case", "MINUS", ":", "{", "bool", "t1", "=", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "bool", "t2", "=", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "return", "(", "t1", "&&", "t2", ")", ";", "}", "case", "CONST_VECTOR", ":", "switch", "(", "mode", ")", "{", "case", "E_V2HImode", ":", "return", "TARGET_PLUS_DMPY", ";", "case", "E_V2SImode", ":", "case", "E_V4HImode", ":", "return", "TARGET_PLUS_QMACW", ";", "default", ":", "return", "false", ";", "}", "case", "UNSPEC", ":", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_TLS_GD", ":", "case", "UNSPEC_TLS_OFF", ":", "case", "UNSPEC_TLS_IE", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "default", ":", "fatal_insn", "(", "\"unrecognized supposed constant\"", ",", "x", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]

[ "arc", "0", "0", "0", "1", "1", "\"unrecognized supposed constant\"" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "UREM", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "||", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", ")", "return", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_X_ANYEXTW_RV64", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i32", ",", "FPConv", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Don't know how to custom type legalize this operation!\"", "ISD::SHL", "ISD::SRA", "ISD::SRL", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "1", "ISD::Constant", "ISD::SDIV", "ISD::UDIV", "ISD::UREM", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "ISD::Constant", "1", "ISD::Constant", "ISD::BITCAST", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "RISCVISD::FMV_X_ANYEXTW_RV64", "MVT::i64", "ISD::TRUNCATE", "MVT::i32" ]

[]

[ "<s>", "bool", "shouldInsertFencesForAtomic", "(", "const", "Instruction", "*", "I", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Helper", "functions", "for", "atomic", "operations", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "cris_return_address_on_stack", "(", "void", ")", "{", "return", "df_regs_ever_live_p", "(", "CRIS_SRP_REGNUM", ")", "||", "cfun", "->", "machine", "->", "needs_return_address_on_stack", ";", "}", "</s>" ]

[ "Accessor", "used", "in", "cris.md", ":", "return", "because", "cfun-", ">", "machine", "is", "n't", "available", "there", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLSRCostLess", "(", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C1", ",", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C2", ")", "{", "return", "std", "::", "tie", "(", "C1", ".", "Insns", ",", "C1", ".", "NumRegs", ",", "C1", ".", "AddRecCost", ",", "C1", ".", "NumIVMuls", ",", "C1", ".", "NumBaseAdds", ",", "C1", ".", "ScaleCost", ",", "C1", ".", "ImmCost", ",", "C1", ".", "SetupCost", ")", "<", "std", "::", "tie", "(", "C2", ".", "Insns", ",", "C2", ".", "NumRegs", ",", "C2", ".", "AddRecCost", ",", "C2", ".", "NumIVMuls", ",", "C2", ".", "NumBaseAdds", ",", "C2", ".", "ScaleCost", ",", "C2", ".", "ImmCost", ",", "C2", ".", "SetupCost", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "LSR", "cost", "of", "C1", "is", "lower", "than", "C2", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PPCQPXLoadSplat", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "MadeChange", "=", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "MFIE", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "MFIE", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "MFI", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "Splats", ";", "for", "(", "auto", "MBBI", "=", "MBB", "->", "rbegin", "(", ")", ";", "MBBI", "!=", "MBB", "->", "rend", "(", ")", ";", "++", "MBBI", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MBBI", ";", "if", "(", "MI", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MI", "->", "isCall", "(", ")", ")", "{", "Splats", ".", "clear", "(", ")", ";", "continue", ";", "}", "for", "(", "auto", "SI", "=", "Splats", ".", "begin", "(", ")", ";", "SI", "!=", "Splats", ".", "end", "(", ")", ";", ")", "{", "MachineInstr", "*", "SMI", "=", "*", "SI", ";", "Register", "SplatReg", "=", "SMI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "SrcReg", "=", "SMI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", "->", "modifiesRegister", "(", "SrcReg", ",", "TRI", ")", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "SI", "=", "Splats", ".", "erase", "(", "SI", ")", ";", "continue", ";", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "LFSU", ":", "case", "PPC", "::", "LFDU", ":", "case", "PPC", "::", "LFSUX", ":", "case", "PPC", "::", "LFDUX", ":", "case", "PPC", "::", "LFSX", ":", "case", "PPC", "::", "LFDX", ":", "case", "PPC", "::", "LFIWAX", ":", "case", "PPC", "::", "LFIWZX", ":", "if", "(", "SplatReg", "!=", "SrcReg", ")", "{", "unsigned", "SubRegIndex", "=", "TRI", "->", "getSubRegIndex", "(", "SrcReg", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "Register", "SplatSubReg", "=", "TRI", "->", "getSubReg", "(", "SplatReg", ",", "SubRegIndex", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "SplatSubReg", ")", ";", "MI", "->", "substituteRegister", "(", "SrcReg", ",", "SplatReg", ",", "0", ",", "*", "TRI", ")", ";", "}", "SI", "=", "Splats", ".", "erase", "(", "SI", ")", ";", "++", "MBBI", ";", "SMI", "->", "eraseFromParent", "(", ")", ";", "--", "MBBI", ";", "++", "NumSimplified", ";", "MadeChange", "=", "true", ";", "continue", ";", "}", "}", "if", "(", "MI", "->", "modifiesRegister", "(", "SplatReg", ",", "TRI", ")", "||", "(", "SrcReg", "!=", "SplatReg", "&&", "MI", "->", "readsRegister", "(", "SplatReg", ",", "TRI", ")", ")", ")", "{", "SI", "=", "Splats", ".", "erase", "(", "SI", ")", ";", "continue", ";", "}", "++", "SI", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "QVESPLATI", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "QVESPLATIs", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "QVESPLATIb", ")", "continue", ";", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "!=", "0", ")", "continue", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ")", "continue", ";", "Splats", ".", "push_back", "(", "MI", ")", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "4", "0", "1", "PPC::LFS", "PPC::LFD", "PPC::LFSU", "PPC::LFDU", "PPC::LFSUX", "PPC::LFDUX", "PPC::LFSX", "PPC::LFDX", "PPC::LFIWAX", "PPC::LFIWZX", "0", "0", "0", "PPC::QVESPLATI", "PPC::QVESPLATIs", "PPC::QVESPLATIb", "2", "0", "1" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "static", "bool", "visium_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "!", "visium_interrupt_function_p", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "ok", "to", "do", "sibling", "call", "optimization", "for", "the", "specified", "call", "expression", "EXP", ".", "DECL", "will", "be", "the", "called", "function", ",", "or", "NULL", "if", "this", "is", "an", "indirect", "call", "." ]

[ "visium" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isZExtFree", "(", "MVT", "VT1", ",", "MVT", "VT2", ")", "const", "{", "return", "VT1", "==", "MVT", "::", "i32", "&&", "VT2", "==", "MVT", "::", "i64", "&&", "Subtarget", "->", "is64Bit", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "unsigned", "int", "ix86_regmode_natural_size", "(", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "P2HImode", "||", "mode", "==", "P2QImode", ")", "return", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", ";", "return", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "REGMODE_NATURAL_SIZE", "(", "MODE", ")", "." ]

[ "i386", "2" ]

[]

[ "<s>", "void", "Cpu0FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Cpu0InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Cpu0InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SP", "=", "Cpu0", "::", "SP", ";", "unsigned", "ADDiu", "=", "Cpu0", "::", "ADDiu", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "StackSize", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "StackSize", ")", ";", "else", "assert", "(", "\"No expandLargeImm(SP, StackSize, false, TII, MBB, MBBI, dl);\"", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0::SP", "Cpu0::ADDiu", "16", "\"No expandLargeImm(SP, StackSize, false, TII, MBB, MBBI, dl);\"" ]

[]

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

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

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

[]