Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "m32c_extra_memory_constraint", "(", "char", "c", ",", "const", "char", "*", "str", "ATTRIBUTE_UNUSED", ")", "{", "return", "c", "==", "'S'", ";", "}", "</s>" ]

[ "Implements", "EXTRA_MEMORY_CONSTRAINT", ".", "Currently", ",", "we", "only", "use", "strings", "starting", "with", "'S", "'", "." ]

[ "m32c" ]

[]

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

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

[ "M680x0", "\"M680x0 Assembly Printer\"" ]

[]

[ "<s>", "static", "int", "mips_small_data_pattern_1", "(", "rtx", "*", "loc", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "*", "loc", ")", "==", "LO_SUM", ")", "return", "-", "1", ";", "return", "mips_rewrite_small_data_p", "(", "*", "loc", ")", ";", "}", "</s>" ]

[ "A", "for_each_rtx", "callback", "for", "mips_small_data_pattern_p", "." ]

[ "mips", "1" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "ARMHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"ARM hazards don't support scoreboard lookahead\"", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "LastMI", "&&", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "!=", "ARMII", "::", "DomainGeneral", ")", "{", "MachineInstr", "*", "DefMI", "=", "LastMI", ";", "const", "MCInstrDesc", "&", "LastMCID", "=", "LastMI", "->", "getDesc", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "LastMI", "->", "isBarrier", "(", ")", "&&", "!", "(", "TII", ".", "getSubtarget", "(", ")", ".", "isLikeA9", "(", ")", "&&", "LastMI", "->", "mayLoadOrStore", "(", ")", ")", "&&", "(", "LastMCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainGeneral", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "LastMI", ";", "if", "(", "I", "!=", "LastMI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "{", "I", "=", "std", "::", "prev", "(", "I", ")", ";", "DefMI", "=", "&", "*", "I", ";", "}", "}", "if", "(", "TII", ".", "isFpMLxInstruction", "(", "DefMI", "->", "getOpcode", "(", ")", ")", "&&", "(", "TII", ".", "canCauseFpMLxStall", "(", "MI", "->", "getOpcode", "(", ")", ")", "||", "hasRAWHazard", "(", "DefMI", ",", "MI", ",", "TII", ".", "getRegisterInfo", "(", ")", ")", ")", ")", "{", "if", "(", "FpMLxStalls", "==", "0", ")", "FpMLxStalls", "=", "4", ";", "return", "Hazard", ";", "}", "}", "}", "return", "ScoreboardHazardRecognizer", "::", "getHazardType", "(", "SU", ",", "Stalls", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"ARM hazards don't support scoreboard lookahead\"", "ARMII::DomainMask", "ARMII::DomainGeneral", "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainGeneral", "0", "4" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "if", "(", "IsThumb", ")", "EmitThumbMappingSymbol", "(", ")", ";", "else", "EmitARMMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "RegisterAliasInfo", "::", "covers", "(", "const", "RegisterSet", "&", "RRs", ",", "RegisterRef", "RR", ")", "const", "{", "if", "(", "RRs", ".", "count", "(", "RR", ")", ")", "return", "true", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "RR", ".", "Reg", ")", ")", "{", "if", "(", "RR", ".", "Sub", "!=", "0", ")", "return", "RRs", ".", "count", "(", "{", "RR", ".", "Reg", ",", "0", "}", ")", ";", "return", "false", ";", "}", "unsigned", "Reg", "=", "RR", ".", "Sub", "==", "0", "?", "RR", ".", "Reg", ":", "TRI", ".", "getSubReg", "(", "RR", ".", "Reg", ",", "RR", ".", "Sub", ")", ";", "for", "(", "MCSuperRegIterator", "SR", "(", "Reg", ",", "&", "TRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "if", "(", "RRs", ".", "count", "(", "{", "*", "SR", ",", "0", "}", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "this", "register", "bank", "covers", "RC", "." ]

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

[]

[ "<s>", "static", "void", "nvptx_neuter_pars", "(", "parallel", "*", "par", ",", "unsigned", "modes", ",", "unsigned", "outer", ")", "{", "unsigned", "me", "=", "(", "par", "->", "mask", "&", "(", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", "|", "GOMP_DIM_MASK", "(", "GOMP_DIM_VECTOR", ")", ")", ")", ";", "unsigned", "skip_mask", "=", "0", ",", "neuter_mask", "=", "0", ";", "if", "(", "par", "->", "inner", ")", "nvptx_neuter_pars", "(", "par", "->", "inner", ",", "modes", ",", "outer", "|", "me", ")", ";", "for", "(", "unsigned", "mode", "=", "GOMP_DIM_WORKER", ";", "mode", "<=", "GOMP_DIM_VECTOR", ";", "mode", "++", ")", "{", "if", "(", "(", "outer", "|", "me", ")", "&", "GOMP_DIM_MASK", "(", "mode", ")", ")", "{", "}", "else", "if", "(", "!", "(", "modes", "&", "GOMP_DIM_MASK", "(", "mode", ")", ")", ")", "{", "}", "else", "if", "(", "par", "->", "inner_mask", "&", "GOMP_DIM_MASK", "(", "mode", ")", "||", "!", "par", "->", "forked_insn", ")", "neuter_mask", "|=", "GOMP_DIM_MASK", "(", "mode", ")", ";", "else", "if", "(", "!", "par", "->", "parent", "||", "!", "par", "->", "parent", "->", "forked_insn", "||", "par", "->", "parent", "->", "inner_mask", "&", "GOMP_DIM_MASK", "(", "mode", ")", ")", "skip_mask", "|=", "GOMP_DIM_MASK", "(", "mode", ")", ";", "else", "{", "}", "}", "if", "(", "neuter_mask", ")", "{", "int", "ix", ",", "len", ";", "if", "(", "nvptx_optimize", ")", "{", "bb_pair_vec_t", "regions", ";", "nvptx_find_sese", "(", "par", "->", "blocks", ",", "regions", ")", ";", "len", "=", "regions", ".", "length", "(", ")", ";", "for", "(", "ix", "=", "0", ";", "ix", "!=", "len", ";", "ix", "++", ")", "{", "basic_block", "from", "=", "regions", "[", "ix", "]", ".", "first", ";", "basic_block", "to", "=", "regions", "[", "ix", "]", ".", "second", ";", "if", "(", "from", ")", "nvptx_single", "(", "neuter_mask", ",", "from", ",", "to", ")", ";", "else", "gcc_assert", "(", "!", "to", ")", ";", "}", "}", "else", "{", "len", "=", "par", "->", "blocks", ".", "length", "(", ")", ";", "for", "(", "ix", "=", "0", ";", "ix", "!=", "len", ";", "ix", "++", ")", "{", "basic_block", "block", "=", "par", "->", "blocks", "[", "ix", "]", ";", "nvptx_single", "(", "neuter_mask", ",", "block", ",", "block", ")", ";", "}", "}", "}", "if", "(", "skip_mask", ")", "nvptx_skip_par", "(", "skip_mask", ",", "par", ")", ";", "if", "(", "par", "->", "next", ")", "nvptx_neuter_pars", "(", "par", "->", "next", ",", "modes", ",", "outer", ")", ";", "}", "</s>" ]

[ "Neuter", "the", "parallel", "described", "by", "PAR", ".", "We", "recurse", "in", "depth-first", "order", ".", "MODES", "are", "the", "partitioning", "of", "the", "execution", "and", "OUTER", "is", "the", "partitioning", "of", "the", "parallels", "we", "are", "contained", "in", "." ]

