Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "HexagonCopyToCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "IsCombinesDisabled", ")", "return", "false", ";", "bool", "HasChanged", "=", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "OptForSize", "=", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", ";", "ShouldCombineAggressively", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "<=", "CodeGenOpt", "::", "Default", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "PotentiallyNewifiableTFR", ".", "clear", "(", ")", ";", "findPotentialNewifiableTFRs", "(", "*", "BI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "BI", "->", "begin", "(", ")", ",", "End", "=", "BI", "->", "end", "(", ")", ";", "MI", "!=", "End", ";", ")", "{", "MachineInstr", "&", "I1", "=", "*", "MI", "++", ";", "if", "(", "I1", ".", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "ShouldCombineAggressively", "&&", "PotentiallyNewifiableTFR", ".", "count", "(", "&", "I1", ")", ")", "continue", ";", "if", "(", "!", "isCombinableInstType", "(", "I1", ",", "TII", ",", "ShouldCombineAggressively", ")", ")", "continue", ";", "bool", "DoInsertAtI1", "=", "false", ";", "DbgMItoMove", ".", "clear", "(", ")", ";", "MachineInstr", "*", "I2", "=", "findPairable", "(", "I1", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "if", "(", "I2", ")", "{", "HasChanged", "=", "true", ";", "combine", "(", "I1", ",", "*", "I2", ",", "MI", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "}", "}", "}", "return", "HasChanged", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "ExpandMOVSZX_RR", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "IsSigned", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to \"", ")", ";", "unsigned", "Move", ";", "if", "(", "MVTDst", "==", "MVT", "::", "i16", ")", "Move", "=", "M68k", "::", "MOV16rr", ";", "else", "Move", "=", "M68k", "::", "MOV32rr", ";", "Register", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "Src", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Dst", "!=", "Src", "&&", "\"You cannot use the same Regs with MOVSX_RR\"", ")", ";", "const", "auto", "&", "TRI", "=", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RCDst", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Dst", ",", "MVTDst", ")", ";", "const", "auto", "*", "RCSrc", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Src", ",", "MVTSrc", ")", ";", "assert", "(", "RCDst", "&&", "RCSrc", "&&", "\"Wrong use of MOVSX_RR\"", ")", ";", "assert", "(", "RCDst", "!=", "RCSrc", "&&", "\"You cannot use the same Reg Classes with MOVSX_RR\"", ")", ";", "unsigned", "SSrc", "=", "RI", ".", "getMatchingMegaReg", "(", "Src", ",", "RCDst", ")", ";", "assert", "(", "SSrc", "&&", "\"No viable MEGA register available\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Dst", "!=", "SSrc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Move and \"", "<<", "'\\n'", ")", ";", "BuildMI", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "get", "(", "Move", ")", ",", "Dst", ")", ".", "addReg", "(", "SSrc", ")", ";", "}", "if", "(", "IsSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Move", "from", "register", "and", "extend", "." ]

[ "M68k", "M68k", "\"Expand \"", "\" to \"", "MVT::i16", "M68k::MOV16rr", "M68k::MOV32rr", "0", "1", "\"You cannot use the same Regs with MOVSX_RR\"", "\"Wrong use of MOVSX_RR\"", "\"You cannot use the same Reg Classes with MOVSX_RR\"", "\"No viable MEGA register available\"", "\"Move and \"", "\"Sign Extend\"", "\"Zero Extend\"" ]

[]

[ "<s>", "static", "enum", "loongarch_symbol_type", "loongarch_classify_symbol", "(", "const_rtx", "x", ")", "{", "if", "(", "LABEL_REF_P", "(", "x", ")", ")", "return", "SYMBOL_GOT_DISP", ";", "gcc_assert", "(", "SYMBOL_REF_P", "(", "x", ")", ")", ";", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "SYMBOL_TLS", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "SYMBOL_GOT_DISP", ";", "return", "SYMBOL_GOT_DISP", ";", "}", "</s>" ]

[ "Return", "the", "method", "that", "should", "be", "used", "to", "access", "SYMBOL_REF", "or", "LABEL_REF", "X", "." ]

[ "loongarch" ]

[]

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

[ "Check", "whether", "the", "target", "can", "fold", "a", "load", "that", "feeds", "a", "subreg", "operand", "(", "or", "a", "subreg", "operand", "that", "feeds", "a", "store", ")", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "aarch64_sve_dup_immediate_p", "(", "rtx", "x", ")", "{", "rtx", "elt", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "||", "!", "CONST_INT_P", "(", "elt", ")", ")", "return", "false", ";", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "elt", ")", ";", "if", "(", "val", "&", "0xff", ")", "return", "IN_RANGE", "(", "val", ",", "-", "0x80", ",", "0x7f", ")", ";", "return", "IN_RANGE", "(", "val", ",", "-", "0x8000", ",", "0x7f00", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "for", "the", "SVE", "DUP", "and", "CPY", "instructions", "." ]

[ "aarch64", "0xff", "0x80", "0x7f", "0x8000", "0x7f00" ]

[]

[ "<s>", "static", "rtx", "gen_load_pcrel_sym", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "int", "orig_flag_pic", "=", "flag_pic", ";", "rtx", "insn", ";", "flag_pic", "=", "0", ";", "if", "(", "TARGET_ARCH64", ")", "insn", "=", "gen_load_pcrel_symdi", "(", "op0", ",", "op1", ",", "op2", ",", "GEN_INT", "(", "REGNO", "(", "op0", ")", ")", ")", ";", "else", "insn", "=", "gen_load_pcrel_symsi", "(", "op0", ",", "op1", ",", "op2", ",", "GEN_INT", "(", "REGNO", "(", "op0", ")", ")", ")", ";", "flag_pic", "=", "orig_flag_pic", ";", "return", "insn", ";", "}", "</s>" ]

[ "Wrapper", "around", "the", "load_pcrel_sym", "{", "si", ",", "di", "}", "patterns", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "void", "SystemZAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "emitStackMaps", "(", "SM", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "const", "SPIRVSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "output_short_suffix", "(", "FILE", "*", "file", ")", "{", "rtx_insn", "*", "insn", "=", "current_output_insn", ";", "if", "(", "!", "insn", ")", "return", ";", "if", "(", "arc_verify_short", "(", "insn", ",", "cfun", "->", "machine", "->", "unalign", ",", "1", ")", ")", "{", "fprintf", "(", "file", ",", "\"_s\"", ")", ";", "cfun", "->", "machine", "->", "unalign", "^=", "2", ";", "}", "extract_insn_cached", "(", "insn", ")", ";", "}", "</s>" ]

[ "When", "outputting", "an", "instruction", "(", "alternative", ")", "that", "can", "potentially", "be", "short", ",", "output", "the", "short", "suffix", "if", "the", "insn", "is", "in", "fact", "short", ",", "and", "update", "cfun-", ">", "machine-", ">", "unalign", "accordingly", "." ]

[ "arc", "1", "\"_s\"", "2" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "L2_loadri_io", ":", "case", "Hexagon", "::", "L2_loadrd_io", ":", "case", "Hexagon", "::", "V6_vL32b_ai", ":", "case", "Hexagon", "::", "V6_vL32b_nt_ai", ":", "case", "Hexagon", "::", "V6_vL32b_ai_128B", ":", "case", "Hexagon", "::", "V6_vL32b_nt_ai_128B", ":", "case", "Hexagon", "::", "V6_vL32Ub_ai", ":", "case", "Hexagon", "::", "V6_vL32Ub_ai_128B", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "case", "Hexagon", "::", "LDriw_mod", ":", "case", "Hexagon", "::", "PS_vloadrq_ai", ":", "case", "Hexagon", "::", "PS_vloadrw_ai", ":", "case", "Hexagon", "::", "PS_vloadrw_nt_ai", ":", "case", "Hexagon", "::", "PS_vloadrq_ai_128B", ":", "case", "Hexagon", "::", "PS_vloadrw_ai_128B", ":", "case", "Hexagon", "::", "PS_vloadrw_nt_ai_128B", ":", "{", "const", "MachineOperand", "OpFI", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "OpOff", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "case", "Hexagon", "::", "L2_ploadrit_io", ":", "case", "Hexagon", "::", "L2_ploadrif_io", ":", "case", "Hexagon", "::", "L2_ploadrdt_io", ":", "case", "Hexagon", "::", "L2_ploadrdf_io", ":", "{", "const", "MachineOperand", "OpFI", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "OpOff", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::L2_loadri_io", "Hexagon::L2_loadrd_io", "Hexagon::V6_vL32b_ai", "Hexagon::V6_vL32b_nt_ai", "Hexagon::V6_vL32b_ai_128B", "Hexagon::V6_vL32b_nt_ai_128B", "Hexagon::V6_vL32Ub_ai", "Hexagon::V6_vL32Ub_ai_128B", "Hexagon::LDriw_pred", "Hexagon::LDriw_mod", "Hexagon::PS_vloadrq_ai", "Hexagon::PS_vloadrw_ai", "Hexagon::PS_vloadrw_nt_ai", "Hexagon::PS_vloadrq_ai_128B", "Hexagon::PS_vloadrw_ai_128B", "Hexagon::PS_vloadrw_nt_ai_128B", "1", "0", "2", "0", "0", "0", "Hexagon::L2_ploadrit_io", "Hexagon::L2_ploadrif_io", "Hexagon::L2_ploadrdt_io", "Hexagon::L2_ploadrdf_io", "2", "0", "3", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "arc_legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "return", "!", "arc_raw_symbolic_reference_mentioned_p", "(", "x", ",", "true", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "arc" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "bool", "is64", "=", "getPointerSize", "(", ")", "==", "8", ";", "return", "createMachObjectWriter", "(", "OS", ",", "is64", ",", "(", "is64", "?", "object", "::", "mach", "::", "CTM_PowerPC64", ":", "object", "::", "mach", "::", "CTM_PowerPC", ")", ",", "object", "::", "mach", "::", "CSPPC_ALL", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "nds32_expand_load_multiple", "(", "int", "base_regno", ",", "int", "count", ",", "rtx", "base_addr", ",", "rtx", "basemem", ")", "{", "int", "par_index", ";", "int", "offset", ";", "rtx", "result", ";", "rtx", "new_addr", ",", "mem", ",", "reg", ";", "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "for", "(", "par_index", "=", "0", ";", "par_index", "<", "count", ";", "par_index", "++", ")", "{", "offset", "=", "par_index", "*", "4", ";", "new_addr", "=", "plus_constant", "(", "Pmode", ",", "base_addr", ",", "offset", ")", ";", "mem", "=", "adjust_automodify_address_nv", "(", "basemem", ",", "SImode", ",", "new_addr", ",", "offset", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "base_regno", "+", "par_index", ")", ";", "XVECEXP", "(", "result", ",", "0", ",", "par_index", ")", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Functions", "to", "expand", "load_multiple", "and", "store_multiple", ".", "They", "are", "auxiliary", "extern", "functions", "to", "help", "create", "rtx", "template", ".", "Check", "nds32-multiple.md", "file", "for", "the", "patterns", "." ]

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

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "char", "*", "SpillLibCall", "=", "getSpillLibCallName", "(", "*", "MF", ",", "CSI", ")", ";", "if", "(", "SpillLibCall", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PseudoCALLReg", ")", ",", "RISCV", "::", "X5", ")", ".", "addExternalSymbol", "(", "SpillLibCall", ",", "RISCVII", "::", "MO_CALL", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "MBB", ".", "addLiveIn", "(", "CS", ".", "getReg", "(", ")", ")", ";", "}", "const", "auto", "&", "NonLibcallCSI", "=", "getNonLibcallCSI", "(", "CSI", ")", ";", "for", "(", "auto", "&", "CS", ":", "NonLibcallCSI", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "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", "(", ")", "." ]

[ "RISCV", "RISCV", "RISCV::PseudoCALLReg", "RISCV::X5", "RISCVII::MO_CALL" ]

[]

[ "<s>", "static", "void", "arc_init", "(", "void", ")", "{", "if", "(", "TARGET_V2", ")", "{", "if", "(", "TARGET_MPYW", "||", "TARGET_MULTI", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "ARC_TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_NOMPY_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "||", "TARGET_DPFP_COMPACT_SET", "||", "TARGET_SPFP", ")", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"no FPX/FPU mixing allowed\"", ")", ";", "if", "(", "flag_pic", "&&", "TARGET_ARC600_FAMILY", ")", "{", "warning", "(", "0", ",", "\"PIC is not supported for %qs\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "arc_punct_chars", "[", "'+'", "]", "=", "1", ";", "arc_punct_chars", "[", "'_'", "]", "=", "1", ";", "}", "</s>" ]