[ "nvptx", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "rs6000_destroy_cost_data", "(", "void", "*", "data", ")", "{", "free", "(", "data", ")", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.destroy_cost_data", "." ]

[ "rs6000" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "unsigned", "CPUFSWidth", "=", "Key", ".", "size", "(", ")", ";", "unsigned", "PreferVectorWidthOverride", "=", "0", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"prefer-vector-width\"", ")", ")", "{", "StringRef", "Val", "=", "F", ".", "getFnAttribute", "(", "\"prefer-vector-width\"", ")", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "\",prefer-vector-width=\"", ";", "Key", "+=", "Val", ";", "PreferVectorWidthOverride", "=", "Width", ";", "}", "}", "unsigned", "RequiredVectorWidth", "=", "UINT32_MAX", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"min-legal-vector-width\"", ")", ")", "{", "StringRef", "Val", "=", "F", ".", "getFnAttribute", "(", "\"min-legal-vector-width\"", ")", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "\",min-legal-vector-width=\"", ";", "Key", "+=", "Val", ";", "RequiredVectorWidth", "=", "Width", ";", "}", "}", "FS", "=", "Key", ".", "slice", "(", "CPU", ".", "size", "(", ")", ",", "CPUFSWidth", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ",", "PreferVectorWidthOverride", ",", "RequiredVectorWidth", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"target-features\"", "512", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "0", "\"prefer-vector-width\"", "\"prefer-vector-width\"", "0", "\",prefer-vector-width=\"", "\"min-legal-vector-width\"", "\"min-legal-vector-width\"", "0", "\",min-legal-vector-width=\"", "X86" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_ARM64_WebKit_JS", ":", "RetCC_ARM64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ISD::OutputArg", "ARM64", "ARM64", "16" ]

[]

[ "<s>", "static", "void", "arm_option_restore", "(", "struct", "gcc_options", "*", ",", "struct", "gcc_options", "*", "opts_set", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "arm_configure_build_target", "(", "&", "arm_active_target", ",", "ptr", ",", "opts_set", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_RESTORE", "." ]

[ "arm" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastEmitInst_r", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "bool", "Op0IsKill", ")", "{", "const", "TargetRegisterClass", "*", "UseRC", "=", "(", "RC", "==", "&", "PPC", "::", "GPRCRegClass", "?", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ":", "(", "RC", "==", "&", "PPC", "::", "G8RCRegClass", "?", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ":", "RC", ")", ")", ";", "return", "FastISel", "::", "fastEmitInst_r", "(", "MachineInstOpcode", ",", "UseRC", ",", "Op0", ",", "Op0IsKill", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::GPRCRegClass", "PPC::GPRC_and_GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_and_G8RC_NOX0RegClass" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "int64_t", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "TailCallReturnAddrDelta", ",", "TailCallReturnAddrDelta", "-", "SlotSize", ",", "true", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "TRI", "->", "getBaseRegister", "(", ")", ")", ";", "if", "(", "MF", ".", "getMMI", "(", ")", ".", "hasEHFunclets", "(", ")", ")", "{", "int", "FI", "=", "MFI", ".", "CreateSpillStackObject", "(", "SlotSize", ",", "SlotSize", ")", ";", "X86FI", "->", "setHasSEHFramePtrSave", "(", "true", ")", ";", "X86FI", "->", "setSEHFramePtrSaveIndex", "(", "FI", ")", ";", "}", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "enableInterleavedAccessVectorization", "(", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "matching", "of", "interleaved", "access", "groups", "." ]

[ "SystemZ" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_broadcast", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "elt", ",", "nelt", "=", "d", "->", "nelt", ";", "unsigned", "char", "perm2", "[", "2", "]", ";", "rtx", "temp", ";", "bool", "ok", ";", "if", "(", "!", "d", "->", "one_operand_p", ")", "return", "false", ";", "elt", "=", "d", "->", "perm", "[", "0", "]", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nelt", ";", "++", "i", ")", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "elt", ")", "return", "false", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V2SImode", ":", "case", "V2SFmode", ":", "perm2", "[", "0", "]", "=", "elt", ";", "perm2", "[", "1", "]", "=", "elt", "+", "2", ";", "ok", "=", "expand_vselect_vconcat", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op0", ",", "perm2", ",", "2", ")", ";", "gcc_assert", "(", "ok", ")", ";", "break", ";", "case", "V8QImode", ":", "if", "(", "BYTES_BIG_ENDIAN", ")", "elt", "=", "7", "-", "elt", ";", "elt", "*=", "BITS_PER_UNIT", ";", "temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_extzv", "(", "temp", ",", "gen_lowpart", "(", "DImode", ",", "d", "->", "op0", ")", ",", "GEN_INT", "(", "8", ")", ",", "GEN_INT", "(", "elt", ")", ")", ")", ";", "emit_insn", "(", "gen_mux1_brcst_qi", "(", "d", "->", "target", ",", "gen_lowpart", "(", "QImode", ",", "temp", ")", ")", ")", ";", "break", ";", "case", "V4HImode", ":", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Pattern", "match", "broadcast", "permutations", "." ]

[ "ia64", "2", "0", "1", "0", "1", "2", "2", "7", "8" ]

[]

[ "<s>", "void", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "BPF" ]

[]

[ "<s>", "int", "shift_operator", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "ASHIFT", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "shift", "operator", "." ]

[ "arc", "1", "0" ]

[]

[ "<s>", "bool", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "override", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "default", ":", "return", "Kind", ">=", "FirstLiteralRelocationKind", ";", "case", "PPC", "::", "fixup_ppc_br24", ":", "case", "PPC", "::", "fixup_ppc_br24abs", ":", "case", "PPC", "::", "fixup_ppc_br24_notoc", ":", "if", "(", "const", "MCSymbolRefExpr", "*", "A", "=", "Target", ".", "getSymA", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "S", "=", "dyn_cast", "<", "MCSymbolELF", ">", "(", "&", "A", "->", "getSymbol", "(", ")", ")", ")", "{", "unsigned", "Other", "=", "S", "->", "getOther", "(", ")", "<<", "2", ";", "if", "(", "(", "Other", "&", "ELF", "::", "STO_PPC64_LOCAL_MASK", ")", "!=", "0", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "PowerPC", "PPC::fixup_ppc_br24", "PPC::fixup_ppc_br24abs", "PPC::fixup_ppc_br24_notoc", "2", "PPC", "0" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIOptimizeExecMaskingPreRAID", ")", ";", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "SILowerControlFlowID", ",", "&", "SIFixWWMLivenessID", ",", "false", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", "RegAllocPass", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "pair", "<", "const", "Value", "*", ",", "unsigned", ">", "AMDGPUTargetMachine", "::", "getPredicatedAddrSpace", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "auto", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_is_shared", ":", "return", "std", "::", "make_pair", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", ";", "case", "Intrinsic", "::", "amdgcn_is_private", ":", "return", "std", "::", "make_pair", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", ";", "default", ":", "break", ";", "}", "return", "std", "::", "make_pair", "(", "nullptr", ",", "-", "1", ")", ";", "}", "Value", "*", "Ptr", ";", "if", "(", "match", "(", "const_cast", "<", "Value", "*", ">", "(", "V", ")", ",", "m_c_And", "(", "m_Not", "(", "m_Intrinsic", "<", "Intrinsic", "::", "amdgcn_is_shared", ">", "(", "m_Value", "(", "Ptr", ")", ")", ")", ",", "m_Not", "(", "m_Intrinsic", "<", "Intrinsic", "::", "amdgcn_is_private", ">", "(", "m_Deferred", "(", "Ptr", ")", ")", ")", ")", ")", ")", "return", "std", "::", "make_pair", "(", "Ptr", ",", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", ";", "return", "std", "::", "make_pair", "(", "nullptr", ",", "-", "1", ")", ";", "}", "</s>" ]

[ "If", "the", "specified", "predicate", "checks", "whether", "a", "generic", "pointer", "falls", "within", "a", "specified", "address", "space", ",", "return", "that", "generic", "pointer", "and", "the", "address", "space", "being", "queried", "." ]

[ "AMDGPU", "AMDGPU", "Intrinsic::amdgcn_is_shared", "0", "AMDGPU", "Intrinsic::amdgcn_is_private", "0", "AMDGPU", "1", "Intrinsic::amdgcn_is_shared", "Intrinsic::amdgcn_is_private", "AMDGPU", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Hardware Loop Fixup\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Hardware Loop Fixup\"" ]

[]

[ "<s>", "void", "push_back", "(", "Value", "*", "V", ")", "{", "if", "(", "!", "S", ".", "count", "(", "V", ")", ")", "{", "Q", ".", "push_back", "(", "V", ")", ";", "S", ".", "insert", "(", "V", ")", ";", "}", "}", "</s>" ]

[ "Insert", "a", "node", "at", "the", "back", ";", "never", "copies", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "releaseBottomNode", "(", "SUnit", "*", "SU", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Bottom Releasing \"", ";", "SU", "->", "dump", "(", "DAG", ")", ";", ")", ";", "if", "(", "isPhysicalRegCopy", "(", "SU", "->", "getInstr", "(", ")", ")", ")", "{", "PhysicalRegCopy", ".", "push_back", "(", "SU", ")", ";", "return", ";", "}", "int", "IK", "=", "getInstKind", "(", "SU", ")", ";", "if", "(", "IK", "==", "IDOther", ")", "Available", "[", "IDOther", "]", ".", "push_back", "(", "SU", ")", ";", "else", "Pending", "[", "IK", "]", ".", "push_back", "(", "SU", ")", ";", "}", "</s>" ]

[ "Currently", "only", "scheduling", "top-down", ",", "so", "this", "method", "is", "empty", "." ]

[ "R600", "\"Bottom Releasing \"" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "SelectConstant", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "ConstantFP", ":", "SelectConstantFP", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "FrameIndex", ":", "SelectFrameIndex", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "ADD", ":", "SelectAdd", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "SHL", ":", "SelectSHL", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "SelectLoad", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "STORE", ":", "SelectStore", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "MUL", ":", "SelectMul", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FNEG", ":", "SelectBitOp", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "SelectZeroExtend", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "SelectIntrinsicWChain", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "SelectIntrinsicWOChain", "(", "N", ")", ";", "return", ";", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::FrameIndex", "ISD::ADD", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::FABS", "ISD::FNEG", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "rtx", "arm_function_arg", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "int", "nregs", ";", "if", "(", "TARGET_IWMMXT_ABI", "&&", "arm_vector_mode_supported_p", "(", "mode", ")", "&&", "pcum", "->", "named_count", ">", "pcum", "->", "nargs", "+", "1", ")", "{", "if", "(", "pcum", "->", "iwmmxt_nregs", "<=", "9", ")", "return", "gen_rtx_REG", "(", "mode", ",", "pcum", "->", "iwmmxt_nregs", "+", "FIRST_IWMMXT_REGNUM", ")", ";", "else", "{", "pcum", "->", "can_split", "=", "false", ";", "return", "NULL_RTX", ";", "}", "}", "if", "(", "pcum", "->", "nregs", "&", "1", "&&", "ARM_DOUBLEWORD_ALIGN", "&&", "arm_needs_doubleword_align", "(", "mode", ",", "type", ")", ")", "pcum", "->", "nregs", "++", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "GEN_INT", "(", "pcum", "->", "call_cookie", ")", ";", "if", "(", "pcum", "->", "can_split", ")", "nregs", "=", "1", ";", "else", "nregs", "=", "ARM_NUM_REGS2", "(", "mode", ",", "type", ")", ";", "if", "(", "!", "named", "||", "pcum", "->", "nregs", "+", "nregs", ">", "NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "mode", ",", "pcum", "->", "nregs", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "the", "ARM", ",", "normally", "the", "first", "16", "bytes", "are", "passed", "in", "registers", "r0-r3", ";", "all", "other", "arguments", "are", "passed", "on", "the", "stack", ".", "If", "(", "NAMED", "==", "0", ")", "(", "which", "happens", "only", "in", "assign_parms", ",", "since", "TARGET_SETUP_INCOMING_VARARGS", "is", "defined", ")", ",", "say", "it", "is", "passed", "in", "the", "stack", "(", "function_prologue", "will", "indeed", "make", "it", "pass", "in", "the", "stack", "if", "necessary", ")", "." ]

[ "arm", "1", "9", "1", "1" ]

[]

[ "<s>", "static", "inline", "bool", "offset_below_red_zone_p", "(", "HOST_WIDE_INT", "offset", ")", "{", "return", "offset", "<", "(", "DEFAULT_ABI", "==", "ABI_V4", "?", "0", ":", "TARGET_32BIT", "?", "-", "220", ":", "-", "288", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "from", "stack", "pointer", "can", "be", "clobbered", "by", "signals", ".", "V.4", "does", "n't", "have", "any", "stack", "cushion", ",", "AIX", "ABIs", "have", "220", "or", "288", "bytes", "below", "stack", "pointer", "not", "cloberred", "by", "signals", "." ]

[ "powerpcspe", "0", "220", "288" ]

[]

[ "<s>", "int", "arc_return_slot_offset", "(", ")", "{", "struct", "arc_frame_info", "*", "afi", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "return", "(", "afi", "->", "save_return_addr", "?", "afi", "->", "total_size", "-", "afi", "->", "pretend_size", "-", "afi", "->", "extra_size", ":", "-", "1", ")", ";", "}", "</s>" ]

[ "Return", "the", "offset", "relative", "to", "the", "stack", "pointer", "where", "the", "return", "address", "is", "stored", ",", "or", "-1", "if", "it", "is", "not", "stored", "." ]

[ "arc", "1" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilderBase", "&", "Builder", ",", "Type", "*", "ValueTy", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValueTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxp", ":", "Intrinsic", "::", "aarch64_ldxp", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValueTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValueTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValueTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "const", "DataLayout", "&", "DL", "=", "M", "->", "getDataLayout", "(", ")", ";", "IntegerType", "*", "IntEltTy", "=", "Builder", ".", "getIntNTy", "(", "DL", ".", "getTypeSizeInBits", "(", "ValueTy", ")", ")", ";", "if", "(", "ValueTy", "->", "isPointerTy", "(", ")", ")", "Addr", "=", "Builder", ".", "CreatePointerCast", "(", "Addr", ",", "IntEltTy", "->", "getPointerTo", "(", "Addr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "Value", "*", "Trunc", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "IntEltTy", ")", ";", "assert", "(", "!", "DL", ".", "isFatPointer", "(", "ValueTy", ")", "&&", "\"Should not be handled here!\"", ")", ";", "if", "(", "ValueTy", "->", "isPointerTy", "(", ")", ")", "return", "Builder", ".", "CreateIntToPtr", "(", "Trunc", ",", "ValueTy", ")", ";", "return", "Builder", ".", "CreateBitCast", "(", "Trunc", ",", "ValueTy", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_ldaxp", "Intrinsic::aarch64_ldxp", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "Intrinsic::getDeclaration", "\"Should not be handled here!\"" ]

[]

[ "<s>", "void", "SystemZXPLINKFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "Subtarget", ".", "getInstrInfo", "(", ")", ")", ";", "auto", "&", "Regs", "=", "Subtarget", ".", "getSpecialRegisters", "<", "SystemZXPLINK64Registers", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineInstr", "*", "StoreInstr", "=", "nullptr", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "DebugLoc", "DL", ";", "uint64_t", "Offset", "=", "0", ";", "MFFrame", ".", "setStackSize", "(", "MFFrame", ".", "getStackSize", "(", ")", "+", "Regs", ".", "getCallFrameSize", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFFrame", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", ">", "1024", "*", "1024", ")", "{", "llvm_unreachable", "(", "\"Huge Stack Frame not yet supported on z/OS\"", ")", ";", "}", "if", "(", "ZFI", "->", "getSpillGPRRegs", "(", ")", ".", "LowGPR", ")", "{", "if", "(", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "&&", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "STMG", ")", ")", ")", "{", "const", "int", "Operand", "=", "3", ";", "Offset", "=", "Regs", ".", "getStackPointerBias", "(", ")", "+", "MBBI", "->", "getOperand", "(", "Operand", ")", ".", "getImm", "(", ")", ";", "if", "(", "isInt", "<", "20", ">", "(", "Offset", "-", "StackSize", ")", ")", "Offset", "-=", "StackSize", ";", "else", "StoreInstr", "=", "&", "*", "MBBI", ";", "MBBI", "->", "getOperand", "(", "Operand", ")", ".", "setImm", "(", "Offset", ")", ";", "++", "MBBI", ";", "}", "else", "llvm_unreachable", "(", "\"Couldn't skip over GPR saves\"", ")", ";", "}", "if", "(", "StackSize", ")", "{", "MachineBasicBlock", "::", "iterator", "InsertPt", "=", "StoreInstr", "?", "StoreInstr", ":", "MBBI", ";", "int64_t", "Delta", "=", "-", "int64_t", "(", "StackSize", ")", ";", "if", "(", "StoreInstr", "&&", "HasFP", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "LGR", ")", ")", ".", "addReg", "(", "SystemZ", "::", "R0D", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "SystemZ", "::", "R4D", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "STG", ")", ")", ".", "addReg", "(", "SystemZ", "::", "R0D", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "SystemZ", "::", "R4D", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "0", ")", ";", "}", "emitIncrement", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "Regs", ".", "getStackPointerRegister", "(", ")", ",", "Delta", ",", "ZII", ")", ";", "}", "if", "(", "HasFP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "LGR", ")", ",", "Regs", ".", "getFramePointerRegister", "(", ")", ")", ".", "addReg", "(", "Regs", ".", "getStackPointerRegister", "(", ")", ")", ";", "for", "(", "auto", "I", "=", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "Regs", ".", "getFramePointerRegister", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Shrink-wrapping not yet supported\"", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "1024", "1024", "\"Huge Stack Frame not yet supported on z/OS\"", "SystemZ::STMG", "3", "20", "\"Couldn't skip over GPR saves\"", "SystemZ::LGR", "SystemZ::R0D", "SystemZ::R4D", "SystemZ::STG", "SystemZ::R0D", "SystemZ::R4D", "0", "SystemZ::LGR" ]

[]

[ "<s>", "static", "void", "recombine_stvx_pattern", "(", "rtx_insn", "*", "insn", ",", "del_info", "*", "to_delete", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_DEST", "(", "body", ")", ")", "==", "MEM", "&&", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", ")", ";", "rtx", "mem", "=", "SET_DEST", "(", "body", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "rtx_insn", "*", "and_insn", ";", "rtx", "and_operation", "=", "find_alignment_op", "(", "insn", ",", "base_reg", ",", "&", "and_insn", ")", ";", "if", "(", "and_operation", "!=", "0", ")", "{", "rtx", "src_reg", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "df_ref", "src_use", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "FOR_EACH_INSN_INFO_USE", "(", "src_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "src_use", ")", ",", "src_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "src_use", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "rtx", "and_base", "=", "XEXP", "(", "and_operation", ",", "0", ")", ";", "rtx", "new_reg", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "and_base", ")", ")", ";", "rtx", "copy", "=", "gen_rtx_SET", "(", "new_reg", ",", "and_base", ")", ";", "rtx_insn", "*", "new_insn", "=", "emit_insn_after", "(", "copy", ",", "and_insn", ")", ";", "set_block_for_insn", "(", "new_insn", ",", "BLOCK_FOR_INSN", "(", "and_insn", ")", ")", ";", "df_insn_rescan", "(", "new_insn", ")", ";", "XEXP", "(", "mem", ",", "0", ")", "=", "gen_rtx_AND", "(", "GET_MODE", "(", "and_base", ")", ",", "new_reg", ",", "XEXP", "(", "and_operation", ",", "1", ")", ")", ";", "SET_SRC", "(", "body", ")", "=", "src_reg", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"stvx opportunity found at %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "INSN", "is", "the", "store", "for", "an", "stvx", "pattern", ",", "put", "it", "in", "canonical", "form", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "1", "1", "\"stvx opportunity found at %d\\n\"" ]

[]

[ "<s>", "void", "UnwindOpcodeAssembler", "::", "EmitVFPRegSave", "(", "uint32_t", "VFPRegSave", ")", "{", "for", "(", "uint32_t", "Regs", ":", "{", "VFPRegSave", "&", "0xffff0000u", ",", "VFPRegSave", "&", "0x0000ffffu", "}", ")", "{", "while", "(", "Regs", ")", "{", "auto", "RangeMSB", "=", "32", "-", "countLeadingZeros", "(", "Regs", ")", ";", "auto", "RangeLen", "=", "countLeadingOnes", "(", "Regs", "<<", "(", "32", "-", "RangeMSB", ")", ")", ";", "auto", "RangeLSB", "=", "RangeMSB", "-", "RangeLen", ";", "int", "Opcode", "=", "RangeLSB", ">=", "16", "?", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_VFP_REG_RANGE_FSTMFDD_D16", ":", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_VFP_REG_RANGE_FSTMFDD", ";", "EmitInt16", "(", "Opcode", "|", "(", "(", "RangeLSB", "%", "16", ")", "<<", "4", ")", "|", "(", "RangeLen", "-", "1", ")", ")", ";", "Regs", "&=", "~", "(", "-", "1u", "<<", "RangeLSB", ")", ";", "}", "}", "}", "</s>" ]

[ "Emit", "unwind", "opcodes", "for", ".vsave", "directives", "." ]

[ "ARM", "0xffff0000u", "0x0000ffffu", "32", "32", "16", "ARM::EHABI", "ARM::EHABI", "16", "4", "1", "1u" ]

[]

[ "<s>", "static", "void", "cr16_compute_frame", "(", "void", ")", "{", "int", "stack_alignment", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "int", "padding_locals", ";", "current_frame_info", ".", "var_size", "=", "get_frame_size", "(", ")", ";", "padding_locals", "=", "current_frame_info", ".", "var_size", "%", "stack_alignment", ";", "if", "(", "padding_locals", ")", "padding_locals", "=", "stack_alignment", "-", "padding_locals", ";", "current_frame_info", ".", "var_size", "+=", "padding_locals", ";", "current_frame_info", ".", "total_size", "=", "(", "current_frame_info", ".", "var_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "(", "HOST_WIDE_INT", ")", "crtl", "->", "outgoing_args_size", ":", "0", ")", ")", ";", "}", "</s>" ]

[ "Compute", "the", "size", "of", "the", "local", "area", "and", "the", "size", "to", "be", "adjusted", "by", "the", "prologue", "and", "epilogue", "." ]