[ "Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "." ]

[ "arc", "1", "0", "4", "30", "3", "30", "4", "30", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", "\"FPX fast and compact options cannot be specified together\"", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", "\"no FPX/FPU mixing allowed\"", "0", "\"PIC is not supported for %qs\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "Tile64InstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", "->", "isLabel", "(", ")", "||", "MI", "->", "isInlineAsm", "(", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Tile64" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "CI", ",", "MachineFunction", "&", "MF", ",", "unsigned", "IntrID", ")", "const", "{", "if", "(", "const", "AMDGPU", "::", "RsrcIntrinsic", "*", "RsrcIntr", "=", "AMDGPU", "::", "lookupRsrcIntrinsic", "(", "IntrID", ")", ")", "{", "AttributeList", "Attr", "=", "Intrinsic", "::", "getAttributes", "(", "CI", ".", "getContext", "(", ")", ",", "(", "Intrinsic", "::", "ID", ")", "IntrID", ")", ";", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "ReadNone", ")", ")", "return", "false", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "RsrcIntr", "->", "IsImage", ")", "{", "Info", ".", "ptrVal", "=", "MFI", "->", "getImagePSV", "(", "*", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "RsrcIntr", "->", "RsrcArg", ")", ")", ";", "Info", ".", "align", "=", "0", ";", "}", "else", "{", "Info", ".", "ptrVal", "=", "MFI", "->", "getBufferPSV", "(", "*", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "RsrcIntr", "->", "RsrcArg", ")", ")", ";", "}", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MODereferenceable", ";", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "ReadOnly", ")", ")", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "}", "else", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "WriteOnly", ")", ")", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "}", "else", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MODereferenceable", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "}", "return", "true", ";", "}", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "align", "=", "0", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", ";", "const", "ConstantInt", "*", "Vol", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "4", ")", ")", ";", "if", "(", "!", "Vol", "||", "!", "Vol", "->", "isZero", "(", ")", ")", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::RsrcIntrinsic", "AMDGPU::lookupRsrcIntrinsic", "Intrinsic::getAttributes", "Intrinsic::ID", "SI", "SI", "SI", "0", "SI", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "ISD::INTRINSIC_VOID", "MVT::getVT", "0", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "SICacheControl", ">", "SICacheControl", "::", "create", "(", "const", "GCNSubtarget", "&", "ST", ")", "{", "GCNSubtarget", "::", "Generation", "Generation", "=", "ST", ".", "getGeneration", "(", ")", ";", "if", "(", "Generation", "<=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "return", "make_unique", "<", "SIGfx6CacheControl", ">", "(", "ST", ")", ";", "return", "make_unique", "<", "SIGfx7CacheControl", ">", "(", "ST", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "static", "bool", "allocate_stack_space", "(", "rtx", "size", ",", "HOST_WIDE_INT", "last_probe_offset", ",", "rtx", "temp_reg", ")", "{", "bool", "temp_reg_clobbered_p", "=", "false", ";", "HOST_WIDE_INT", "probe_interval", "=", "1", "<<", "param_stack_clash_protection_probe_interval", ";", "HOST_WIDE_INT", "guard_size", "=", "1", "<<", "param_stack_clash_protection_guard_size", ";", "if", "(", "flag_stack_clash_protection", ")", "{", "if", "(", "last_probe_offset", "+", "-", "INTVAL", "(", "size", ")", "<", "guard_size", ")", "dump_stack_clash_frame_info", "(", "NO_PROBE_SMALL_FRAME", ",", "true", ")", ";", "else", "{", "rtx", "offset", "=", "GEN_INT", "(", "probe_interval", "-", "UNITS_PER_LONG", ")", ";", "HOST_WIDE_INT", "rounded_size", "=", "-", "INTVAL", "(", "size", ")", "&", "-", "probe_interval", ";", "HOST_WIDE_INT", "num_probes", "=", "rounded_size", "/", "probe_interval", ";", "HOST_WIDE_INT", "residual", "=", "-", "INTVAL", "(", "size", ")", "-", "rounded_size", ";", "if", "(", "num_probes", "<", "MIN_UNROLL_PROBES", ")", "{", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "num_probes", ";", "i", "++", ")", "{", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "probe_interval", ")", ",", "true", ")", ";", "s390_emit_stack_probe", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "}", "if", "(", "num_probes", ">", "0", ")", "last_probe_offset", "=", "INTVAL", "(", "offset", ")", ";", "dump_stack_clash_frame_info", "(", "PROBE_INLINE", ",", "residual", "!=", "0", ")", ";", "}", "else", "{", "rtx_code_label", "*", "loop_start_label", "=", "gen_label_rtx", "(", ")", ";", "s390_prologue_plus_offset", "(", "temp_reg", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "rounded_size", ")", ",", "true", ")", ";", "emit_label", "(", "loop_start_label", ")", ";", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "probe_interval", ")", ",", "false", ")", ";", "s390_emit_stack_probe", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "stack_pointer_rtx", ",", "temp_reg", ",", "GT", ",", "NULL_RTX", ",", "Pmode", ",", "1", ",", "loop_start_label", ")", ";", "JUMP_LABEL", "(", "get_last_insn", "(", ")", ")", "=", "loop_start_label", ";", "LABEL_NUSES", "(", "loop_start_label", ")", "=", "1", ";", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "temp_reg", ",", "const0_rtx", ",", "true", ")", ";", "temp_reg_clobbered_p", "=", "true", ";", "last_probe_offset", "=", "INTVAL", "(", "offset", ")", ";", "dump_stack_clash_frame_info", "(", "PROBE_LOOP", ",", "residual", "!=", "0", ")", ";", "}", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "residual", ")", ",", "true", ")", ";", "last_probe_offset", "+=", "residual", ";", "if", "(", "last_probe_offset", ">=", "probe_interval", ")", "s390_emit_stack_probe", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "residual", "-", "UNITS_PER_LONG", ")", ")", ")", ";", "return", "temp_reg_clobbered_p", ";", "}", "}", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "size", ",", "true", ")", ";", "return", "temp_reg_clobbered_p", ";", "}", "</s>" ]

[ "Allocate", "SIZE", "bytes", "of", "stack", "space", ",", "using", "TEMP_REG", "as", "a", "temporary", "if", "necessary", ".", "LAST_PROBE_OFFSET", "contains", "the", "offset", "of", "the", "closest", "probe", "relative", "to", "the", "stack", "pointer", ".", "Note", "that", "SIZE", "is", "negative", ".", "The", "return", "value", "is", "true", "if", "TEMP_REG", "has", "been", "clobbered", "." ]

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

[]