[ "cr16", "0" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "unsigned", "OpId", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "OpId", "=", "0", ";", "if", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "0", ")", "return", "false", ";", "break", ";", "case", "ARM", "::", "MVE_WLSTP_8", ":", "case", "ARM", "::", "MVE_WLSTP_16", ":", "case", "ARM", "::", "MVE_WLSTP_32", ":", "case", "ARM", "::", "MVE_WLSTP_64", ":", "case", "ARM", "::", "t2WLS", ":", "case", "ARM", "::", "MVE_LETP", ":", "case", "ARM", "::", "t2LEUpdate", ":", "OpId", "=", "2", ";", "break", ";", "case", "ARM", "::", "t2LE", ":", "OpId", "=", "1", ";", "break", ";", "}", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpId", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "OpId", ")", ".", "getImm", "(", ")", "+", "4", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "ARM", "0", "0", "ARM::MVE_WLSTP_8", "ARM::MVE_WLSTP_16", "ARM::MVE_WLSTP_32", "ARM::MVE_WLSTP_64", "ARM::t2WLS", "ARM::MVE_LETP", "ARM::t2LEUpdate", "2", "ARM::t2LE", "1", "4" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "mips_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", ")", "{", "if", "(", "EABI_FLOAT_VARARGS_P", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", ";", "tree", "f_ovfl", ",", "f_gtop", ",", "f_ftop", ",", "f_goff", ",", "f_foff", ";", "tree", "ovfl", ",", "gtop", ",", "ftop", ",", "goff", ",", "foff", ";", "tree", "t", ";", "int", "gpr_save_area_size", ";", "int", "fpr_save_area_size", ";", "int", "fpr_offset", ";", "cum", "=", "&", "current_function_args_info", ";", "gpr_save_area_size", "=", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "num_gprs", ")", "*", "UNITS_PER_WORD", ";", "fpr_save_area_size", "=", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "num_fprs", ")", "*", "UNITS_PER_FPREG", ";", "f_ovfl", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_gtop", "=", "TREE_CHAIN", "(", "f_ovfl", ")", ";", "f_ftop", "=", "TREE_CHAIN", "(", "f_gtop", ")", ";", "f_goff", "=", "TREE_CHAIN", "(", "f_ftop", ")", ";", "f_foff", "=", "TREE_CHAIN", "(", "f_goff", ")", ";", "ovfl", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ovfl", ")", ",", "valist", ",", "f_ovfl", ",", "NULL_TREE", ")", ";", "gtop", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_gtop", ")", ",", "valist", ",", "f_gtop", ",", "NULL_TREE", ")", ";", "ftop", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ftop", ")", ",", "valist", ",", "f_ftop", ",", "NULL_TREE", ")", ";", "goff", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_goff", ")", ",", "valist", ",", "f_goff", ",", "NULL_TREE", ")", ";", "foff", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_foff", ")", ",", "valist", ",", "f_foff", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovfl", ")", ",", "virtual_incoming_args_rtx", ")", ";", "if", "(", "cum", "->", "stack_words", ">", "0", ")", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "ovfl", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "cum", "->", "stack_words", "*", "UNITS_PER_WORD", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ovfl", ")", ",", "ovfl", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "gtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "gtop", ")", ",", "gtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ftop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "fpr_offset", "=", "gpr_save_area_size", "+", "UNITS_PER_FPVALUE", "-", "1", ";", "fpr_offset", "&=", "~", "(", "UNITS_PER_FPVALUE", "-", "1", ")", ";", "if", "(", "fpr_offset", ")", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "ftop", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "-", "fpr_offset", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ftop", ")", ",", "ftop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "goff", ")", ",", "goff", ",", "build_int_cst", "(", "NULL_TREE", ",", "gpr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "foff", ")", ",", "foff", ",", "build_int_cst", "(", "NULL_TREE", ",", "fpr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "{", "nextarg", "=", "plus_constant", "(", "nextarg", ",", "-", "cfun", "->", "machine", "->", "varargs_size", ")", ";", "std_expand_builtin_va_start", "(", "valist", ",", "nextarg", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "csky_configure_build_target", "(", "struct", "csky_build_target", "*", "target", ",", "struct", "cl_target_option", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "const", "struct", "csky_processors", "*", "csky_selected_tune", "=", "NULL", ";", "struct", "csky_processors", "*", "csky_selected_cpu", "=", "NULL", ";", "struct", "csky_processors", "*", "csky_selected_arch", "=", "NULL", ";", "sbitmap", "all_sbits", "=", "sbitmap_alloc", "(", "CSKY_ISA_FEATURE_GET", "(", "max", ")", ")", ";", "bitmap_clear", "(", "all_sbits", ")", ";", "bitmap_clear", "(", "target", "->", "isa", ")", ";", "target", "->", "core_name", "=", "NULL", ";", "target", "->", "arch_name", "=", "NULL", ";", "if", "(", "opts_set", "->", "x_csky_arch_option", ")", "csky_selected_arch", "=", "&", "all_architectures", "[", "opts", "->", "x_csky_arch_option", "]", ";", "if", "(", "opts_set", "->", "x_csky_cpu_option", ")", "{", "csky_selected_cpu", "=", "&", "all_cores", "[", "opts", "->", "x_csky_cpu_option", "]", ";", "csky_selected_tune", "=", "&", "all_cores", "[", "opts", "->", "x_csky_cpu_option", "]", ";", "}", "if", "(", "csky_selected_cpu", ")", "{", "if", "(", "csky_selected_arch", "&&", "(", "csky_selected_cpu", "->", "base_arch", "!=", "csky_selected_arch", "->", "base_arch", ")", ")", "warning", "(", "0", ",", "\"cpu %s is not based on arch %s, ignoring the arch\"", ",", "csky_selected_cpu", "->", "name", ",", "csky_selected_arch", "->", "name", ")", ";", "if", "(", "!", "csky_selected_arch", ")", "csky_selected_arch", "=", "&", "all_architectures", "[", "csky_selected_cpu", "->", "base_arch", "]", ";", "csky_initialize_isa", "(", "all_sbits", ",", "csky_selected_arch", "->", "isa_bits", ")", ";", "target", "->", "core_name", "=", "csky_selected_cpu", "->", "name", ";", "}", "else", "if", "(", "csky_selected_arch", ")", "{", "csky_selected_cpu", "=", "csky_selected_arch", ";", "target", "->", "arch_name", "=", "csky_selected_arch", "->", "name", ";", "}", "else", "{", "csky_selected_cpu", "=", "&", "all_cores", "[", "TARGET_CPU_DEFAULT", "]", ";", "csky_selected_arch", "=", "&", "all_architectures", "[", "csky_selected_cpu", "->", "base_arch", "]", ";", "csky_initialize_isa", "(", "all_sbits", ",", "csky_selected_arch", "->", "isa_bits", ")", ";", "target", "->", "core_name", "=", "csky_selected_cpu", "->", "name", ";", "}", "if", "(", "!", "csky_selected_tune", ")", "csky_selected_tune", "=", "&", "all_cores", "[", "csky_selected_cpu", "->", "core", "]", ";", "gcc_assert", "(", "csky_selected_tune", ")", ";", "gcc_assert", "(", "csky_selected_arch", ")", ";", "gcc_assert", "(", "csky_selected_cpu", ")", ";", "csky_initialize_isa", "(", "target", "->", "isa", ",", "csky_selected_cpu", "->", "isa_bits", ")", ";", "bitmap_ior", "(", "target", "->", "isa", ",", "target", "->", "isa", ",", "all_sbits", ")", ";", "target", "->", "arch_pp_name", "=", "csky_selected_cpu", "->", "arch", ";", "target", "->", "base_arch", "=", "csky_selected_cpu", "->", "base_arch", ";", "target", "->", "arch_core", "=", "csky_selected_cpu", "->", "core", ";", "sbitmap_free", "(", "all_sbits", ")", ";", "}", "</s>" ]

[ "Configure", "a", "build", "target", "TARGET", "from", "the", "user-specified", "options", "OPTS", "and", "OPTS_SET", "." ]

[ "csky", "0", "\"cpu %s is not based on arch %s, ignoring the arch\"" ]

[]

[ "<s>", "int", "i386_pe_dllimport_name_p", "(", "const", "char", "*", "symbol", ")", "{", "return", "(", "strncmp", "(", "DLL_IMPORT_PREFIX", ",", "symbol", ",", "strlen", "(", "DLL_IMPORT_PREFIX", ")", ")", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "SYMBOL", "is", "marked", "as", "being", "dllimport", "'d", "." ]

[ "i386", "0" ]

[]

[ "<s>", "static", "void", "s390_expand_cs_tdsi", "(", "machine_mode", "mode", ",", "rtx", "btarget", ",", "rtx", "vtarget", ",", "rtx", "mem", ",", "rtx", "cmp", ",", "rtx", "new_rtx", ",", "bool", "is_weak", ")", "{", "rtx", "output", "=", "vtarget", ";", "rtx_code_label", "*", "skip_cs_label", "=", "NULL", ";", "bool", "do_const_opt", "=", "false", ";", "if", "(", "!", "register_operand", "(", "output", ",", "mode", ")", ")", "output", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "TARGET_Z196", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", ")", "do_const_opt", "=", "(", "is_weak", "&&", "CONST_INT_P", "(", "cmp", ")", ")", ";", "if", "(", "do_const_opt", ")", "{", "const", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx", "cc", "=", "gen_rtx_REG", "(", "CCZmode", ",", "CC_REGNUM", ")", ";", "skip_cs_label", "=", "gen_label_rtx", "(", ")", ";", "emit_move_insn", "(", "btarget", ",", "const0_rtx", ")", ";", "if", "(", "CONST_INT_P", "(", "cmp", ")", "&&", "INTVAL", "(", "cmp", ")", "==", "0", ")", "{", "rtvec", "lt", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "lt", ",", "0", ")", "=", "gen_rtx_SET", "(", "cc", ",", "gen_rtx_COMPARE", "(", "CCZmode", ",", "mem", ",", "cmp", ")", ")", ";", "RTVEC_ELT", "(", "lt", ",", "1", ")", "=", "gen_rtx_SET", "(", "output", ",", "mem", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "lt", ")", ")", ";", "}", "else", "{", "emit_move_insn", "(", "output", ",", "mem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cc", ",", "gen_rtx_COMPARE", "(", "CCZmode", ",", "output", ",", "cmp", ")", ")", ")", ";", "}", "s390_emit_jump", "(", "skip_cs_label", ",", "gen_rtx_NE", "(", "VOIDmode", ",", "cc", ",", "const0_rtx", ")", ")", ";", "add_int_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "cmp", "=", "output", ";", "}", "else", "cmp", "=", "force_reg", "(", "mode", ",", "cmp", ")", ";", "new_rtx", "=", "force_reg", "(", "mode", ",", "new_rtx", ")", ";", "s390_emit_compare_and_swap", "(", "EQ", ",", "output", ",", "mem", ",", "cmp", ",", "new_rtx", ",", "(", "do_const_opt", ")", "?", "CCZmode", ":", "CCZ1mode", ")", ";", "if", "(", "skip_cs_label", "!=", "NULL", ")", "emit_label", "(", "skip_cs_label", ")", ";", "if", "(", "output", "!=", "vtarget", ")", "emit_move_insn", "(", "vtarget", ",", "output", ")", ";", "if", "(", "do_const_opt", ")", "{", "rtx", "cc", ",", "cond", ",", "ite", ";", "cc", "=", "gen_rtx_REG", "(", "CCZmode", ",", "CC_REGNUM", ")", ";", "cond", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "cc", ",", "const0_rtx", ")", ";", "ite", "=", "gen_rtx_IF_THEN_ELSE", "(", "SImode", ",", "cond", ",", "const1_rtx", ",", "btarget", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "btarget", ",", "ite", ")", ")", ";", "}", "else", "{", "rtx", "cc", ",", "cond", ";", "cc", "=", "gen_rtx_REG", "(", "CCZ1mode", ",", "CC_REGNUM", ")", ";", "cond", "=", "gen_rtx_EQ", "(", "SImode", ",", "cc", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_cstorecc4", "(", "btarget", ",", "cond", ",", "cc", ",", "const0_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Variant", "of", "s390_expand_cs", "for", "SI", ",", "DI", "and", "TI", "modes", "." ]

[ "s390", "100", "1", "0", "2", "0", "1" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "PPCInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "PPCII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_PLT", ",", "\"ppc-plt\"", "}", ",", "{", "MO_PIC_FLAG", ",", "\"ppc-pic\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "PowerPC", "PPC", "PPC", "\"ppc-plt\"", "\"ppc-pic\"" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "DataTy", ")", "{", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", "&&", "!", "isPowerOf2_32", "(", "DataTy", "->", "getVectorNumElements", "(", ")", ")", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "DataWidth", ">=", "32", "&&", "ST", "->", "hasAVX512", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

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

[]

[ "<s>", "bool", "PPCAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "std", "::", "string", "NewOpcode", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Plus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "NewOpcode", "=", "Name", ";", "NewOpcode", "+=", "'+'", ";", "Name", "=", "NewOpcode", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Minus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "NewOpcode", "=", "Name", ";", "NewOpcode", "+=", "'-'", ";", "Name", "=", "NewOpcode", ";", "}", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "0", ",", "Dot", ")", ";", "if", "(", "!", "NewOpcode", ".", "empty", "(", ")", ")", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateTokenWithStringCopy", "(", "Mnemonic", ",", "NameLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "else", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "if", "(", "Dot", "!=", "StringRef", "::", "npos", ")", "{", "SMLoc", "DotLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Dot", ")", ";", "StringRef", "DotStr", "=", "Name", ".", "slice", "(", "Dot", ",", "StringRef", "::", "npos", ")", ";", "if", "(", "!", "NewOpcode", ".", "empty", "(", ")", ")", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateTokenWithStringCopy", "(", "DotStr", ",", "DotLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "else", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "DotStr", ",", "DotLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "if", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureBookE", "]", "&&", "Operands", ".", "size", "(", ")", "==", "4", "&&", "(", "Name", "==", "\"dcbt\"", "||", "Name", "==", "\"dcbtst\"", ")", ")", "{", "std", "::", "swap", "(", "Operands", "[", "1", "]", ",", "Operands", "[", "3", "]", ")", ";", "std", "::", "swap", "(", "Operands", "[", "2", "]", ",", "Operands", "[", "1", "]", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC::FeatureBookE", "4", "\"dcbt\"", "\"dcbtst\"", "1", "3", "2", "1" ]

[]

[ "<s>", "void", "AArch64AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "Ctx", ",", "TheTriple", ",", "IsResolved", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "FulleSizeInBytes", "-", "1", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid fixup offset!\"", "0", "0", "8", "0xff", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "static", "void", "replace_constant_pool_ref", "(", "rtx", "*", "x", ",", "rtx", "ref", ",", "rtx", "offset", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "gcc_assert", "(", "*", "x", "!=", "ref", ")", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "*", "x", ",", "1", ")", "==", "UNSPEC_LTREF", "&&", "XVECEXP", "(", "*", "x", ",", "0", ",", "0", ")", "==", "ref", ")", "{", "*", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XVECEXP", "(", "*", "x", ",", "0", ",", "1", ")", ",", "offset", ")", ";", "return", ";", "}", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_LTREF", "&&", "XVECEXP", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "0", ",", "0", ")", "==", "ref", ")", "{", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XVECEXP", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "0", ",", "1", ")", ",", "offset", ")", ";", "*", "x", "=", "plus_constant", "(", "Pmode", ",", "addr", ",", "INTVAL", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", ")", ";", "return", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "*", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "*", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "replace_constant_pool_ref", "(", "&", "XEXP", "(", "*", "x", ",", "i", ")", ",", "ref", ",", "offset", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "*", "x", ",", "i", ")", ";", "j", "++", ")", "replace_constant_pool_ref", "(", "&", "XVECEXP", "(", "*", "x", ",", "i", ",", "j", ")", ",", "ref", ",", "offset", ")", ";", "}", "}", "}", "</s>" ]

[ "Replace", "every", "reference", "to", "the", "annotated", "literal", "pool", "symbol", "REF", "in", "X", "by", "its", "base", "plus", "OFFSET", "." ]

[ "s390", "1", "0", "0", "0", "1", "1", "0", "0", "1", "0", "0", "0", "0", "0", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "void", "SIAssignInterpRegsPass", "::", "addLiveIn", "(", "MachineFunction", "*", "MF", ",", "MachineRegisterInfo", "&", "MRI", ",", "unsigned", "physReg", ",", "unsigned", "virtReg", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "MRI", ".", "isLiveIn", "(", "physReg", ")", ")", "{", "MRI", ".", "addLiveIn", "(", "physReg", ",", "virtReg", ")", ";", "MF", "->", "front", "(", ")", ".", "addLiveIn", "(", "physReg", ")", ";", "BuildMI", "(", "MF", "->", "front", "(", ")", ",", "MF", "->", "front", "(", ")", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "virtReg", ")", ".", "addReg", "(", "physReg", ")", ";", "}", "else", "{", "MRI", ".", "replaceRegWith", "(", "virtReg", ",", "MRI", ".", "getLiveInVirtReg", "(", "physReg", ")", ")", ";", "}", "}", "</s>" ]