[ "<s>", "SDValue", "BlackfinTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AllocateStack", "(", "12", ",", "4", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_Blackfin", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "TargetRegisterClass", "*", "RC", "=", "VA", ".", "getLocReg", "(", ")", "==", "BF", "::", "P0", "?", "BF", "::", "PRegisterClass", ":", "BF", "::", "DRegisterClass", ";", "assert", "(", "RC", "->", "contains", "(", "VA", ".", "getLocReg", "(", ")", ")", "&&", "\"Unexpected regclass in CCState\"", ")", ";", "assert", "(", "RC", "->", "hasType", "(", "RegVT", ")", "&&", "\"Unexpected regclass in CCState\"", ")", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "Reg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "\"CCValAssign must be RegLoc or MemLoc\"", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "NULL", ",", "0", ",", "false", ",", "false", ",", "0", ")", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Blackfin", "ISD::InputArg", "16", "12", "4", "0", "BF::P0", "BF::PRegisterClass", "BF::DRegisterClass", "\"Unexpected regclass in CCState\"", "\"Unexpected regclass in CCState\"", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"CCValAssign must be RegLoc or MemLoc\"", "MVT::i32", "0", "0" ]

[]

[ "<s>", "rtx", "spu_legitimize_reload_address", "(", "rtx", "ad", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "opnum", ",", "int", "type", ")", "{", "bool", "removed_and", "=", "false", ";", "if", "(", "GET_CODE", "(", "ad", ")", "==", "AND", "&&", "CONST_INT_P", "(", "XEXP", "(", "ad", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "ad", ",", "1", ")", ")", "==", "(", "HOST_WIDE_INT", ")", "-", "16", ")", "{", "ad", "=", "XEXP", "(", "ad", ",", "0", ")", ";", "removed_and", "=", "true", ";", "}", "if", "(", "GET_CODE", "(", "ad", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "ad", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "ad", ",", "1", ")", ")", "&&", "!", "(", "INTVAL", "(", "XEXP", "(", "ad", ",", "1", ")", ")", ">=", "-", "0x2000", "&&", "INTVAL", "(", "XEXP", "(", "ad", ",", "1", ")", ")", "<=", "0x1fff", ")", ")", "{", "ad", "=", "copy_rtx", "(", "ad", ")", ";", "push_reload", "(", "XEXP", "(", "ad", ",", "1", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "ad", ",", "1", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "ad", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "if", "(", "removed_and", ")", "ad", "=", "gen_rtx_AND", "(", "GET_MODE", "(", "ad", ")", ",", "ad", ",", "GEN_INT", "(", "-", "16", ")", ")", ";", "return", "ad", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Reload", "reg", "+", "const_int", "for", "out-of-range", "displacements", "." ]

[ "spu", "1", "1", "16", "0", "0", "1", "1", "0x2000", "1", "0x1fff", "1", "1", "0", "0", "16" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "0U", "PPC::F4RCRegClass", "MVT::f64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass" ]

[]

[ "<s>", "static", "void", "aarch64_override_options", "(", "void", ")", "{", "unsigned", "long", "cpu_isa", "=", "0", ";", "unsigned", "long", "arch_isa", "=", "0", ";", "aarch64_isa_flags", "=", "0", ";", "bool", "valid_cpu", "=", "true", ";", "bool", "valid_tune", "=", "true", ";", "bool", "valid_arch", "=", "true", ";", "selected_cpu", "=", "NULL", ";", "selected_arch", "=", "NULL", ";", "selected_tune", "=", "NULL", ";", "if", "(", "aarch64_cpu_string", ")", "valid_cpu", "=", "aarch64_validate_mcpu", "(", "aarch64_cpu_string", ",", "&", "selected_cpu", ",", "&", "cpu_isa", ")", ";", "if", "(", "aarch64_arch_string", ")", "valid_arch", "=", "aarch64_validate_march", "(", "aarch64_arch_string", ",", "&", "selected_arch", ",", "&", "arch_isa", ")", ";", "if", "(", "aarch64_tune_string", ")", "valid_tune", "=", "aarch64_validate_mtune", "(", "aarch64_tune_string", ",", "&", "selected_tune", ")", ";", "if", "(", "!", "selected_cpu", ")", "{", "if", "(", "selected_arch", ")", "{", "selected_cpu", "=", "&", "all_cores", "[", "selected_arch", "->", "ident", "]", ";", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "else", "{", "selected_cpu", "=", "aarch64_get_tune_cpu", "(", "aarch64_none", ")", ";", "aarch64_isa_flags", "=", "TARGET_CPU_DEFAULT", ">>", "6", ";", "}", "if", "(", "selected_tune", ")", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "}", "else", "if", "(", "selected_arch", ")", "{", "if", "(", "selected_arch", "->", "arch", "!=", "selected_cpu", "->", "arch", ")", "{", "warning", "(", "0", ",", "\"switch -mcpu=%s conflicts with -march=%s switch\"", ",", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ".", "name", ",", "selected_arch", "->", "name", ")", ";", "}", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "}", "else", "{", "aarch64_isa_flags", "=", "cpu_isa", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "if", "(", "!", "selected_arch", ")", "{", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "}", "if", "(", "!", "selected_tune", ")", "selected_tune", "=", "selected_cpu", ";", "if", "(", "TARGET_ILP32", ")", "error", "(", "\"Assembler does not support -mabi=ilp32\"", ")", ";", "if", "(", "aarch64_ra_sign_scope", "!=", "AARCH64_FUNCTION_NONE", "&&", "TARGET_ILP32", ")", "sorry", "(", "\"Return address signing is only supported for -mabi=lp64\"", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_tune_string", "&&", "valid_tune", ")", ")", "gcc_assert", "(", "explicit_tune_core", "!=", "aarch64_none", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_arch_string", "&&", "valid_arch", ")", ")", "gcc_assert", "(", "explicit_arch", "!=", "aarch64_no_arch", ")", ";", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "target_option_default_node", "=", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "aarch64", "0", "0", "0", "6", "0", "\"switch -mcpu=%s conflicts with -march=%s switch\"", "\"Assembler does not support -mabi=ilp32\"", "\"Return address signing is only supported for -mabi=lp64\"" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addRegAssignAndRewriteFast", "(", ")", "{", "if", "(", "!", "usingDefaultRegAlloc", "(", ")", ")", "report_fatal_error", "(", "RegAllocOptNotSupportedMessage", ")", ";", "addPass", "(", "createSGPRAllocPass", "(", "false", ")", ")", ";", "addPass", "(", "&", "SILowerSGPRSpillsID", ")", ";", "addPass", "(", "createVGPRAllocPass", "(", "false", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "core", "register", "allocator", "passes", "which", "do", "the", "actual", "register", "assignment", "and", "rewriting", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "||", "Subtarget", "->", "isTargetMachO", "(", ")", "||", "Subtarget", "->", "isTargetWindows", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "false", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "bool", "LC2200AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "LC2200", "LC2200", "0" ]

[]

[ "<s>", "bool", "TL45PassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "TL45", "TL45" ]

[]

[ "<s>", "void", "ia64_emit_cond_move", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "cond", ")", "{", "rtx_insn", "*", "insn", ",", "*", "first", "=", "get_last_insn", "(", ")", ";", "emit_move_insn", "(", "op0", ",", "op1", ")", ";", "for", "(", "insn", "=", "get_last_insn", "(", ")", ";", "insn", "!=", "first", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "PATTERN", "(", "insn", ")", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "copy_rtx", "(", "cond", ")", ",", "PATTERN", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Split", "a", "move", "from", "OP1", "to", "OP0", "conditional", "on", "COND", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "bool", "rs6000_save_toc_in_prologue_p", "(", "void", ")", "{", "return", "(", "cfun", "&&", "cfun", "->", "machine", "&&", "cfun", "->", "machine", "->", "save_toc_in_prologue", ")", ";", "}", "</s>" ]

[ "Return", "whether", "we", "need", "to", "always", "update", "the", "saved", "TOC", "pointer", "when", "we", "update", "the", "stack", "pointer", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUAttributorPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", "&&", "EnableLowerKernelArguments", ")", "addPass", "(", "createAMDGPULowerKernelArgumentsPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "if", "(", "isPassEnabled", "(", "EnableLoadStoreVectorizer", ")", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "addPass", "(", "createLowerSwitchPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

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

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", ".", "isVarArg", "(", ")", ";", "DebugLoc", "DL", ";", "SystemZ", "::", "GPRRegs", "SpillGPRs", "=", "ZFI", "->", "getSpillGPRRegs", "(", ")", ";", "if", "(", "SpillGPRs", ".", "LowGPR", ")", "{", "assert", "(", "SpillGPRs", ".", "LowGPR", "!=", "SpillGPRs", ".", "HighGPR", "&&", "\"Should be saving %r15 and something else\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "STMG", ")", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SpillGPRs", ".", "LowGPR", ",", "false", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SpillGPRs", ".", "HighGPR", ",", "false", ")", ";", "MIB", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ".", "addImm", "(", "SpillGPRs", ".", "GPROffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "Reg", ",", "true", ")", ";", "}", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "ZFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "SystemZ", "::", "NumArgGPRs", ";", "++", "I", ")", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SystemZ", "::", "ArgGPRs", "[", "I", "]", ",", "true", ")", ";", "}", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "true", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "}", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "true", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::GPRRegs", "\"Should be saving %r15 and something else\"", "SystemZ::STMG", "SystemZ::R15D", "0", "SystemZ::GR64BitRegClass", "SystemZ::NumArgGPRs", "SystemZ::ArgGPRs", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass" ]

[]

[ "<s>", "bool", "HexagonEvaluator", "::", "evaluate", "(", "const", "MachineInstr", "*", "BI", ",", "const", "CellMapType", "&", "Inputs", ",", "BranchTargetList", "&", "Targets", ",", "bool", "&", "FallsThru", ")", "const", "{", "unsigned", "Opc", "=", "BI", "->", "getOpcode", "(", ")", ";", "bool", "SimpleBranch", "=", "false", ";", "bool", "Negated", "=", "false", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "J2_jumpf", ":", "case", "Hexagon", "::", "J2_jumpfnew", ":", "case", "Hexagon", "::", "J2_jumpfnewpt", ":", "Negated", "=", "true", ";", "case", "Hexagon", "::", "J2_jumpt", ":", "case", "Hexagon", "::", "J2_jumptnew", ":", "case", "Hexagon", "::", "J2_jumptnewpt", ":", "SimpleBranch", "=", "true", ";", "break", ";", "case", "Hexagon", "::", "J2_jump", ":", "Targets", ".", "insert", "(", "BI", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ";", "FallsThru", "=", "false", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "SimpleBranch", ")", "return", "false", ";", "RegisterRef", "PR", "=", "BI", "->", "getOperand", "(", "0", ")", ";", "RegisterCell", "PC", "=", "getCell", "(", "PR", ",", "Inputs", ")", ";", "const", "BT", "::", "BitValue", "&", "Test", "=", "PC", "[", "0", "]", ";", "if", "(", "!", "Test", ".", "is", "(", "0", ")", "&&", "!", "Test", ".", "is", "(", "1", ")", ")", "return", "false", ";", "if", "(", "!", "Test", ".", "is", "(", "!", "Negated", ")", ")", "{", "FallsThru", "=", "true", ";", "return", "true", ";", "}", "Targets", ".", "insert", "(", "BI", "->", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ")", ";", "FallsThru", "=", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "evaluate", "-", "Evaluate", "Expr", "and", "append", "the", "resulting", "set", "to", "Elts", "." ]

[ "Hexagon", "Hexagon", "Hexagon::J2_jumpf", "Hexagon::J2_jumpfnew", "Hexagon::J2_jumpfnewpt", "Hexagon::J2_jumpt", "Hexagon::J2_jumptnew", "Hexagon::J2_jumptnewpt", "Hexagon::J2_jump", "0", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "SPUAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printMemRegReg", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "0" ]

[]

[ "<s>", "SUnit", "*", "R600SchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "SUnit", "*", "SU", "=", "nullptr", ";", "NextInstKind", "=", "IDOther", ";", "IsTopNode", "=", "false", ";", "bool", "AllowSwitchToAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "||", "(", "Available", "[", "CurInstKind", "]", ".", "empty", "(", ")", ")", ";", "bool", "AllowSwitchFromAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "&&", "(", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", "||", "!", "Available", "[", "IDOther", "]", ".", "empty", "(", ")", ")", ";", "if", "(", "CurInstKind", "==", "IDAlu", "&&", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", ")", "{", "float", "ALUFetchRationEstimate", "=", "(", "AluInstCount", "+", "AvailablesAluCount", "(", ")", "+", "Pending", "[", "IDAlu", "]", ".", "size", "(", ")", ")", "/", "(", "FetchInstCount", "+", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ")", ";", "if", "(", "ALUFetchRationEstimate", "==", "0", ")", "{", "AllowSwitchFromAlu", "=", "true", ";", "}", "else", "{", "unsigned", "NeededWF", "=", "62.5f", "/", "ALUFetchRationEstimate", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "NeededWF", "<<", "\" approx. Wavefronts Required\\n\"", ")", ";", "unsigned", "NearRegisterRequirement", "=", "2", "*", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ";", "if", "(", "NeededWF", ">", "getWFCountLimitedByGPR", "(", "NearRegisterRequirement", ")", ")", "AllowSwitchFromAlu", "=", "true", ";", "}", "}", "if", "(", "!", "SU", "&&", "(", "(", "AllowSwitchToAlu", "&&", "CurInstKind", "!=", "IDAlu", ")", "||", "(", "!", "AllowSwitchFromAlu", "&&", "CurInstKind", "==", "IDAlu", ")", ")", ")", "{", "SU", "=", "pickAlu", "(", ")", ";", "if", "(", "!", "SU", "&&", "!", "PhysicalRegCopy", ".", "empty", "(", ")", ")", "{", "SU", "=", "PhysicalRegCopy", ".", "front", "(", ")", ";", "PhysicalRegCopy", ".", "erase", "(", "PhysicalRegCopy", ".", "begin", "(", ")", ")", ";", "}", "if", "(", "SU", ")", "{", "if", "(", "CurEmitted", ">=", "InstKindLimit", "[", "IDAlu", "]", ")", "CurEmitted", "=", "0", ";", "NextInstKind", "=", "IDAlu", ";", "}", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDFetch", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDFetch", ";", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDOther", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDOther", ";", "}", "DEBUG", "(", "if", "(", "SU", ")", "{", "dbgs", "(", ")", "<<", "\" ** Pick node **\\n\"", ";", "SU", "->", "dump", "(", "DAG", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"NO NODE \\n\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "DAG", "->", "SUnits", ".", "size", "(", ")", ";", "i", "++", ")", "{", "const", "SUnit", "&", "S", "=", "DAG", "->", "SUnits", "[", "i", "]", ";", "if", "(", "!", "S", ".", "isScheduled", ")", "S", ".", "dump", "(", "DAG", ")", ";", "}", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "AMDGPU", "R600", "0", "62.5f", "\" approx. Wavefronts Required\\n\"", "2", "0", "\" ** Pick node **\\n\"", "\"NO NODE \\n\"", "0" ]

[]

[ "<s>", "char", "*", "xstormy16_output_cbranch_si", "(", "rtx", "op", ",", "const", "char", "*", "label", ",", "int", "reversed", ",", "rtx_insn", "*", "insn", ")", "{", "static", "char", "string", "[", "64", "]", ";", "int", "need_longbranch", "=", "get_attr_length", "(", "insn", ")", ">=", "8", ";", "int", "really_reversed", "=", "reversed", "^", "need_longbranch", ";", "const", "char", "*", "ccode", ";", "const", "char", "*", "templ", ";", "char", "prevop", "[", "16", "]", ";", "enum", "rtx_code", "code", ";", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "really_reversed", ")", "code", "=", "reverse_condition", "(", "code", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "ccode", "=", "\"z\"", ";", "break", ";", "case", "NE", ":", "ccode", "=", "\"nz\"", ";", "break", ";", "case", "GE", ":", "ccode", "=", "\"ge\"", ";", "break", ";", "case", "LT", ":", "ccode", "=", "\"lt\"", ";", "break", ";", "case", "GEU", ":", "ccode", "=", "\"nc\"", ";", "break", ";", "case", "LTU", ":", "ccode", "=", "\"c\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "{", "int", "regnum", ";", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", ")", ";", "regnum", "=", "REGNO", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "sprintf", "(", "prevop", ",", "\"or %s,%s\"", ",", "reg_names", "[", "regnum", "]", ",", "reg_names", "[", "regnum", "+", "1", "]", ")", ";", "}", "break", ";", "case", "GE", ":", "case", "LT", ":", "case", "GEU", ":", "case", "LTU", ":", "strcpy", "(", "prevop", ",", "\"sbc %2,%3\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "need_longbranch", ")", "templ", "=", "\"%s | b%s .+6 | jmpf %s\"", ";", "else", "templ", "=", "\"%s | b%s %s\"", ";", "sprintf", "(", "string", ",", "templ", ",", "prevop", ",", "ccode", ",", "label", ")", ";", "return", "string", ";", "}", "</s>" ]

[ "Return", "the", "string", "to", "output", "a", "conditional", "branch", "to", "LABEL", ",", "which", "is", "the", "operand", "number", "of", "the", "label", ",", "but", "suitable", "for", "the", "tail", "of", "a", "SImode", "branch", ".", "OP", "is", "the", "conditional", "expression", "(", "OP", "is", "never", "NULL_RTX", ")", ".", "REVERSED", "is", "non-zero", "if", "we", "should", "reverse", "the", "sense", "of", "the", "comparison", ".", "INSN", "is", "the", "insn", "." ]

[ "stormy16", "64", "8", "16", "\"z\"", "\"nz\"", "\"ge\"", "\"lt\"", "\"nc\"", "\"c\"", "0", "0", "\"or %s,%s\"", "1", "\"sbc %2,%3\"", "\"%s | b%s .+6 | jmpf %s\"", "\"%s | b%s %s\"" ]

[]

[ "<s>", "rtx", "sh_extending_set_of_reg", "::", "use_as_extended_reg", "(", "rtx_insn", "*", "use_at_insn", ")", "const", "{", "gcc_assert", "(", "insn", "!=", "NULL", "&&", "set_src", "!=", "NULL", "&&", "set_rtx", "!=", "NULL", ")", ";", "gcc_assert", "(", "ext_code", "==", "SIGN_EXTEND", "||", "ext_code", "==", "ZERO_EXTEND", ")", ";", "gcc_assert", "(", "from_mode", "==", "QImode", "||", "from_mode", "==", "HImode", ")", ";", "if", "(", "MEM_P", "(", "set_src", ")", "&&", "ext_code", "==", "SIGN_EXTEND", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"use_as_extended_reg: converting non-extending mem load in \"", "\"insn %d into sign-extending load\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "rtx", "r", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_insn", "*", "i0", ";", "if", "(", "from_mode", "==", "QImode", ")", "i0", "=", "emit_insn_after", "(", "gen_extendqisi2", "(", "r", ",", "set_src", ")", ",", "insn", ")", ";", "else", "if", "(", "from_mode", "==", "HImode", ")", "i0", "=", "emit_insn_after", "(", "gen_extendhisi2", "(", "r", ",", "set_src", ")", ",", "insn", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "emit_insn_after", "(", "gen_move_insn", "(", "XEXP", "(", "set_rtx", ",", "0", ")", ",", "gen_lowpart", "(", "GET_MODE", "(", "set_src", ")", ",", "r", ")", ")", ",", "i0", ")", ";", "set_insn_deleted", "(", "insn", ")", ";", "return", "r", ";", "}", "else", "{", "rtx", "extension_dst", "=", "XEXP", "(", "set_rtx", ",", "0", ")", ";", "if", "(", "GET_MODE", "(", "extension_dst", ")", "!=", "SImode", ")", "extension_dst", "=", "simplify_gen_subreg", "(", "SImode", ",", "extension_dst", ",", "GET_MODE", "(", "extension_dst", ")", ",", "0", ")", ";", "if", "(", "modified_between_p", "(", "extension_dst", ",", "insn", ",", "use_at_insn", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"use_as_extended_reg: dest reg %d of extending insn %d is \"", "\"modified, inserting a reg-reg copy\\n\"", ",", "REGNO", "(", "extension_dst", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "rtx", "r", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn_after", "(", "gen_move_insn", "(", "r", ",", "extension_dst", ")", ",", "insn", ")", ";", "return", "r", ";", "}", "else", "{", "sh_remove_reg_dead_or_unused_notes", "(", "insn", ",", "REGNO", "(", "extension_dst", ")", ")", ";", "return", "extension_dst", ";", "}", "}", "}", "</s>" ]

[ "Given", "a", "reg", "that", "is", "known", "to", "be", "sign", "or", "zero", "extended", "at", "some", "insn", ",", "take", "the", "appropriate", "measures", "so", "that", "the", "extended", "value", "can", "be", "used", "as", "a", "reg", "at", "the", "specified", "insn", "and", "return", "the", "resulting", "reg", "rtx", "." ]

[ "sh", "\"use_as_extended_reg: converting non-extending mem load in \"", "\"insn %d into sign-extending load\\n\"", "0", "0", "0", "\"use_as_extended_reg: dest reg %d of extending insn %d is \"", "\"modified, inserting a reg-reg copy\\n\"" ]

[]

[ "<s>", "StringRef", "getName", "(", ")", "const", "{", "return", "StringRef", "(", "reinterpret_cast", "<", "const", "char", "*", ">", "(", "this", ")", "+", "sizeof", "(", "*", "this", ")", ",", "namesz", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFixed", "=", "MFI", ".", "getNumFixedObjects", "(", ")", ";", "bool", "HasPrealloc", "=", "const_cast", "<", "MachineFrameInfo", "&", ">", "(", "MFI", ")", ".", "getLocalFrameObjectCount", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "true", ";", "if", "(", "(", "HasFixed", "||", "HasPrealloc", ")", "&&", "(", "HasAlloca", "||", "HasExtraAlign", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "getStackSize", "(", ")", ">", "0", ")", "{", "if", "(", "EnableStackOVFSanitizer", "||", "UseAllocframe", ")", "return", "true", ";", "}", "if", "(", "MFI", ".", "hasCalls", "(", ")", "||", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasClobberLR", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "case", "MSP430", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CSSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "MSP430::RETI", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FPW", "MSP430::POP16r", "MSP430::MOV16rr", "MSP430::SPW", "MSP430::FPW", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "bool", "CAHPAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "OS", "<<", "\"0(\"", "<<", "CAHPInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "\"0(\"", "CAHP", "\")\"" ]

[]

[ "<s>", "EVT", "SITargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "Op", ".", "size", "(", ")", ">=", "16", "&&", "Op", ".", "isDstAligned", "(", "Align", "(", "4", ")", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "Op", ".", "isDstAligned", "(", "Align", "(", "4", ")", ")", ")", "return", "MVT", "::", "v2i32", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "16", "4", "MVT::v4i32", "8", "4", "MVT::v2i32", "MVT::Other" ]

[]

[ "<s>", "void", "OpenRISCAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "OpenRISCMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "Mang", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC", "OpenRISC" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "RV16K" ]

[]

[ "<s>", "MCRegister", "SIRegisterInfo", "::", "findUnusedRegister", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ",", "bool", "ReserveHighestVGPR", ")", "const", "{", "if", "(", "ReserveHighestVGPR", ")", "{", "for", "(", "MCRegister", "Reg", ":", "reverse", "(", "*", "RC", ")", ")", "if", "(", "MRI", ".", "isAllocatable", "(", "Reg", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "return", "Reg", ";", "}", "else", "{", "for", "(", "MCRegister", "Reg", ":", "*", "RC", ")", "if", "(", "MRI", ".", "isAllocatable", "(", "Reg", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "return", "Reg", ";", "}", "return", "MCRegister", "(", ")", ";", "}", "</s>" ]

[ "Returns", "a", "lowest", "register", "that", "is", "not", "used", "at", "any", "point", "in", "the", "function", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "OptForSize", "=", "MF", ".", "getFunction", "(", ")", ".", "optForSize", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "LiveRegs", ".", "init", "(", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupBWInsts\\n\"", ";", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MF", ",", "MBB", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupBWInsts\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Start X86FixupBWInsts\\n\"", "\"End X86FixupBWInsts\\n\"" ]

[]

[ "<s>", "static", "int", "thumb_find_work_register", "(", "unsigned", "long", "pushed_regs_mask", ")", "{", "int", "reg", ";", "for", "(", "reg", "=", "LAST_ARG_REGNUM", ";", "reg", ">=", "0", ";", "reg", "--", ")", "if", "(", "!", "regs_ever_live", "[", "reg", "]", ")", "return", "reg", ";", "if", "(", "cfun", "->", "machine", "->", "uses_anonymous_args", "&&", "current_function_pretend_args_size", ">", "0", ")", "return", "LAST_ARG_REGNUM", ";", "if", "(", "!", "cfun", "->", "machine", "->", "uses_anonymous_args", "&&", "current_function_args_size", ">=", "0", "&&", "current_function_args_size", "<=", "(", "LAST_ARG_REGNUM", "*", "UNITS_PER_WORD", ")", "&&", "cfun", "->", "args_info", ".", "nregs", "<", "4", ")", "return", "LAST_ARG_REGNUM", ";", "for", "(", "reg", "=", "LAST_LO_REGNUM", ";", "reg", ">", "LAST_ARG_REGNUM", ";", "reg", "--", ")", "if", "(", "pushed_regs_mask", "&", "(", "1", "<<", "reg", ")", ")", "return", "reg", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Find", "a", "spare", "low", "register", "to", "use", "during", "the", "prolog", "of", "a", "function", "." ]

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

[]

[ "<s>", "unsigned", "getCSRFirstUseCost", "(", ")", "const", "override", "{", "return", "100", ";", "}", "</s>" ]

[ "Allow", "the", "target", "to", "override", "the", "cost", "of", "using", "a", "callee-saved", "register", "for", "the", "first", "time", "." ]

[ "AMDGPU", "100" ]

[]

[ "<s>", "machine_mode", "select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", ",", "rtx", "y", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "case", "UNLT", ":", "case", "UNLE", ":", "case", "UNGT", ":", "case", "UNGE", ":", "case", "UNEQ", ":", "case", "LTGT", ":", "return", "CCFPmode", ";", "case", "LT", ":", "case", "LE", ":", "case", "GT", ":", "case", "GE", ":", "return", "CCFPEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "GET_CODE", "(", "x", ")", "==", "MINUS", "||", "GET_CODE", "(", "x", ")", "==", "NEG", "||", "GET_CODE", "(", "x", ")", "==", "ASHIFT", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCX_NOOVmode", ";", "else", "return", "CC_NOOVmode", ";", "}", "else", "{", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCXmode", ";", "else", "return", "CCmode", ";", "}", "}", "</s>" ]

[ "Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "first", "operand", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", ".", "For", "floating-point", ",", "CCFP", "[", "E", "]", "mode", "is", "used", ".", "CC_NOOVmode", "should", "be", "used", "when", "the", "first", "operand", "is", "a", "PLUS", ",", "MINUS", ",", "NEG", ",", "or", "ASHIFT", ".", "CCmode", "should", "be", "used", "when", "no", "special", "processing", "is", "needed", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "bool", "m32c_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "m32c_hard_regno_nregs_1", "(", "regno", ",", "mode", ")", "!=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "The", "above", "function", "does", "the", "work", "already", ";", "just", "test", "its", "return", "value", "." ]

[ "m32c", "0" ]

[]

[ "<s>", "static", "tree", "msp430_attr", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "if", "(", "args", "!=", "NULL", ")", "{", "gcc_assert", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "switch", "(", "TREE_CODE", "(", "value", ")", ")", "{", "case", "STRING_CST", ":", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"reset\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"nmi\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"watchdog\"", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"unrecognised interrupt vector argument of %qE attribute\"", ",", "name", ")", ";", "break", ";", "case", "INTEGER_CST", ":", "if", "(", "wi", "::", "gtu_p", "(", "value", ",", "63", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"numeric argument of %qE attribute must be in range 0..63\"", ",", "name", ")", ";", "break", ";", "default", ":", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant or number\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "break", ";", "}", "}", "const", "char", "*", "message", "=", "NULL", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "message", "=", "\"%qE attribute only applies to functions\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "FUNCTION_TYPE", "&&", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", "message", "=", "\"interrupt handlers must be void\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_REENT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be reentrant\"", ";", "else", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be reentrant\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_CRIT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be critical\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be critical\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_NAKED", ")", ")", "{", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be naked\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be naked\"", ";", "}", "if", "(", "message", ")", "{", "warning", "(", "OPT_Wattributes", ",", "message", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Verify", "MSP430", "specific", "attributes", "." ]

[ "msp430", "\"reset\"", "\"nmi\"", "\"watchdog\"", "\"unrecognised interrupt vector argument of %qE attribute\"", "63", "\"numeric argument of %qE attribute must be in range 0..63\"", "\"argument of %qE attribute is not a string constant or number\"", "\"%qE attribute only applies to functions\"", "\"interrupt handlers must be void\"", "\"naked functions cannot be reentrant\"", "\"critical functions cannot be reentrant\"", "\"naked functions cannot be critical\"", "\"reentrant functions cannot be critical\"", "\"critical functions cannot be naked\"", "\"reentrant functions cannot be naked\"" ]

[]

[ "<s>", "int", "simple_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "addr", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "FALSE", ";", "indirection", ":", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "return", "1", ";", "case", "MEM", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "return", "0", ";", "op", "=", "addr", ";", "goto", "indirection", ";", "case", "CONST_INT", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "return", "0", ";", "case", "PLUS", ":", "return", "0", ";", "default", ":", "break", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "truth", "value", "if", "a", "memory", "operand", "fits", "in", "a", "single", "instruction", "(", "ie", ",", "register", "+", "small", "offset", ")", "." ]

[ "pdp11", "0", "1", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "emit_push_byte", "(", "unsigned", "regno", ",", "bool", "frame_related_p", ")", "{", "rtx", "mem", ",", "reg", ";", "rtx_insn", "*", "insn", ";", "mem", "=", "gen_rtx_POST_DEC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "cfun", "->", "machine", "->", "stack_usage", "++", ";", "}", "</s>" ]

[ "Helper", "for", "expand_prologue", ".", "Emit", "a", "push", "of", "a", "byte", "register", "." ]

[ "avr", "1" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "TS", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "InConstantPool", "&&", "Opc", "!=", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "InConstantPool", "=", "false", ";", "}", "if", "(", "Opc", "==", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "LabelId", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "CPIdx", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "if", "(", "!", "InConstantPool", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegion", ")", ";", "InConstantPool", "=", "true", ";", "}", "OutStreamer", "->", "EmitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "EmitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "EmitGlobalConstant", "(", "MF", "->", "getDataLayout", "(", ")", ",", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Mips", "::", "PATCHABLE_FUNCTION_ENTER", ":", "LowerPATCHABLE_FUNCTION_ENTER", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_FUNCTION_EXIT", ":", "LowerPATCHABLE_FUNCTION_EXIT", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_TAIL_CALL", ":", "LowerPATCHABLE_TAIL_CALL", "(", "*", "MI", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG64", ")", "{", "emitPseudoIndirectBranch", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "&", "*", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "128", "Mips::CONSTPOOL_ENTRY", "Mips::CONSTPOOL_ENTRY", "0", "1", "Mips::PATCHABLE_FUNCTION_ENTER", "Mips::PATCHABLE_FUNCTION_EXIT", "Mips::PATCHABLE_TAIL_CALL", "Mips::PseudoReturn", "Mips::PseudoReturn64", "Mips::PseudoIndirectBranch", "Mips::PseudoIndirectBranch64", "Mips::TAILCALLREG", "Mips::TAILCALLREG64", "Mips", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "void", "ARMInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "AFI", "->", "isThumbFunction", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tSpill", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FSTD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", "&&", "\"Unknown regclass!\"", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FSTS", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegisterClass", "ARM", "ARM", "ARM::STR", "0", "0", "ARM::tGPRRegisterClass", "ARM", "ARM", "ARM::tSpill", "0", "ARM::DPRRegisterClass", "ARM::FSTD", "0", "ARM::SPRRegisterClass", "\"Unknown regclass!\"", "ARM::FSTS", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "ia64_invalid_binary_op", "(", "int", "op", "ATTRIBUTE_UNUSED", ",", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "if", "(", "TYPE_MODE", "(", "type1", ")", "==", "RFmode", "||", "TYPE_MODE", "(", "type2", ")", "==", "RFmode", ")", "return", "N_", "(", "\"invalid operation on %<__fpreg%>\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "the", "diagnostic", "message", "string", "if", "the", "binary", "operation", "OP", "is", "not", "permitted", "on", "TYPE1", "and", "TYPE2", ",", "NULL", "otherwise", "." ]

[ "ia64", "\"invalid operation on %<__fpreg%>\"" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16rm", "0", "MSP430::GR8RegClass", "MSP430::MOV8rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "void", "MCS51FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "MCS51", "::", "R29", ")", ";", "SavedRegs", ".", "set", "(", "MCS51", "::", "R28", ")", ";", "}", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51::R29", "MCS51::R28" ]

[]

[ "<s>", "static", "int", "ix86_mode_needed", "(", "int", "entity", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "ix86_dirflag_mode_needed", "(", "insn", ")", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_needed", "(", "insn", ")", ";", "case", "I387_ROUNDEVEN", ":", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "ix86_i387_mode_needed", "(", "entity", ",", "insn", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "SIFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", ")", "{", "if", "(", "MFI", ".", "getStackSize", "(", ")", "!=", "0", ")", "return", "true", ";", "if", "(", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "isEntryFunction", "(", ")", ")", "return", "true", ";", "}", "return", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "needsStackRealignment", "(", "MF", ")", "||", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "XtensaPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createXtensaISelDag", "(", "getXtensaTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "Xtensa", "Xtensa" ]

[]

[ "<s>", "const", "RegisterBank", "&", "SPIRVRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", "Ty", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "SPIRV", "::", "TYPERegClassID", ":", "return", "SPIRV", "::", "TYPERegBank", ";", "case", "SPIRV", "::", "pIDRegClassID", ":", "case", "SPIRV", "::", "IDRegClassID", ":", "return", "SPIRV", "::", "IDRegBank", ";", "case", "SPIRV", "::", "fIDRegClassID", ":", "return", "SPIRV", "::", "fIDRegBank", ";", "case", "SPIRV", "::", "vIDRegClassID", ":", "return", "SPIRV", "::", "vIDRegBank", ";", "case", "SPIRV", "::", "vfIDRegClassID", ":", "return", "SPIRV", "::", "vfIDRegBank", ";", "case", "SPIRV", "::", "ANYIDRegClassID", ":", "case", "SPIRV", "::", "ANYRegClassID", ":", "return", "SPIRV", "::", "IDRegBank", ";", "}", "llvm_unreachable", "(", "\"Unknown register class\"", ")", ";", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "SPIRV", "SPIRV", "SPIRV::TYPERegClassID", "SPIRV::TYPERegBank", "SPIRV::pIDRegClassID", "SPIRV::IDRegClassID", "SPIRV::IDRegBank", "SPIRV::fIDRegClassID", "SPIRV::fIDRegBank", "SPIRV::vIDRegClassID", "SPIRV::vIDRegBank", "SPIRV::vfIDRegClassID", "SPIRV::vfIDRegBank", "SPIRV::ANYIDRegClassID", "SPIRV::ANYRegClassID", "SPIRV::IDRegBank", "\"Unknown register class\"" ]

[]

[ "<s>", "int", "RISCVFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "bool", "HasRISCVVector", "=", "RVFI", "->", "hasSpillVRs", "(", ")", ";", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "RISCV", "::", "X2", ";", "if", "(", "FirstSPAdjustAmount", ")", "Offset", "+=", "FirstSPAdjustAmount", ";", "else", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "else", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "if", "(", "hasBP", "(", "MF", ")", ")", "FrameReg", "=", "RISCVABI", "::", "getBPReg", "(", ")", ";", "else", "FrameReg", "=", "RISCV", "::", "X2", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "Offset", "+=", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "FI", ">=", "0", ")", "Offset", "-=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "}", "return", "Offset", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "0", "1", "0", "1", "RISCV::X2", "RISCVABI::getBPReg", "RISCV::X2", "0", "0", "0" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "auto", "&", "NonLibcallCSI", "=", "getNonLibcallCSI", "(", "CSI", ")", ";", "for", "(", "auto", "&", "CS", ":", "reverse", "(", "NonLibcallCSI", ")", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "const", "char", "*", "RestoreLibCall", "=", "getRestoreLibCallName", "(", "*", "MF", ",", "CSI", ")", ";", "if", "(", "RestoreLibCall", ")", "{", "MachineBasicBlock", "::", "iterator", "NewMI", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PseudoTAIL", ")", ")", ".", "addExternalSymbol", "(", "RestoreLibCall", ",", "RISCVII", "::", "MO_CALL", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "MI", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoRET", ")", "{", "NewMI", "->", "copyImplicitOps", "(", "*", "MF", ",", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"loadRegFromStackSlot didn't insert any code!\"", "RISCV::PseudoTAIL", "RISCVII::MO_CALL", "RISCV::PseudoRET" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_sve_tbl", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "HOST_WIDE_INT", "nelt", ";", "if", "(", "!", "d", "->", "one_vector_p", "&&", "!", "d", "->", "perm", ".", "length", "(", ")", ".", "is_constant", "(", "&", "nelt", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "machine_mode", "sel_mode", "=", "mode_for_int_vector", "(", "d", "->", "vmode", ")", ".", "require", "(", ")", ";", "rtx", "sel", "=", "vec_perm_indices_to_rtx", "(", "sel_mode", ",", "d", "->", "perm", ")", ";", "if", "(", "d", "->", "one_vector_p", ")", "emit_unspec2", "(", "d", "->", "target", ",", "UNSPEC_TBL", ",", "d", "->", "op0", ",", "force_reg", "(", "sel_mode", ",", "sel", ")", ")", ";", "else", "aarch64_expand_sve_vec_perm", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "sel", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "implement", "D", "using", "an", "SVE", "TBL", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "char", "*", "output_move_vfp", "(", "rtx", "*", "operands", ")", "{", "rtx", "reg", ",", "mem", ",", "addr", ",", "ops", "[", "2", "]", ";", "int", "load", "=", "REG_P", "(", "operands", "[", "0", "]", ")", ";", "int", "dp", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "==", "8", ";", "int", "sp", "=", "(", "!", "TARGET_VFP_FP16INST", "||", "GET_MODE_SIZE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "==", "4", ")", ";", "int", "integer_p", "=", "GET_MODE_CLASS", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "==", "MODE_INT", ";", "const", "char", "*", "templ", ";", "char", "buff", "[", "50", "]", ";", "machine_mode", "mode", ";", "reg", "=", "operands", "[", "!", "load", "]", ";", "mem", "=", "operands", "[", "load", "]", ";", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "gcc_assert", "(", "IS_VFP_REGNUM", "(", "REGNO", "(", "reg", ")", ")", ")", ";", "gcc_assert", "(", "(", "mode", "==", "HFmode", "&&", "TARGET_HARD_FLOAT", ")", "||", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", "||", "mode", "==", "HImode", "||", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "(", "TARGET_NEON", "&&", "VALID_NEON_DREG_MODE", "(", "mode", ")", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PRE_DEC", ":", "templ", "=", "\"v%smdb%%?.%s\\t%%0!, {%%%s1}%s\"", ";", "ops", "[", "0", "]", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "ops", "[", "1", "]", "=", "reg", ";", "break", ";", "case", "POST_INC", ":", "templ", "=", "\"v%smia%%?.%s\\t%%0!, {%%%s1}%s\"", ";", "ops", "[", "0", "]", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "ops", "[", "1", "]", "=", "reg", ";", "break", ";", "default", ":", "templ", "=", "\"v%sr%%?.%s\\t%%%s0, %%1%s\"", ";", "ops", "[", "0", "]", "=", "reg", ";", "ops", "[", "1", "]", "=", "mem", ";", "break", ";", "}", "sprintf", "(", "buff", ",", "templ", ",", "load", "?", "\"ld\"", ":", "\"st\"", ",", "dp", "?", "\"64\"", ":", "sp", "?", "\"32\"", ":", "\"16\"", ",", "dp", "?", "\"P\"", ":", "\"\"", ",", "integer_p", "?", "\"\\t%@ int\"", ":", "\"\"", ")", ";", "output_asm_insn", "(", "buff", ",", "ops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "VFP", "load", "or", "store", "instruction", "." ]

[ "arm", "2", "0", "0", "8", "0", "4", "0", "50", "0", "\"v%smdb%%?.%s\\t%%0!, {%%%s1}%s\"", "0", "0", "1", "\"v%smia%%?.%s\\t%%0!, {%%%s1}%s\"", "0", "0", "1", "\"v%sr%%?.%s\\t%%%s0, %%1%s\"", "0", "1", "\"ld\"", "\"st\"", "\"64\"", "\"32\"", "\"16\"", "\"P\"", "\"\"", "\"\\t%@ int\"", "\"\"", "\"\"" ]

[]

[ "<s>", "bool", "isLegalMaskedStore", "(", "Type", "*", "DataType", ",", "MaybeAlign", "Alignment", ")", "{", "return", "isLegalMaskedLoadStore", "(", "DataType", ",", "Alignment", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "WebAssemblyEHRestoreStackPointer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** EH Restore Stack Pointer **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "auto", "*", "FrameLowering", "=", "static_cast", "<", "const", "WebAssemblyFrameLowering", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "if", "(", "!", "FrameLowering", "->", "needsPrologForEH", "(", "MF", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "if", "(", "!", "MBB", ".", "isEHPad", "(", ")", ")", "continue", ";", "Changed", "=", "true", ";", "auto", "InsertPos", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "WebAssembly", "::", "isCatch", "(", "*", "MBB", ".", "begin", "(", ")", ")", ")", "InsertPos", "++", ";", "FrameLowering", "->", "writeSPToGlobal", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "InsertPos", ",", "MBB", ".", "begin", "(", ")", "->", "getDebugLoc", "(", ")", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** EH Restore Stack Pointer **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly::isCatch", "WebAssembly::SP32" ]

[]

[ "<s>", "void", "rs6000_output_function_entry", "(", "FILE", "*", "file", ",", "const", "char", "*", "fname", ")", "{", "if", "(", "fname", "[", "0", "]", "!=", "'.'", ")", "{", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ABI_AIX", ":", "if", "(", "DOT_SYMBOLS", ")", "putc", "(", "'.'", ",", "file", ")", ";", "else", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "file", ",", "\"L.\"", ")", ";", "break", ";", "case", "ABI_ELFv2", ":", "case", "ABI_V4", ":", "case", "ABI_DARWIN", ":", "break", ";", "}", "}", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "fname", ")", ";", "}", "</s>" ]

[ "Write", "out", "a", "function", "code", "label", "." ]

[ "rs6000", "0", "\"L.\"" ]

[]

[ "<s>", "bool", "SystemZTDCPass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", "F", ")", ".", "hasSoftFloat", "(", ")", ")", "return", "false", ";", "ConvertedInsts", ".", "clear", "(", ")", ";", "LogicOpsWorklist", ".", "clear", "(", ")", ";", "PossibleJunk", ".", "clear", "(", ")", ";", "for", "(", "auto", "&", "I", ":", "instructions", "(", "F", ")", ")", "{", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "Instruction", "::", "FCmp", ")", "convertFCmp", "(", "cast", "<", "CmpInst", ">", "(", "I", ")", ")", ";", "else", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "Instruction", "::", "ICmp", ")", "convertICmp", "(", "cast", "<", "CmpInst", ">", "(", "I", ")", ")", ";", "}", "if", "(", "ConvertedInsts", ".", "empty", "(", ")", ")", "return", "false", ";", "while", "(", "!", "LogicOpsWorklist", ".", "empty", "(", ")", ")", "{", "BinaryOperator", "*", "Op", "=", "LogicOpsWorklist", ".", "back", "(", ")", ";", "LogicOpsWorklist", ".", "pop_back", "(", ")", ";", "if", "(", "ConvertedInsts", ".", "count", "(", "dyn_cast", "<", "Instruction", ">", "(", "Op", "->", "getOperand", "(", "0", ")", ")", ")", "&&", "ConvertedInsts", ".", "count", "(", "dyn_cast", "<", "Instruction", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "&&", "!", "ConvertedInsts", ".", "count", "(", "Op", ")", ")", "convertLogicOp", "(", "*", "Op", ")", ";", "}", "Module", "&", "M", "=", "*", "F", ".", "getParent", "(", ")", ";", "auto", "&", "Ctx", "=", "M", ".", "getContext", "(", ")", ";", "Value", "*", "Zero32", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ",", "0", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "&", "It", ":", "reverse", "(", "ConvertedInsts", ")", ")", "{", "Instruction", "*", "I", "=", "It", ".", "first", ";", "Value", "*", "V", ";", "int", "Mask", ";", "bool", "Worthy", ";", "std", "::", "tie", "(", "V", ",", "Mask", ",", "Worthy", ")", "=", "It", ".", "second", ";", "if", "(", "!", "I", "->", "user_empty", "(", ")", ")", "{", "if", "(", "!", "Worthy", ")", "continue", ";", "Function", "*", "TDCFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "s390_tdc", ",", "V", "->", "getType", "(", ")", ")", ";", "IRBuilder", "<", ">", "IRB", "(", "I", ")", ";", "Value", "*", "MaskVal", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt64Ty", "(", "Ctx", ")", ",", "Mask", ")", ";", "Instruction", "*", "TDC", "=", "IRB", ".", "CreateCall", "(", "TDCFunc", ",", "{", "V", ",", "MaskVal", "}", ")", ";", "Value", "*", "ICmp", "=", "IRB", ".", "CreateICmp", "(", "CmpInst", "::", "ICMP_NE", ",", "TDC", ",", "Zero32", ")", ";", "I", "->", "replaceAllUsesWith", "(", "ICmp", ")", ";", "}", "I", "->", "eraseFromParent", "(", ")", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "!", "MadeChange", ")", "return", "false", ";", "for", "(", "auto", "*", "I", ":", "PossibleJunk", ")", "if", "(", "I", "->", "user_empty", "(", ")", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "0", "1", "0", "Intrinsic::getDeclaration", "Intrinsic::s390_tdc" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", "||", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "DA", "=", "&", "getAnalysis", "<", "DivergenceAnalysis", ">", "(", ")", ";", "visit", "(", "F", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "MachineBasicBlock", "*", "XCoreTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "SELECT_CC", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "BRFT_lru6", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "XCore", "XCore", "XCore::SELECT_CC", "\"Unexpected instr type to insert\"", "XCore::BRFT_lru6", "1", "XCore::PHI", "0", "3", "2" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_cmp", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "cmp_ops_mode", "=", "GET_MODE", "(", "cmp_op0", ")", ";", "machine_mode", "cmp_mode", ";", "bool", "maskcmp", "=", "false", ";", "rtx", "x", ";", "if", "(", "GET_MODE_SIZE", "(", "cmp_ops_mode", ")", "==", "64", ")", "{", "cmp_mode", "=", "mode_for_size", "(", "GET_MODE_NUNITS", "(", "cmp_ops_mode", ")", ",", "MODE_INT", ",", "0", ")", ";", "gcc_assert", "(", "cmp_mode", "!=", "BLKmode", ")", ";", "maskcmp", "=", "true", ";", "}", "else", "cmp_mode", "=", "cmp_ops_mode", ";", "cmp_op0", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op0", ")", ";", "if", "(", "!", "nonimmediate_operand", "(", "cmp_op1", ",", "cmp_ops_mode", ")", ")", "cmp_op1", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op1", ")", ";", "if", "(", "optimize", "||", "(", "maskcmp", "&&", "cmp_mode", "!=", "mode", ")", "||", "(", "op_true", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_true", ")", ")", "||", "(", "op_false", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_false", ")", ")", ")", "dest", "=", "gen_reg_rtx", "(", "maskcmp", "?", "cmp_mode", ":", "mode", ")", ";", "if", "(", "maskcmp", "&&", "(", "code", "==", "GT", "||", "code", "==", "EQ", ")", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "cmp_ops_mode", ")", "{", "case", "V64QImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv64qi3", ":", "gen_avx512bw_eqv64qi3_1", ";", "break", ";", "case", "V32HImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv32hi3", ":", "gen_avx512bw_eqv32hi3_1", ";", "break", ";", "case", "V16SImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv16si3", ":", "gen_avx512f_eqv16si3_1", ";", "break", ";", "case", "V8DImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv8di3", ":", "gen_avx512f_eqv8di3_1", ";", "break", ";", "default", ":", "gen", "=", "NULL", ";", "}", "if", "(", "gen", ")", "{", "emit_insn", "(", "gen", "(", "dest", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "return", "dest", ";", "}", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "cmp_mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "cmp_mode", "!=", "mode", "&&", "!", "maskcmp", ")", "{", "x", "=", "force_reg", "(", "cmp_ops_mode", ",", "x", ")", ";", "convert_move", "(", "dest", ",", "x", ",", "false", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Expand", "an", "sse", "vector", "comparison", ".", "Return", "the", "register", "with", "the", "result", "." ]

[ "i386", "64", "0" ]

[]

[ "<s>", "bool", "nvptx_libc_has_function", "(", "enum", "function_class", "fn_class", ",", "tree", "type", ")", "{", "if", "(", "fn_class", "==", "function_sincos", ")", "{", "if", "(", "type", "!=", "NULL_TREE", ")", "return", "type", "==", "float_type_node", "||", "type", "==", "double_type_node", ";", "else", "return", "true", ";", "}", "return", "default_libc_has_function", "(", "fn_class", ",", "type", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBC_HAS_FUNCTION", "." ]

[ "nvptx" ]

[]

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

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

[ "CSKY" ]

[]

[ "<s>", "void", "LM32InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "'%'", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

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

[ "LM32", "LM32" ]

[]

[ "<s>", "static", "bool", "fusion_load_store", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ",", "bool", "*", "is_load", ")", "{", "rtx", "x", ",", "dest", ",", "src", ";", "gcc_assert", "(", "INSN_P", "(", "insn", ")", ")", ";", "x", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SET", ")", "return", "false", ";", "src", "=", "SET_SRC", "(", "x", ")", ";", "dest", "=", "SET_DEST", "(", "x", ")", ";", "if", "(", "REG_P", "(", "src", ")", "&&", "MEM_P", "(", "dest", ")", ")", "{", "*", "is_load", "=", "false", ";", "extract_base_offset_in_addr", "(", "dest", ",", "base", ",", "offset", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", "&&", "REG_P", "(", "dest", ")", ")", "{", "*", "is_load", "=", "true", ";", "extract_base_offset_in_addr", "(", "src", ",", "base", ",", "offset", ")", ";", "}", "else", "return", "false", ";", "return", "(", "*", "base", "!=", "NULL_RTX", "&&", "*", "offset", "!=", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "If", "INSN", "is", "a", "load", "or", "store", "of", "address", "in", "the", "form", "of", "[", "base+offset", "]", ",", "extract", "the", "two", "parts", "and", "set", "to", "BASE", "and", "OFFSET", ".", "IS_LOAD", "is", "set", "to", "TRUE", "if", "it", "'s", "a", "load", ".", "Return", "TRUE", "if", "INSN", "is", "such", "an", "instruction", ",", "otherwise", "return", "FALSE", "." ]

[ "arm" ]

[]

[ "<s>", "static", "int", "get_vec_cmp_insn", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "dest_mode", ",", "enum", "machine_mode", "op_mode", ")", "{", "if", "(", "!", "TARGET_ALTIVEC", ")", "return", "INSN_NOT_AVAILABLE", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "if", "(", "dest_mode", "==", "V16QImode", "&&", "op_mode", "==", "V16QImode", ")", "return", "UNSPEC_VCMPEQUB", ";", "if", "(", "dest_mode", "==", "V8HImode", "&&", "op_mode", "==", "V8HImode", ")", "return", "UNSPEC_VCMPEQUH", ";", "if", "(", "dest_mode", "==", "V4SImode", "&&", "op_mode", "==", "V4SImode", ")", "return", "UNSPEC_VCMPEQUW", ";", "if", "(", "dest_mode", "==", "V4SImode", "&&", "op_mode", "==", "V4SFmode", ")", "return", "UNSPEC_VCMPEQFP", ";", "break", ";", "case", "GE", ":", "if", "(", "dest_mode", "==", "V4SImode", "&&", "op_mode", "==", "V4SFmode", ")", "return", "UNSPEC_VCMPGEFP", ";", "case", "GT", ":", "if", "(", "dest_mode", "==", "V16QImode", "&&", "op_mode", "==", "V16QImode", ")", "return", "UNSPEC_VCMPGTSB", ";", "if", "(", "dest_mode", "==", "V8HImode", "&&", "op_mode", "==", "V8HImode", ")", "return", "UNSPEC_VCMPGTSH", ";", "if", "(", "dest_mode", "==", "V4SImode", "&&", "op_mode", "==", "V4SImode", ")", "return", "UNSPEC_VCMPGTSW", ";", "if", "(", "dest_mode", "==", "V4SImode", "&&", "op_mode", "==", "V4SFmode", ")", "return", "UNSPEC_VCMPGTFP", ";", "break", ";", "case", "GTU", ":", "if", "(", "dest_mode", "==", "V16QImode", "&&", "op_mode", "==", "V16QImode", ")", "return", "UNSPEC_VCMPGTUB", ";", "if", "(", "dest_mode", "==", "V8HImode", "&&", "op_mode", "==", "V8HImode", ")", "return", "UNSPEC_VCMPGTUH", ";", "if", "(", "dest_mode", "==", "V4SImode", "&&", "op_mode", "==", "V4SImode", ")", "return", "UNSPEC_VCMPGTUW", ";", "break", ";", "default", ":", "break", ";", "}", "return", "INSN_NOT_AVAILABLE", ";", "}", "</s>" ]

[ "Return", "insn", "index", "for", "the", "vector", "compare", "instruction", "for", "given", "CODE", ",", "and", "DEST_MODE", ",", "OP_MODE", ".", "Return", "-1", "if", "valid", "insn", "is", "not", "available", "." ]

[ "rs6000" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Delay Slot Filler\"" ]

[]

[ "<s>", "static", "bool", "pru_addr_space_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "operand", ",", "bool", "strict_p", ",", "addr_space_t", "as", ")", "{", "if", "(", "as", "==", "ADDR_SPACE_REGIO", ")", "{", "return", "true", ";", "}", "else", "if", "(", "as", "!=", "ADDR_SPACE_GENERIC", ")", "{", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "case", "CONST_WIDE_INT", ":", "return", "false", ";", "case", "CONST_INT", ":", "return", "ctable_addr_operand", "(", "operand", ",", "VOIDmode", ")", ";", "case", "REG", ":", "return", "pru_regno_ok_for_base_p", "(", "REGNO", "(", "operand", ")", ",", "strict_p", ")", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "operand", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operand", ",", "1", ")", ";", "return", "pru_valid_addr_expr_p", "(", "mode", ",", "op0", ",", "op1", ",", "strict_p", ")", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P", "." ]

[ "pru", "0", "1" ]

[]

[ "<s>", "unsigned", "X86FrameLowering", "::", "getWinEHFuncletFrameSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "CSSize", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getCalleeSavedFrameSize", "(", ")", ";", "unsigned", "UsedSize", ";", "EHPersonality", "Personality", "=", "classifyEHPersonality", "(", "MF", ".", "getFunction", "(", ")", "->", "getPersonalityFn", "(", ")", ")", ";", "if", "(", "Personality", "==", "EHPersonality", "::", "CoreCLR", ")", "{", "UsedSize", "=", "getPSPSlotOffsetFromSP", "(", "MF", ")", "+", "SlotSize", ";", "}", "else", "{", "UsedSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getMaxCallFrameSize", "(", ")", ";", "}", "unsigned", "FrameSizeMinusRBP", "=", "alignTo", "(", "CSSize", "+", "UsedSize", ",", "getStackAlignment", "(", ")", ")", ";", "return", "FrameSizeMinusRBP", "-", "CSSize", ";", "}", "</s>" ]

[ "Funclets", "only", "need", "to", "account", "for", "space", "for", "the", "callee", "saved", "registers", ",", "as", "the", "locals", "are", "accounted", "for", "in", "the", "parent", "'s", "stack", "frame", "." ]

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

[]

[ "<s>", "bool", "mips_use_pic_fn_addr_reg_p", "(", "const_rtx", "x", ")", "{", "if", "(", "!", "TARGET_USE_PIC_FN_ADDR_REG", ")", "return", "false", ";", "if", "(", "mips16_stub_function_p", "(", "x", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "TARGET_ABICALLS_PIC0", ")", "return", "false", ";", "if", "(", "TARGET_ABSOLUTE_ABICALLS", "&&", "mips_symbol_binds_local_p", "(", "x", ")", "&&", "!", "SYMBOL_REF_EXTERNAL_P", "(", "x", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "calls", "to", "X", "might", "need", "$", "25", "to", "be", "valid", "on", "entry", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isAssociativeAndCommutative", "(", "const", "MachineInstr", "&", "Inst", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "PPC", "::", "FADD", ":", "case", "PPC", "::", "FADDS", ":", "case", "PPC", "::", "FMUL", ":", "case", "PPC", "::", "FMULS", ":", "case", "PPC", "::", "VADDFP", ":", "case", "PPC", "::", "XSADDDP", ":", "case", "PPC", "::", "XVADDDP", ":", "case", "PPC", "::", "XVADDSP", ":", "case", "PPC", "::", "XSADDSP", ":", "case", "PPC", "::", "XSMULDP", ":", "case", "PPC", "::", "XVMULDP", ":", "case", "PPC", "::", "XVMULSP", ":", "case", "PPC", "::", "XSMULSP", ":", "return", "Inst", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmReassoc", ")", "&&", "Inst", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmNsz", ")", ";", "case", "PPC", "::", "MULHD", ":", "case", "PPC", "::", "MULLD", ":", "case", "PPC", "::", "MULHW", ":", "case", "PPC", "::", "MULLW", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "when", "\\P", "Inst", "is", "both", "associative", "and", "commutative", "." ]

[ "PowerPC", "PPC", "PPC::FADD", "PPC::FADDS", "PPC::FMUL", "PPC::FMULS", "PPC::VADDFP", "PPC::XSADDDP", "PPC::XVADDDP", "PPC::XVADDSP", "PPC::XSADDSP", "PPC::XSMULDP", "PPC::XVMULDP", "PPC::XVMULSP", "PPC::XSMULSP", "PPC::MULHD", "PPC::MULLD", "PPC::MULHW", "PPC::MULLW" ]

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "VEISD", "::", "NAME", ":", "\\", "return", "\"VEISD::\"", "#", "NAME", ";", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "VE", "VE", "VEISD::NAME", "\"VEISD::\"", "VEISD::NodeType", "VEISD::FIRST_NUMBER" ]

[]

[ "<s>", "int", "pa_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "(", "unsigned", "int", ")", "length", ">=", "INT_MAX", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SEQUENCE", ")", "insn", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_MILLI", ":", "length", "=", "pa_attr_length_millicode_call", "(", "insn", ")", ";", "break", ";", "case", "TYPE_CALL", ":", "length", "=", "pa_attr_length_call", "(", "insn", ",", "0", ")", ";", "break", ";", "case", "TYPE_SIBCALL", ":", "length", "=", "pa_attr_length_call", "(", "insn", ",", "1", ")", ";", "break", ";", "case", "TYPE_DYNCALL", ":", "length", "=", "pa_attr_length_indirect_call", "(", "insn", ")", ";", "break", ";", "case", "TYPE_SH_FUNC_ADRS", ":", "length", "=", "pa_attr_length_millicode_call", "(", "insn", ")", "+", "20", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", ")", "==", "MEM", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "BLKmode", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", ")", "==", "BLKmode", ")", "length", "+=", "compute_movmem_length", "(", "insn", ")", "-", "4", ";", "else", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "MEM", "&&", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", "==", "const0_rtx", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "BLKmode", ")", "length", "+=", "compute_clrmem_length", "(", "insn", ")", "-", "4", ";", "else", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "!", "simplejump_p", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "length", "==", "4", "&&", "JUMP_LABEL", "(", "insn", ")", "!=", "NULL_RTX", "&&", "!", "forward_branch_p", "(", "insn", ")", ")", "length", "+=", "4", ";", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_PARALLEL_BRANCH", "&&", "length", "==", "4", ")", "length", "+=", "4", ";", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", "==", "REG", "&&", "!", "FP_REG_P", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", "&&", "length", "==", "4", "&&", "!", "forward_branch_p", "(", "insn", ")", ")", "length", "+=", "4", ";", "}", "return", "length", ";", "}", "</s>" ]

[ "Return", "any", "length", "adjustment", "needed", "by", "INSN", "which", "already", "has", "its", "length", "computed", "as", "LENGTH", ".", "Return", "zero", "if", "no", "adjustment", "is", "necessary", ".", "For", "the", "PA", ":", "function", "calls", ",", "millicode", "calls", ",", "and", "backwards", "short", "conditional", "branches", "with", "unfilled", "delay", "slots", "need", "an", "adjustment", "by", "+1", "(", "to", "account", "for", "the", "NOP", "which", "will", "be", "inserted", "into", "the", "instruction", "stream", ")", ".", "Also", "compute", "the", "length", "of", "an", "inline", "block", "move", "here", "as", "it", "is", "too", "complicated", "to", "express", "as", "a", "length", "attribute", "in", "pa.md", "." ]

[ "pa", "0", "0", "0", "1", "20", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "1", "4", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "4", "4", "4", "4", "4", "0", "1", "0", "1", "0", "0", "1", "0", "4", "4" ]

[]

[ "<s>", "static", "void", "assign_int_registers", "(", "HOST_WIDE_INT", "bitpos", ",", "assign_data_t", "*", "data", ")", "{", "int", "intoffset", "=", "data", "->", "intoffset", ";", "machine_mode", "mode", ";", "int", "nregs", ";", "if", "(", "!", "compute_int_layout", "(", "bitpos", ",", "data", ",", "&", "nregs", ")", ")", "return", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "mode", "=", "smallest_mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ",", "MODE_INT", ")", ";", "else", "mode", "=", "word_mode", ";", "const", "int", "this_slotno", "=", "data", "->", "slotno", "+", "intoffset", "/", "BITS_PER_WORD", ";", "unsigned", "int", "regno", "=", "data", "->", "regbase", "+", "this_slotno", ";", "intoffset", "/=", "BITS_PER_UNIT", ";", "do", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "data", "->", "ret", ",", "0", ",", "data", "->", "stack", "+", "data", "->", "nregs", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "data", "->", "nregs", "+=", "1", ";", "mode", "=", "word_mode", ";", "regno", "+=", "1", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "1", ")", ")", "+", "1", ";", "}", "while", "(", "--", "nregs", ">", "0", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_record_value", ".", "Assign", "the", "bits", "of", "the", "structure", "between", "PARMS-", ">", "intoffset", "and", "BITPOS", "to", "integer", "registers", "." ]

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

[]

[ "<s>", "static", "void", "ix86_emit_mode_set", "(", "int", "entity", ",", "int", "mode", ",", "int", "prev_mode", "ATTRIBUTE_UNUSED", ",", "HARD_REG_SET", "regs_live", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "if", "(", "mode", "==", "X86_DIRFLAG_RESET", ")", "emit_insn", "(", "gen_cld", "(", ")", ")", ";", "break", ";", "case", "AVX_U128", ":", "if", "(", "mode", "==", "AVX_U128_CLEAN", ")", "ix86_expand_avx_vzeroupper", "(", ")", ";", "break", ";", "case", "I387_ROUNDEVEN", ":", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "if", "(", "mode", "!=", "I387_CW_ANY", "&&", "mode", "!=", "I387_CW_UNINITIALIZED", ")", "emit_i387_cw_initialization", "(", "mode", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "one", "or", "more", "insns", "to", "set", "ENTITY", "to", "MODE", ".", "HARD_REG_LIVE", "is", "the", "set", "of", "hard", "registers", "live", "at", "the", "point", "where", "the", "insn", "(", "s", ")", "are", "to", "be", "inserted", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "moxie_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "*", "cum", "<", "8", ")", "return", "gen_rtx_REG", "(", "mode", ",", "*", "cum", ")", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "the", "next", "register", "to", "be", "used", "to", "hold", "a", "function", "argument", "or", "NULL_RTX", "if", "there", "'s", "no", "more", "space", "." ]

[ "moxie", "8" ]

[]

[ "<s>", "void", "GCNScheduleDAGMILive", "::", "finalizeSchedule", "(", ")", "{", "GCNMaxOccupancySchedStrategy", "&", "S", "=", "(", "GCNMaxOccupancySchedStrategy", "&", ")", "*", "SchedImpl", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"All regions recorded, starting actual scheduling.\\n\"", ")", ";", "LiveIns", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "Pressure", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "do", "{", "Stage", "++", ";", "RegionIdx", "=", "0", ";", "MachineBasicBlock", "*", "MBB", "=", "nullptr", ";", "if", "(", "Stage", ">", "1", ")", "{", "if", "(", "!", "LIS", "||", "StartingOccupancy", "<=", "MinOccupancy", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Retrying function scheduling with lowest recorded occupancy \"", "<<", "MinOccupancy", "<<", "\".\\n\"", ")", ";", "S", ".", "setTargetOccupancy", "(", "MinOccupancy", ")", ";", "}", "for", "(", "auto", "Region", ":", "Regions", ")", "{", "RegionBegin", "=", "Region", ".", "first", ";", "RegionEnd", "=", "Region", ".", "second", ";", "if", "(", "RegionBegin", "->", "getParent", "(", ")", "!=", "MBB", ")", "{", "if", "(", "MBB", ")", "finishBlock", "(", ")", ";", "MBB", "=", "RegionBegin", "->", "getParent", "(", ")", ";", "startBlock", "(", "MBB", ")", ";", "if", "(", "Stage", "==", "1", ")", "computeBlockPressure", "(", "MBB", ")", ";", "}", "unsigned", "NumRegionInstrs", "=", "std", "::", "distance", "(", "begin", "(", ")", ",", "end", "(", ")", ")", ";", "enterRegion", "(", "MBB", ",", "begin", "(", ")", ",", "end", "(", ")", ",", "NumRegionInstrs", ")", ";", "if", "(", "begin", "(", ")", "==", "end", "(", ")", "||", "begin", "(", ")", "==", "std", "::", "prev", "(", "end", "(", ")", ")", ")", "{", "exitRegion", "(", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Scheduling **********\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "MF", ".", "getName", "(", ")", "<<", "\":\"", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "\" \"", "<<", "MBB", "->", "getName", "(", ")", "<<", "\"\\n From: \"", "<<", "*", "begin", "(", ")", "<<", "\" To: \"", ";", "if", "(", "RegionEnd", "!=", "MBB", "->", "end", "(", ")", ")", "dbgs", "(", ")", "<<", "*", "RegionEnd", ";", "else", "dbgs", "(", ")", "<<", "\"End\"", ";", "dbgs", "(", ")", "<<", "\" RegionInstrs: \"", "<<", "NumRegionInstrs", "<<", "'\\n'", ")", ";", "schedule", "(", ")", ";", "exitRegion", "(", ")", ";", "++", "RegionIdx", ";", "}", "finishBlock", "(", ")", ";", "}", "while", "(", "Stage", "<", "2", ")", ";", "}", "</s>" ]

[ "After", "the", "schedule", "has", "been", "formed", ",", "call", "this", "function", "to", "combine", "the", "instructions", "from", "the", "different", "stages/cycles", "." ]

[ "AMDGPU", "\"All regions recorded, starting actual scheduling.\\n\"", "0", "1", "\"Retrying function scheduling with lowest recorded occupancy \"", "\".\\n\"", "1", "\"********** MI Scheduling **********\\n\"", "\":\"", "\" \"", "\"\\n From: \"", "\" To: \"", "\"End\"", "\" RegionInstrs: \"", "2" ]

[]

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

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

[ "MOS", "MOS" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "_RM", ",", "MipsTargetMachine", "*", "_TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "RM", "(", "_RM", ")", ",", "OverrideMode", "(", "NoOverride", ")", ",", "TM", "(", "_TM", ")", ",", "TargetTriple", "(", "TT", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "if", "(", "inMips16Mode", "(", ")", ")", "HasBitCount", "=", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips32\"", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"linux\"", "Mips" ]

[]

[ "<s>", "void", "s390_expand_vcond", "(", "rtx", "target", ",", "rtx", "then", ",", "rtx", "els", ",", "enum", "rtx_code", "cond", ",", "rtx", "cmp_op1", ",", "rtx", "cmp_op2", ")", "{", "rtx", "tmp", ";", "machine_mode", "result_mode", ";", "rtx", "result_target", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "cmp_mode", "=", "GET_MODE", "(", "cmp_op1", ")", ";", "rtx", "op", "=", "(", "cond", "==", "LT", ")", "?", "els", ":", "then", ";", "if", "(", "(", "cond", "==", "LT", "||", "cond", "==", "GE", ")", "&&", "target_mode", "==", "cmp_mode", "&&", "cmp_op2", "==", "CONST0_RTX", "(", "cmp_mode", ")", "&&", "op", "==", "CONST0_RTX", "(", "target_mode", ")", "&&", "s390_vector_mode_supported_p", "(", "target_mode", ")", "&&", "GET_MODE_CLASS", "(", "target_mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "rtx", "negop", "=", "(", "cond", "==", "LT", ")", "?", "then", ":", "els", ";", "int", "shift", "=", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "target_mode", ")", ")", "-", "1", ";", "if", "(", "negop", "==", "CONST1_RTX", "(", "target_mode", ")", ")", "{", "rtx", "res", "=", "expand_simple_binop", "(", "cmp_mode", ",", "LSHIFTRT", ",", "cmp_op1", ",", "GEN_INT", "(", "shift", ")", ",", "target", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "res", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "return", ";", "}", "else", "if", "(", "all_ones_operand", "(", "negop", ",", "target_mode", ")", ")", "{", "rtx", "res", "=", "expand_simple_binop", "(", "cmp_mode", ",", "ASHIFTRT", ",", "cmp_op1", ",", "GEN_INT", "(", "shift", ")", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "res", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "return", ";", "}", "}", "result_mode", "=", "mode_for_vector", "(", "int_mode_for_mode", "(", "GET_MODE_INNER", "(", "cmp_mode", ")", ")", ",", "GET_MODE_NUNITS", "(", "cmp_mode", ")", ")", ";", "result_target", "=", "gen_reg_rtx", "(", "result_mode", ")", ";", "if", "(", "!", "REG_P", "(", "cmp_op1", ")", ")", "cmp_op1", "=", "force_reg", "(", "GET_MODE", "(", "cmp_op1", ")", ",", "cmp_op1", ")", ";", "if", "(", "!", "REG_P", "(", "cmp_op2", ")", ")", "cmp_op2", "=", "force_reg", "(", "GET_MODE", "(", "cmp_op2", ")", ",", "cmp_op2", ")", ";", "s390_expand_vec_compare", "(", "result_target", ",", "cond", ",", "cmp_op1", ",", "cmp_op2", ")", ";", "if", "(", "all_ones_operand", "(", "then", ",", "GET_MODE", "(", "then", ")", ")", "&&", "const0_operand", "(", "els", ",", "GET_MODE", "(", "els", ")", ")", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_SUBREG", "(", "target_mode", ",", "result_target", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "!", "REG_P", "(", "then", ")", ")", "then", "=", "force_reg", "(", "target_mode", ",", "then", ")", ";", "if", "(", "!", "REG_P", "(", "els", ")", ")", "els", "=", "force_reg", "(", "target_mode", ",", "els", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "EQ", ",", "VOIDmode", ",", "result_target", ",", "CONST0_RTX", "(", "result_mode", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "target_mode", ",", "tmp", ",", "els", ",", "then", ")", ";", "gcc_assert", "(", "target_mode", "==", "GET_MODE", "(", "then", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "vector", "comparison", "expression", "loading", "either", "elements", "of", "THEN", "or", "ELS", "into", "TARGET", "depending", "on", "the", "comparison", "COND", "of", "CMP_OP1", "and", "CMP_OP2", "." ]

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

[]

[ "<s>", "static", "bool", "quad_aligned_store_p", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx_insn", "*", "insn", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid", "]", ".", "is_swap", "||", "!", "insn_entry", "[", "uid", "]", ".", "is_store", ")", "return", "false", ";", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "dest_address", "=", "XEXP", "(", "SET_DEST", "(", "body", ")", ",", "0", ")", ";", "rtx", "swap_reg", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "dest_address", ")", "&&", "!", "rs6000_sum_of_two_registers_p", "(", "dest_address", ")", ")", "return", "false", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "use", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "use", ")", ",", "swap_reg", ")", ")", "continue", ";", "if", "(", "!", "def_link", "||", "!", "def_link", "->", "ref", "||", "DF_REF_IS_ARTIFICIAL", "(", "def_link", "->", "ref", ")", "||", "def_link", "->", "next", ")", "return", "false", ";", "rtx", "def_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "unsigned", "uid2", "=", "INSN_UID", "(", "def_insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid2", "]", ".", "is_swap", "||", "insn_entry", "[", "uid2", "]", ".", "is_load", "||", "insn_entry", "[", "uid2", "]", ".", "is_store", ")", "return", "false", ";", "break", ";", "}", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "MEM_P", "(", "dest", ")", ")", "return", "(", "MEM_ALIGN", "(", "dest", ")", ">=", "128", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "INSN", "represents", "a", "store-with-swap", "of", "a", "swapped", "value", "and", "the", "memory", "address", "is", "quad-word", "aligned", "." ]

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

[]

[ "<s>", "static", "rtx", "frame_subreg_note", "(", "rtx", "set", ",", "int", "offset", ")", "{", "rtx", "src", "=", "simplify_gen_subreg", "(", "SImode", ",", "SET_SRC", "(", "set", ")", ",", "DImode", ",", "offset", ")", ";", "rtx", "dst", "=", "simplify_gen_subreg", "(", "SImode", ",", "SET_DEST", "(", "set", ")", ",", "DImode", ",", "offset", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "src", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "For", "a", "DImode", "load", "/", "store", "SET", ",", "make", "a", "SImode", "set", "for", "a", "REG_FRAME_RELATED_EXPR", "note", ",", "using", "OFFSET", "to", "create", "a", "high", "or", "lowpart", "subreg", "." ]

[ "epiphany", "1" ]

[]

[ "<s>", "static", "rtx_insn", "*", "frame_emit_load", "(", "int", "regno", ",", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SImode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "V4SImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "return", "emit_insn", "(", "gen_movv4si", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "load", "in", "the", "stack", "frame", "to", "load", "REGNO", "from", "address", "ADDR", ".", "Add", "a", "REG_CFA_RESTORE", "note", "to", "CFA_RESTORES", "if", "CFA_RESTORES", "is", "non-null", ".", "Return", "the", "emitted", "insn", "." ]

[ "spu" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_cmp", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "cmp_ops_mode", "=", "GET_MODE", "(", "cmp_op0", ")", ";", "machine_mode", "cmp_mode", ";", "bool", "maskcmp", "=", "false", ";", "rtx", "x", ";", "if", "(", "GET_MODE_SIZE", "(", "cmp_ops_mode", ")", "==", "64", ")", "{", "cmp_mode", "=", "mode_for_size", "(", "GET_MODE_NUNITS", "(", "cmp_ops_mode", ")", ",", "MODE_INT", ",", "0", ")", ";", "gcc_assert", "(", "cmp_mode", "!=", "BLKmode", ")", ";", "maskcmp", "=", "true", ";", "}", "else", "cmp_mode", "=", "cmp_ops_mode", ";", "cmp_op0", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op0", ")", ";", "if", "(", "!", "nonimmediate_operand", "(", "cmp_op1", ",", "cmp_ops_mode", ")", ")", "cmp_op1", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op1", ")", ";", "if", "(", "optimize", "||", "reg_overlap_mentioned_p", "(", "dest", ",", "op_true", ")", "||", "reg_overlap_mentioned_p", "(", "dest", ",", "op_false", ")", ")", "dest", "=", "gen_reg_rtx", "(", "maskcmp", "?", "cmp_mode", ":", "mode", ")", ";", "if", "(", "maskcmp", "&&", "(", "code", "==", "GT", "||", "code", "==", "EQ", ")", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "cmp_ops_mode", ")", "{", "case", "V64QImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv64qi3", ":", "gen_avx512bw_eqv64qi3_1", ";", "break", ";", "case", "V32HImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv32hi3", ":", "gen_avx512bw_eqv32hi3_1", ";", "break", ";", "case", "V16SImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv16si3", ":", "gen_avx512f_eqv16si3_1", ";", "break", ";", "case", "V8DImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv8di3", ":", "gen_avx512f_eqv8di3_1", ";", "break", ";", "default", ":", "gen", "=", "NULL", ";", "}", "if", "(", "gen", ")", "{", "emit_insn", "(", "gen", "(", "dest", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "return", "dest", ";", "}", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "cmp_mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "cmp_mode", "!=", "mode", "&&", "!", "maskcmp", ")", "{", "x", "=", "force_reg", "(", "cmp_ops_mode", ",", "x", ")", ";", "convert_move", "(", "dest", ",", "x", ",", "false", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "x", ")", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Expand", "an", "sse", "vector", "comparison", ".", "Return", "the", "register", "with", "the", "result", "." ]

[ "i386", "64", "0" ]

[]

[ "<s>", "static", "cpp_hashnode", "*", "s390_macro_to_expand", "(", "cpp_reader", "*", "pfile", ",", "const", "cpp_token", "*", "tok", ")", "{", "cpp_hashnode", "*", "expand_this", "=", "tok", "->", "val", ".", "node", ".", "node", ";", "cpp_hashnode", "*", "ident", ";", "static", "bool", "expand_bool_p", "=", "false", ";", "int", "idx", "=", "0", ";", "enum", "rid", "rid_code", ";", "if", "(", "!", "TARGET_ZVECTOR", ")", "return", "NULL", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "!=", "expand_this", ")", "expand_this", "=", "NULL", ";", "if", "(", "expand_bool_p", "&&", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "{", "expand_bool_p", "=", "false", ";", "return", "ident", ";", "}", "if", "(", "ident", "!=", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ")", "return", "expand_this", ";", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "!", "ident", ")", "return", "expand_this", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "{", "expand_bool_p", "=", "true", ";", "return", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "}", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ")", "return", "expand_this", ";", "rid_code", "=", "(", "enum", "rid", ")", "(", "ident", "->", "rid_code", ")", ";", "if", "(", "cpp_macro_p", "(", "ident", ")", ")", "{", "do", "(", "void", ")", "cpp_get_token", "(", "pfile", ")", ";", "while", "(", "--", "idx", ">", "0", ")", ";", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "{", "expand_bool_p", "=", "true", ";", "return", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "}", "else", "if", "(", "ident", ")", "rid_code", "=", "(", "enum", "rid", ")", "(", "ident", "->", "rid_code", ")", ";", "}", "if", "(", "rid_code", "==", "RID_UNSIGNED", "||", "rid_code", "==", "RID_LONG", "||", "rid_code", "==", "RID_SHORT", "||", "rid_code", "==", "RID_SIGNED", "||", "rid_code", "==", "RID_INT", "||", "rid_code", "==", "RID_CHAR", "||", "(", "rid_code", "==", "RID_FLOAT", "&&", "TARGET_VXE", ")", "||", "rid_code", "==", "RID_DOUBLE", ")", "{", "expand_this", "=", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "expand_bool_p", "=", "true", ";", "else", "{", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "expand_bool_p", "=", "true", ";", "}", "}", "return", "expand_this", ";", "}", "</s>" ]

[ "Called", "to", "decide", "whether", "a", "conditional", "macro", "should", "be", "expanded", ".", "Since", "we", "have", "exactly", "one", "such", "macro", "(", "i.e", ",", "'vector", "'", ")", ",", "we", "do", "not", "need", "to", "examine", "the", "'tok", "'", "parameter", "." ]

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

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "begin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "end", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "LdrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPXi", ":", "AArch64", "::", "LDRXui", ";", "else", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPDi", ":", "AArch64", "::", "LDRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR restore: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "MIB", ".", "addReg", "(", "Reg2", ",", "getDefRegState", "(", "true", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "AArch64::LDPXi", "AArch64::LDRXui", "AArch64::LDPDi", "AArch64::LDRDui", "\"CSR restore: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "void", "alpha_split_tfmode_frobsign", "(", "rtx", "operands", "[", "3", "]", ",", "rtx", "(", "*", "operation", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "rtx", "high_bit", "=", "operands", "[", "2", "]", ";", "rtx", "scratch", ";", "int", "move", ";", "alpha_split_tmode_pair", "(", "operands", ",", "TFmode", ",", "false", ")", ";", "move", "=", "1", ";", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ")", "move", "=", "0", ";", "else", "if", "(", "rtx_equal_p", "(", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "high_bit", ")", ")", "move", "=", "2", ";", "else", "move", "=", "-", "1", ";", "}", "if", "(", "move", "<", "0", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "scratch", "=", "operands", "[", "move", "<", "2", "?", "1", ":", "3", "]", ";", "emit_insn", "(", "(", "*", "operation", ")", "(", "scratch", ",", "high_bit", ",", "operands", "[", "3", "]", ")", ")", ";", "if", "(", "move", ">", "0", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "if", "(", "move", ">", "1", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "scratch", ")", ";", "}", "}", "</s>" ]

[ "Implement", "negtf2", "or", "abstf2", ".", "Op0", "is", "destination", ",", "op1", "is", "source", ",", "op2", "is", "a", "register", "containing", "the", "sign", "bit", ",", "operation", "is", "the", "logical", "operation", "to", "be", "performed", "." ]

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

[]