[ "addLiveIn", "-", "Add", "the", "specified", "register", "as", "a", "live-in", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "struct", "sparc_args", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "cum", "->", "words", "=", "0", ";", "cum", "->", "prototype_p", "=", "fntype", "&&", "prototype_p", "(", "fntype", ")", ";", "cum", "->", "libcall_p", "=", "fntype", "==", "0", ";", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

[ "sparc", "0", "0" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "AArch64", "architecture", "model", "." ]

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

[]

[ "<s>", "void", "F2003fMCAsmStreamer", "::", "emitValueToOffset", "(", "const", "MCExpr", "*", "Offset", ",", "unsigned", "char", "Value", ",", "SMLoc", "Loc", ")", "{", "llvm_unreachable", "(", "\"2003lk doesn't support this directive\"", ")", ";", "}", "</s>" ]

[ "Emit", "some", "number", "of", "copies", "of", "Value", "until", "the", "byte", "offset", "Offset", "is", "reached", "." ]

[ "F2003f", "F2003f", "\"2003lk doesn't support this directive\"" ]

[]

[ "<s>", "static", "const", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ")", "{", "Triple", "TheTriple", "(", "TT", ")", ";", "bool", "isPPC64", "=", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64", ";", "if", "(", "TheTriple", ".", "getOS", "(", ")", "==", "Triple", "::", "Darwin", ")", "return", "new", "PPCMCAsmInfoDarwin", "(", "isPPC64", ")", ";", "return", "new", "PPCLinuxMCAsmInfo", "(", "isPPC64", ")", ";", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

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

[]

[ "<s>", "void", "BlackfinRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "Amount", "%", "4", "==", "0", "&&", "\"Unaligned call frame size\"", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "BF", "::", "ADJCALLSTACKDOWN", ")", "{", "adjustRegister", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "I", "->", "getOpcode", "(", ")", "==", "BF", "::", "ADJCALLSTACKUP", "&&", "\"Unknown call frame pseudo instruction\"", ")", ";", "adjustRegister", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "Amount", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "0", "0", "4", "0", "\"Unaligned call frame size\"", "BF::ADJCALLSTACKDOWN", "BF::SP", "BF::P1", "BF::ADJCALLSTACKUP", "\"Unknown call frame pseudo instruction\"", "BF::SP", "BF::P1" ]

[]

[ "<s>", "bool", "M68kOperand", "::", "isReg", "(", ")", "const", "{", "return", "Kind", "==", "Kind", "::", "MemOp", "&&", "MemOp", ".", "Op", "==", "M68kMemOp", "::", "Kind", "::", "Reg", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "M68k", "M68k", "M68kMemOp::Kind" ]

[]

[ "<s>", "static", "void", "riscv_emit_int_order_test", "(", "enum", "rtx_code", "code", ",", "bool", "*", "invert_ptr", ",", "rtx", "target", ",", "rtx", "cmp0", ",", "rtx", "cmp1", ")", "{", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "cmp0", ")", ";", "if", "(", "riscv_canonicalize_int_order_test", "(", "&", "code", ",", "&", "cmp1", ",", "mode", ")", ")", "riscv_emit_binary", "(", "code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "else", "{", "enum", "rtx_code", "inv_code", "=", "reverse_condition", "(", "code", ")", ";", "if", "(", "!", "riscv_canonicalize_int_order_test", "(", "&", "inv_code", ",", "&", "cmp1", ",", "mode", ")", ")", "{", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "riscv_emit_int_order_test", "(", "code", ",", "invert_ptr", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "else", "if", "(", "invert_ptr", "==", "0", ")", "{", "rtx", "inv_target", "=", "riscv_force_binary", "(", "word_mode", ",", "inv_code", ",", "cmp0", ",", "cmp1", ")", ";", "riscv_emit_binary", "(", "EQ", ",", "target", ",", "inv_target", ",", "const0_rtx", ")", ";", "}", "else", "{", "*", "invert_ptr", "=", "!", "*", "invert_ptr", ";", "riscv_emit_binary", "(", "inv_code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "}", "}", "</s>" ]

[ "Compare", "CMP0", "and", "CMP1", "using", "ordering", "test", "CODE", "and", "store", "the", "result", "in", "TARGET", ".", "CMP0", "and", "TARGET", "are", "register_operands", ".", "If", "INVERT_PTR", "is", "nonnull", ",", "it", "'s", "OK", "to", "set", "TARGET", "to", "the", "inverse", "of", "the", "result", "and", "flip", "*", "INVERT_PTR", "instead", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "XCoreAsmPrinter", "::", "emitFileDirective", "(", "const", "std", "::", "string", "&", "name", ")", "{", "O", "<<", "\"\\t.file\\t\\\"\"", ";", "PrintEscapedString", "(", "name", ",", "O", ")", ";", "O", "<<", "\"\\\"\\n\"", ";", "}", "</s>" ]

[ "Emit", "``", ".file", "assembler", "diretive", "with", "additioal", "info", "." ]

[ "XCore", "XCore", "\"\\t.file\\t\\\"\"", "\"\\\"\\n\"" ]

[]

[ "<s>", "static", "int", "avr_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "cost", "=", "4", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "SUBREG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "{", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "cost", "=", "18", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "if", "(", "optimize", ">", "0", "&&", "io_address_operand", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_absdata_p", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "}", "if", "(", "avr_log", ".", "address_cost", ")", "avr_edump", "(", "\"\\n%?: %d = %r\\n\"", ",", "cost", ",", "x", ")", ";", "return", "cost", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "a", "memory", "address", "." ]

[ "avr", "4", "1", "0", "0", "1", "18", "0", "2", "2", "\"\\n%?: %d = %r\\n\"" ]

[]

[ "<s>", "static", "rtx", "force_mode", "(", "machine_mode", "mode", ",", "rtx", "orig", ")", "{", "if", "(", "mode", "==", "GET_MODE", "(", "orig", ")", ")", "return", "orig", ";", "if", "(", "REGNO", "(", "orig", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "abort", "(", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "orig", ")", ")", ";", "}", "</s>" ]

[ "Ensure", "mode", "of", "ORIG", ",", "a", "REG", "rtx", ",", "is", "MODE", ".", "Returns", "either", "ORIG", "or", "a", "new", "rtx", "with", "the", "correct", "mode", "." ]

[ "m68k" ]

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "assert", "(", "i", "==", "0", "&&", "\"Frame indices can only appear as the first \"", "\"operand of a DBG_VALUE machine instruction\"", ")", ";", "Register", "Reg", ";", "int64_t", "Offset", "=", "TFI", ".", "getFrameIndexReference", "(", "MF", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ",", "Reg", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setIsDebug", "(", ")", ";", "auto", "*", "DIExpr", "=", "DIExpression", "::", "prepend", "(", "MI", ".", "getDebugExpression", "(", ")", ",", "DIExpression", "::", "ApplyOffset", ",", "Offset", ")", ";", "MI", ".", "getDebugExpressionOp", "(", ")", ".", "setMetadata", "(", "DIExpr", ")", ";", "continue", ";", "}", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ",", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReturnBlock", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "0", "\"Frame indices can only appear as the first \"", "\"operand of a DBG_VALUE machine instruction\"", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "m32c_hard_regno_nregs_1", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "FLG_REGNO", "&&", "mode", "==", "CCmode", ")", "return", "1", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "if", "(", "regno", ">=", "MEM0_REGNO", "&&", "regno", "<=", "MEM7_REGNO", ")", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "1", ")", "/", "2", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "1", ")", "return", "nregs_table", "[", "regno", "]", ".", "qi_regs", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "2", ")", "return", "nregs_table", "[", "regno", "]", ".", "hi_regs", ";", "if", "(", "regno", "==", "A0_REGNO", "&&", "mode", "==", "SImode", "&&", "TARGET_A16", ")", "return", "2", ";", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "3", "||", "mode", "==", "PSImode", ")", "&&", "TARGET_A24", ")", "return", "nregs_table", "[", "regno", "]", ".", "pi_regs", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "return", "nregs_table", "[", "regno", "]", ".", "si_regs", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "8", ")", "return", "nregs_table", "[", "regno", "]", ".", "di_regs", ";", "return", "0", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS", ".", "This", "is", "complicated", "by", "the", "fact", "that", "different", "registers", "are", "different", "sizes", "from", "each", "other", ",", "*", "and", "*", "may", "be", "different", "sizes", "in", "different", "chip", "families", "." ]

[ "m32c", "1", "1", "1", "2", "1", "2", "2", "3", "4", "8", "0" ]

[]

[ "<s>", "bool", "AMDGPUPreLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "IsOptNone", "?", "nullptr", ":", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "AMDGPUPreLegalizerCombinerInfo", "PCInfo", "(", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "KB", ",", "MDT", ")", ";", "GISelCSEAnalysisWrapper", "&", "Wrapper", "=", "getAnalysis", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ".", "getCSEWrapper", "(", ")", ";", "auto", "*", "CSEInfo", "=", "&", "Wrapper", ".", "get", "(", "TPC", "->", "getCSEConfig", "(", ")", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "CSEInfo", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "nds32_n13_last_load_to_e2_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "last_def_reg", "=", "extract_nth_access_reg", "(", "producer", ",", "-", "1", ")", ";", "return", "n13_consumed_by_e2_dep_p", "(", "consumer", ",", "last_def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "LMW", "(", "N", ",", "N", ")", "to", "E2", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ",", "Last", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Last", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "emitIf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "emitElse", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "emitIfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "emitLoop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "emitEndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_AND_B64", ":", "case", "AMDGPU", "::", "S_OR_B64", ":", "combineMasks", "(", "MI", ")", ";", "Last", "=", "I", ";", "continue", ";", "default", ":", "Last", "=", "I", ";", "continue", ";", "}", "Next", "=", "(", "Last", "==", "MBB", ".", "end", "(", ")", ")", "?", "MBB", ".", "begin", "(", ")", ":", "Last", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64" ]

[]

[ "<s>", "static", "bool", "aarch_macro_fusion_pair_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "curr", ")", "{", "rtx", "prev_set", "=", "single_set", "(", "prev", ")", ";", "rtx", "curr_set", "=", "single_set", "(", "curr", ")", ";", "if", "(", "!", "prev_set", "||", "!", "curr_set", ")", "return", "false", ";", "if", "(", "any_condjump_p", "(", "curr", ")", ")", "return", "false", ";", "if", "(", "!", "arm_macro_fusion_p", "(", ")", ")", "return", "false", ";", "if", "(", "current_tune", "->", "fusible_ops", "&", "tune_params", "::", "FUSE_MOVW_MOVT", "&&", "arm_sets_movw_movt_fusible_p", "(", "prev_set", ",", "curr_set", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_MACRO_FUSION_PAIR_P", ".", "Return", "true", "if", "PREV", "and", "CURR", "should", "be", "kept", "together", "during", "scheduling", "." ]

[ "arm" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "WebAssemblyTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "assert", "(", "VT", "!=", "MVT", "::", "iPTR", "&&", "\"Pointer MVT not expected here\"", ")", ";", "if", "(", "Subtarget", "->", "hasSIMD128", "(", ")", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "V128RegClass", ")", ";", "}", "if", "(", "VT", ".", "isInteger", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "<=", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "I64RegClass", ")", ";", "}", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", ")", "{", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "case", "32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "F32RegClass", ")", ";", "case", "64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "F64RegClass", ")", ";", "default", ":", "break", ";", "}", "}", "break", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "1", "0", "MVT::iPTR", "\"Pointer MVT not expected here\"", "128", "0U", "WebAssembly::V128RegClass", "32", "0U", "WebAssembly::I32RegClass", "64", "0U", "WebAssembly::I64RegClass", "32", "0U", "WebAssembly::F32RegClass", "64", "0U", "WebAssembly::F64RegClass" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerQuadwordRestore", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "MI", ".", "definesRegister", "(", "DestReg", ")", "&&", "\"RESTORE_QUADWORD does not define its destination\"", ")", ";", "Register", "Reg", "=", "PPC", "::", "X0", "+", "(", "DestReg", "-", "PPC", "::", "G8p0", ")", "*", "2", ";", "bool", "IsLittleEndian", "=", "Subtarget", ".", "isLittleEndian", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "LD", ")", ",", "Reg", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "8", ":", "0", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "LD", ")", ",", "Reg", "+", "1", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "0", ":", "8", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerQuadwordRestore", "-", "Generate", "code", "to", "restore", "paired", "general", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0", "\"RESTORE_QUADWORD does not define its destination\"", "PPC::X0", "PPC::G8p0", "2", "PPC::LD", "8", "0", "PPC::LD", "1", "0", "8" ]

[]

[ "<s>", "static", "void", "epiphany_override_options", "(", "void", ")", "{", "if", "(", "epiphany_stack_offset", "<", "4", ")", "error", "(", "\"%<stack_offset%> must be at least 4\"", ")", ";", "if", "(", "epiphany_stack_offset", "&", "3", ")", "error", "(", "\"%<stack_offset%> must be a multiple of 4\"", ")", ";", "epiphany_stack_offset", "=", "(", "epiphany_stack_offset", "+", "3", ")", "&", "-", "4", ";", "if", "(", "!", "TARGET_SOFT_CMPSF", ")", "flag_finite_math_only", "=", "1", ";", "epiphany_init", "(", ")", ";", "}", "</s>" ]

[ "Fix", "up", "invalid", "option", "settings", "." ]

[ "epiphany", "4", "\"%<stack_offset%> must be at least 4\"", "3", "\"%<stack_offset%> must be a multiple of 4\"", "3", "4", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Cheri Addressing Mode Folder\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Cheri Addressing Mode Folder\"" ]

[]

[ "<s>", "static", "void", "d30v_add_gc_roots", "(", ")", "{", "ggc_add_rtx_root", "(", "&", "d30v_compare_op0", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "d30v_compare_op1", ",", "1", ")", ";", "}", "</s>" ]

[ "Called", "to", "register", "all", "of", "our", "global", "variables", "with", "the", "garbage", "collector", "." ]

[ "d30v", "1", "1" ]

[]

[ "<s>", "static", "void", "arm_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "if", "(", "optimize", ">", "0", "&&", "TREE_CONSTANT", "(", "decl", ")", ")", "SYMBOL_REF_FLAG", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "=", "1", ";", "if", "(", "first", "&&", "DECL_P", "(", "decl", ")", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "DECL_WEAK", "(", "decl", ")", ")", "arm_encode_call_attribute", "(", "decl", ",", "LONG_CALL_FLAG_CHAR", ")", ";", "else", "if", "(", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "arm_encode_call_attribute", "(", "decl", ",", "SHORT_CALL_FLAG_CHAR", ")", ";", "}", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "}", "</s>" ]

[ "Symbols", "in", "the", "text", "segment", "can", "be", "accessed", "without", "indirecting", "via", "the", "constant", "pool", ";", "it", "may", "take", "an", "extra", "binary", "operation", ",", "but", "this", "is", "still", "faster", "than", "indirecting", "via", "memory", ".", "Do", "n't", "do", "this", "when", "not", "optimizing", ",", "since", "we", "wo", "n't", "be", "calculating", "al", "of", "the", "offsets", "necessary", "to", "do", "this", "simplification", "." ]

[ "arm", "0", "0", "1" ]

[]

[ "<s>", "bool", "GBZ80FrameLowering", "::", "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", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "i", "--", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "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", "(", ")", "." ]

[ "GBZ80", "GB", "GB", "GB", "2", "0", "1", "GBZ80::PUSH16r" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "struct", "microblaze_address_info", "info", ";", "enum", "microblaze_address_type", "type", ";", "if", "(", "!", "microblaze_classify_address", "(", "&", "info", ",", "addr", ",", "GET_MODE", "(", "addr", ")", ",", "1", ")", ")", "fatal_insn", "(", "\"insn contains an invalid address !\"", ",", "addr", ")", ";", "type", "=", "info", ".", "type", ";", "switch", "(", "info", ".", "type", ")", "{", "case", "ADDRESS_REG", ":", "fprintf", "(", "file", ",", "\"%s,\"", ",", "reg_names", "[", "REGNO", "(", "info", ".", "regA", ")", "]", ")", ";", "output_addr_const", "(", "file", ",", "info", ".", "offset", ")", ";", "break", ";", "case", "ADDRESS_REG_INDEX", ":", "if", "(", "REGNO", "(", "info", ".", "regA", ")", "==", "0", ")", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "info", ".", "regB", ")", "]", ",", "reg_names", "[", "REGNO", "(", "info", ".", "regA", ")", "]", ")", ";", "else", "if", "(", "REGNO", "(", "info", ".", "regB", ")", "!=", "0", ")", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "info", ".", "regB", ")", "]", ",", "reg_names", "[", "REGNO", "(", "info", ".", "regA", ")", "]", ")", ";", "break", ";", "case", "ADDRESS_CONST_INT", ":", "fprintf", "(", "file", ",", "\"%s,\"", ",", "reg_names", "[", "REGNO", "(", "info", ".", "regA", ")", "]", ")", ";", "output_addr_const", "(", "file", ",", "info", ".", "offset", ")", ";", "break", ";", "case", "ADDRESS_SYMBOLIC", ":", "case", "ADDRESS_GOTOFF", ":", "case", "ADDRESS_PLT", ":", "case", "ADDRESS_TLS", ":", "if", "(", "info", ".", "regA", ")", "fprintf", "(", "file", ",", "\"%s,\"", ",", "reg_names", "[", "REGNO", "(", "info", ".", "regA", ")", "]", ")", ";", "output_addr_const", "(", "file", ",", "info", ".", "symbol", ")", ";", "if", "(", "type", "==", "ADDRESS_GOTOFF", ")", "{", "fputs", "(", "\"@GOT\"", ",", "file", ")", ";", "}", "else", "if", "(", "type", "==", "ADDRESS_PLT", ")", "{", "fputs", "(", "\"@PLT\"", ",", "file", ")", ";", "}", "else", "if", "(", "type", "==", "ADDRESS_TLS", ")", "{", "switch", "(", "info", ".", "tls_type", ")", "{", "case", "TLS_GD", ":", "fputs", "(", "\"@TLSGD\"", ",", "file", ")", ";", "break", ";", "case", "TLS_LDM", ":", "fputs", "(", "\"@TLSLDM\"", ",", "file", ")", ";", "break", ";", "case", "TLS_DTPREL", ":", "fputs", "(", "\"@TLSDTPREL\"", ",", "file", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "break", ";", "}", "}", "break", ";", "case", "ADDRESS_INVALID", ":", "fatal_insn", "(", "\"invalid address\"", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "microblaze", "1", "\"insn contains an invalid address !\"", "\"%s,\"", "0", "\"%s,%s\"", "0", "\"%s,%s\"", "\"%s,\"", "\"%s,\"", "\"@GOT\"", "\"@PLT\"", "\"@TLSGD\"", "\"@TLSLDM\"", "\"@TLSDTPREL\"", "\"invalid address\"" ]

[]

[ "<s>", "rtx", "avr_return_addr_rtx", "(", "int", "count", ",", "rtx", "tem", ")", "{", "rtx", "r", ";", "if", "(", "count", ")", "return", "NULL", ";", "if", "(", "AVR_3_BYTE_PC", ")", "{", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+2\"", ")", ";", "warning", "(", "0", ",", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", ")", ";", "}", "else", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+1\"", ")", ";", "cfun", "->", "machine", "->", "use_L__stack_usage", "=", "1", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "r", ")", ";", "r", "=", "gen_frame_mem", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "r", ")", ")", ";", "r", "=", "gen_rtx_ROTATE", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "r", ";", "}", "</s>" ]

[ "Return", "contents", "of", "MEM", "at", "frame", "pointer", "+", "stack", "size", "+", "1", "(", "+2", "if", "3-byte", "PC", ")", ".", "This", "is", "return", "address", "of", "function", "." ]

[ "avr", "\".L__stack_usage+2\"", "0", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", "\".L__stack_usage+1\"", "1", "8" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.workitem.id.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workitem.id.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.dispatch.ptr\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.amdgcn.queue.ptr\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.amdgcn.dispatch.id\"", ",", "\"amdgpu-dispatch-id\"", "}", ",", "{", "\"llvm.trap\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.debugtrap\"", ",", "\"amdgpu-queue-ptr\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "||", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "Mesa3D", ")", "{", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-queue-ptr\"", ")", ")", "continue", ";", "bool", "HasApertureRegs", "=", "TM", "&&", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ".", "hasApertureRegs", "(", ")", ";", "if", "(", "!", "HasApertureRegs", "&&", "hasAddrSpaceCast", "(", "F", ")", ")", "F", ".", "addFnAttr", "(", "\"amdgpu-queue-ptr\"", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "2", "\"llvm.amdgcn.workitem.id.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.amdgcn.workitem.id.z\"", "\"amdgpu-work-item-id-z\"", "\"llvm.amdgcn.workgroup.id.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.amdgcn.workgroup.id.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.amdgcn.dispatch.ptr\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.amdgcn.queue.ptr\"", "\"amdgpu-queue-ptr\"", "\"llvm.amdgcn.dispatch.id\"", "\"amdgpu-dispatch-id\"", "\"llvm.trap\"", "\"amdgpu-queue-ptr\"", "\"llvm.debugtrap\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"", "AMDGPU", "\"amdgpu-queue-ptr\"" ]

[]

[ "<s>", "DecodeStatus", "AArch64Disassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "Size", "=", "0", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "return", "Fail", ";", "Size", "=", "4", ";", "uint32_t", "Insn", "=", "(", "Bytes", "[", "3", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "2", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "1", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "0", "]", "<<", "0", ")", ";", "const", "uint8_t", "*", "Tables", "[", "]", "=", "{", "DecoderTable32", ",", "DecoderTableFallback32", "}", ";", "for", "(", "auto", "Table", ":", "Tables", ")", "{", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "Table", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "4", "4", "3", "24", "2", "16", "1", "8", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_move", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "operands", "[", "]", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "REG", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "if", "(", "REGNO", "(", "src", ")", "==", "CC_REG", ")", "return", "\"mvc\\t%0\"", ";", "else", "return", "\"mov\\t%0,%1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "LABEL_REF", ")", "return", "\"lrw\\t%0,[%1]\"", ";", "else", "switch", "(", "GET_MODE", "(", "src", ")", ")", "{", "case", "SImode", ":", "return", "\"ldw\\t%0,%1\"", ";", "case", "HImode", ":", "return", "\"ld.h\\t%0,%1\"", ";", "case", "QImode", ":", "return", "\"ld.b\\t%0,%1\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "int", "x", ",", "y", ";", "if", "(", "CONST_OK_FOR_I", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"movi\\t%0,%1\"", ";", "else", "if", "(", "CONST_OK_FOR_M", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"bgeni\\t%0,%P1\\t// %1 %x1\"", ";", "else", "if", "(", "CONST_OK_FOR_N", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"bmaski\\t%0,%N1\\t// %1 %x1\"", ";", "else", "if", "(", "try_constant_tricks", "(", "INTVAL", "(", "src", ")", ",", "&", "x", ",", "&", "y", ")", ")", "return", "output_inline_const", "(", "SImode", ",", "operands", ")", ";", "else", "return", "\"lrw\\t%0,%x1\\t// %1\"", ";", "}", "else", "return", "\"lrw\\t%0, %1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", ")", "switch", "(", "GET_MODE", "(", "dst", ")", ")", "{", "case", "SImode", ":", "return", "\"stw\\t%1,%0\"", ";", "case", "HImode", ":", "return", "\"st.h\\t%1,%0\"", ";", "case", "QImode", ":", "return", "\"st.b\\t%1,%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Output", "a", "move", "of", "a", "word", "or", "less", "value", "." ]

[ "mcore", "0", "1", "\"mvc\\t%0\"", "\"mov\\t%0,%1\"", "0", "\"lrw\\t%0,[%1]\"", "\"ldw\\t%0,%1\"", "\"ld.h\\t%0,%1\"", "\"ld.b\\t%0,%1\"", "\"movi\\t%0,%1\"", "\"bgeni\\t%0,%P1\\t// %1 %x1\"", "\"bmaski\\t%0,%N1\\t// %1 %x1\"", "\"lrw\\t%0,%x1\\t// %1\"", "\"lrw\\t%0, %1\"", "\"stw\\t%1,%0\"", "\"st.h\\t%1,%0\"", "\"st.b\\t%1,%0\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", "||", "MI", ".", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_SETREG_IMM32_B32", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_SETREG_B32", "||", "changesVGPRIndexingMode", "(", "MI", ")", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::S_SETREG_IMM32_B32", "AMDGPU::S_SETREG_B32" ]

[]

[ "<s>", "void", "ValueEnumerator", "::", "purgeFunction", "(", ")", "{", "for", "(", "unsigned", "i", "=", "NumModuleValues", ",", "e", "=", "Values", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "ValueMap", ".", "erase", "(", "Values", "[", "i", "]", ".", "first", ")", ";", "for", "(", "unsigned", "i", "=", "NumModuleMDs", ",", "e", "=", "MDs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MetadataMap", ".", "erase", "(", "MDs", "[", "i", "]", ")", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "BasicBlocks", ")", "ValueMap", ".", "erase", "(", "BB", ")", ";", "Values", ".", "resize", "(", "NumModuleValues", ")", ";", "MDs", ".", "resize", "(", "NumModuleMDs", ")", ";", "BasicBlocks", ".", "clear", "(", ")", ";", "NumMDStrings", "=", "0", ";", "}", "</s>" ]

[ "After", "calling", "incorporateFunction", ",", "use", "this", "method", "to", "remove", "the", "most", "recently", "incorporated", "function", "from", "the", "SlotTracker", "." ]

[ "DirectX", "0" ]

[]

[ "<s>", "rtx", "aarch64_check_zero_based_sve_index_immediate", "(", "rtx", "x", ")", "{", "rtx", "base", ",", "step", ";", "if", "(", "const_vec_series_p", "(", "x", ",", "&", "base", ",", "&", "step", ")", "&&", "base", "==", "const0_rtx", "&&", "aarch64_sve_index_immediate_p", "(", "step", ")", ")", "return", "step", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Check", "whether", "X", "is", "a", "VEC_SERIES-like", "constant", "that", "starts", "at", "0", "and", "has", "a", "step", "in", "the", "range", "of", "INDEX", ".", "Return", "the", "index", "expression", "if", "so", ",", "otherwise", "return", "null", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "!", "EnableScalarToIRF", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**** ScalarToIRF Pass\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "BB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TPC", "\"**** ScalarToIRF Pass\\n\"" ]

[]

[ "<s>", "static", "bool", "aarch64_sched_can_speculate_insn", "(", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_SDIV", ":", "case", "TYPE_UDIV", ":", "case", "TYPE_FDIVS", ":", "case", "TYPE_FDIVD", ":", "case", "TYPE_FSQRTS", ":", "case", "TYPE_FSQRTD", ":", "case", "TYPE_NEON_FP_SQRT_S", ":", "case", "TYPE_NEON_FP_SQRT_D", ":", "case", "TYPE_NEON_FP_SQRT_S_Q", ":", "case", "TYPE_NEON_FP_SQRT_D_Q", ":", "case", "TYPE_NEON_FP_DIV_S", ":", "case", "TYPE_NEON_FP_DIV_D", ":", "case", "TYPE_NEON_FP_DIV_S_Q", ":", "case", "TYPE_NEON_FP_DIV_D_Q", ":", "return", "false", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_CAN_SPECULATE_INSN", ".", "Return", "true", "if", "INSN", "can", "be", "scheduled", "for", "speculative", "execution", ".", "Reject", "the", "long-running", "division", "and", "square-root", "instructions", "." ]

[ "aarch64" ]

[]

[ "<s>", "MCSymbol", "*", "BPFMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "BPF", "BPF" ]

[]

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

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

[ "RISCV" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "ARMTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "Size", "<=", "(", "Subtarget", "->", "isMClass", "(", ")", "?", "32U", ":", "64U", ")", ")", "?", "AtomicExpansionKind", "::", "LLSC", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "ARM", "ARM", "32U", "64U" ]

[]

[ "<s>", "static", "void", "ea_load_store", "(", "rtx", "mem", ",", "bool", "is_store", ",", "rtx", "ea_addr", ",", "rtx", "data_addr", ")", "{", "if", "(", "is_store", ")", "{", "rtx", "ndirty", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem", ")", ")", ")", ";", "if", "(", "!", "cache_fetch_dirty", ")", "cache_fetch_dirty", "=", "init_one_libfunc", "(", "\"__cache_fetch_dirty\"", ")", ";", "emit_library_call_value", "(", "cache_fetch_dirty", ",", "data_addr", ",", "LCT_NORMAL", ",", "Pmode", ",", "2", ",", "ea_addr", ",", "EAmode", ",", "ndirty", ",", "SImode", ")", ";", "}", "else", "{", "if", "(", "!", "cache_fetch", ")", "cache_fetch", "=", "init_one_libfunc", "(", "\"__cache_fetch\"", ")", ";", "emit_library_call_value", "(", "cache_fetch", ",", "data_addr", ",", "LCT_NORMAL", ",", "Pmode", ",", "1", ",", "ea_addr", ",", "EAmode", ")", ";", "}", "}", "</s>" ]

[ "MEM", "is", "known", "to", "be", "an", "__ea", "qualified", "memory", "access", ".", "Emit", "a", "call", "to", "fetch", "the", "ppu", "memory", "to", "local", "store", ",", "and", "return", "its", "address", "in", "local", "store", "." ]

[ "spu", "\"__cache_fetch_dirty\"", "2", "\"__cache_fetch\"", "1" ]

[]

[ "<s>", "DecodeStatus", "AVRDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "{", "Result", "=", "readInstruction16", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "getDecoderTable", "(", "Size", ")", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "}", "{", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "getDecoderTable", "(", "Size", ")", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createX86CallFrameOptimization", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "void", "lm32_expand_conditional_branch", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "destination", "=", "operands", "[", "3", "]", ";", "gen_int_relational", "(", "code", ",", "NULL_RTX", ",", "op0", ",", "op1", ",", "destination", ")", ";", "}", "</s>" ]

[ "Compare", "OPERANDS", "[", "1", "]", "with", "OPERANDS", "[", "2", "]", "using", "comparison", "code", "CODE", "and", "jump", "to", "OPERANDS", "[", "3", "]", "if", "the", "condition", "holds", "." ]

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

[]

[ "<s>", "bool", "NyuziTargetLowering", "::", "isIntDivCheap", "(", "EVT", ",", "AttributeList", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "void", "MipsAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "FK_Data_2", ":", "case", "Mips", "::", "fixup_Mips_16", ":", "case", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ":", "FullSize", "=", "2", ";", "break", ";", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "case", "FK_Data_4", ":", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "bool", "microMipsLEByteOrder", "=", "needsMMLEByteOrder", "(", "(", "unsigned", ")", "Kind", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "7", "8", "Mips::fixup_Mips_16", "Mips::fixup_MICROMIPS_PC10_S1", "2", "Mips::fixup_Mips_64", "8", "4", "0", "Mips", "0", "Mips", "1", "8", "1", "64", "0", "Mips", "1", "8", "0xff" ]

[]

[ "<s>", "static", "rtx", "mem_ref", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTEND", "||", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTEND", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "return", "x", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "the", "memory", "reference", "contained", "in", "X", "if", "any", ",", "zero", "otherwise", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "static", "tree", "alpha_fold_builtin_cmpbge", "(", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "if", "(", "op_const", "==", "3", ")", "{", "int", "i", ",", "val", ";", "for", "(", "i", "=", "0", ",", "val", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "{", "unsigned", "HOST_WIDE_INT", "c0", "=", "(", "opint", "[", "0", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "unsigned", "HOST_WIDE_INT", "c1", "=", "(", "opint", "[", "1", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "if", "(", "c0", ">=", "c1", ")", "val", "|=", "1", "<<", "i", ";", "}", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "val", ")", ";", "}", "else", "if", "(", "op_const", "==", "2", "&&", "opint", "[", "1", "]", "==", "0", ")", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "0xff", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Fold", "the", "builtin", "for", "the", "CMPBGE", "instruction", ".", "This", "is", "a", "vector", "comparison", "with", "an", "8", "bit", "output", "vector", ".", "OPINT", "contains", "the", "integer", "operands", ";", "bit", "N", "of", "OP_CONST", "is", "set", "if", "OPINT", "[", "N", "]", "is", "valid", "." ]

[ "alpha", "3", "0", "0", "8", "0", "8", "0xff", "1", "8", "0xff", "1", "2", "1", "0", "0xff" ]

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "Op", ",", "unsigned", "Kind", ")", "{", "AMDGPUOperand", "&", "Operand", "=", "(", "AMDGPUOperand", "&", ")", "Op", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_addr64", ":", "return", "Operand", ".", "isAddr64", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_gds", ":", "return", "Operand", ".", "isGDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_glc", ":", "return", "Operand", ".", "isGLC", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_idxen", ":", "return", "Operand", ".", "isIdxen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_offen", ":", "return", "Operand", ".", "isOffen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "default", ":", "return", "Match_InvalidOperand", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "Thumb1RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MBB", ".", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "R12", ")", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM::tMOVr", "ARM::R12", "0", "ARM::R12", "ARM::R12", "ARM::tMOVr", "ARM::R12" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "N", ",", "ISD", "::", "LoadExtType", ",", "EVT", "NewVT", ")", "const", "{", "unsigned", "NewSize", "=", "NewVT", ".", "getStoreSizeInBits", "(", ")", ";", "if", "(", "NewSize", "==", "32", ")", "return", "true", ";", "EVT", "OldVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "unsigned", "OldSize", "=", "OldVT", ".", "getStoreSizeInBits", "(", ")", ";", "return", "(", "OldSize", "<", "32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "R600", "ISD::LoadExtType", "32", "0", "32" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'L'", ":", "O", "<<", "getDataLayout", "(", ")", ".", "getPointerSize", "(", ")", "<<", "\"(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "case", "'y'", ":", "O", "<<", "\"0, \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "O", "<<", "\"i\"", ";", "return", "false", ";", "case", "'U'", ":", "case", "'X'", ":", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"(\"", "\")\"", "\"0, \"", "\"i\"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemchr", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src", ",", "SDValue", "Char", ",", "SDValue", "Length", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "EVT", "PtrVT", "=", "Src", ".", "getValueType", "(", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "PtrVT", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "Length", "=", "DAG", ".", "getZExtOrTrunc", "(", "Length", ",", "DL", ",", "PtrVT", ")", ";", "Char", "=", "DAG", ".", "getZExtOrTrunc", "(", "Char", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Char", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "Char", ",", "DAG", ".", "getConstant", "(", "255", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Limit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Src", ",", "Length", ")", ";", "SDValue", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SEARCH_STRING", ",", "DL", ",", "VTs", ",", "Chain", ",", "Limit", ",", "Src", ",", "Char", ")", ";", "Chain", "=", "End", ".", "getValue", "(", "1", ")", ";", "SDValue", "Glue", "=", "End", ".", "getValue", "(", "2", ")", ";", "SmallVector", "<", "SDValue", ",", "5", ">", "Ops", ";", "Ops", ".", "push_back", "(", "End", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "PtrVT", ")", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST", ",", "MVT", "::", "i32", ")", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST_FOUND", ",", "MVT", "::", "i32", ")", ")", ";", "Ops", ".", "push_back", "(", "Glue", ")", ";", "VTs", "=", "DAG", ".", "getVTList", "(", "PtrVT", ",", "MVT", "::", "Glue", ")", ";", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SELECT_CCMASK", ",", "DL", ",", "VTs", ",", "&", "Ops", "[", "0", "]", ",", "Ops", ".", "size", "(", ")", ")", ";", "return", "std", "::", "make_pair", "(", "End", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memchr", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::Other", "MVT::Glue", "MVT::i32", "ISD::AND", "MVT::i32", "255", "MVT::i32", "ISD::ADD", "SystemZISD::SEARCH_STRING", "1", "2", "5", "0", "SystemZ::CCMASK_SRST", "MVT::i32", "SystemZ::CCMASK_SRST_FOUND", "MVT::i32", "MVT::Glue", "SystemZISD::SELECT_CCMASK", "0" ]

[]

[ "<s>", "bool", "hasFusion", "(", ")", "const", "{", "return", "hasArithmeticBccFusion", "(", ")", "||", "hasArithmeticCbzFusion", "(", ")", "||", "hasFuseAES", "(", ")", "||", "hasFuseCCSelect", "(", ")", "||", "hasFuseLiterals", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "CPU", "supports", "any", "kind", "of", "instruction", "fusion", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "LLVMContext", "&", "Context", "=", "M", ".", "getContext", "(", ")", ";", "Void", "=", "Type", "::", "getVoidTy", "(", "Context", ")", ";", "Boolean", "=", "Type", "::", "getInt1Ty", "(", "Context", ")", ";", "Int64", "=", "Type", "::", "getInt64Ty", "(", "Context", ")", ";", "ReturnStruct", "=", "StructType", "::", "get", "(", "Boolean", ",", "Int64", ")", ";", "BoolTrue", "=", "ConstantInt", "::", "getTrue", "(", "Context", ")", ";", "BoolFalse", "=", "ConstantInt", "::", "getFalse", "(", "Context", ")", ";", "BoolUndef", "=", "UndefValue", "::", "get", "(", "Boolean", ")", ";", "Int64Zero", "=", "ConstantInt", "::", "get", "(", "Int64", ",", "0", ")", ";", "If", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_if", ")", ";", "Else", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_else", ")", ";", "Break", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_break", ")", ";", "IfBreak", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_if_break", ")", ";", "ElseBreak", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_else_break", ")", ";", "Loop", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_loop", ")", ";", "EndCf", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_end_cf", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_if", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_else", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_break", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_if_break", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_else_break", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_loop", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_end_cf" ]

[]

[ "<s>", "static", "rtx", "visium_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "visium_function_value_1", "(", "mode", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "representing", "the", "place", "where", "the", "library", "function", "result", "will", "be", "returned", "." ]

[ "visium" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "60", "12" ]

[]

[ "<s>", "const", "LegalizerInfo", "*", "M68kSubtarget", "::", "getLegalizerInfo", "(", ")", "const", "{", "return", "Legalizer", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

[ "M68k", "M68k" ]

[]