Datasets:

---

docz1105

/

ComBack

like 10

[ "<s>", "const", "MipsSubtarget", "*", "MipsTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "hasMips16Attr", "=", "!", "F", ".", "getFnAttribute", "(", "\"mips16\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "bool", "hasNoMips16Attr", "=", "!", "F", ".", "getFnAttribute", "(", "\"nomips16\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "bool", "HasMicroMipsAttr", "=", "!", "F", ".", "getFnAttribute", "(", "\"micromips\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "bool", "HasNoMicroMipsAttr", "=", "!", "F", ".", "getFnAttribute", "(", "\"nomicromips\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "bool", "softFloat", "=", "F", ".", "hasFnAttribute", "(", "\"use-soft-float\"", ")", "&&", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "hasMips16Attr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+mips16\"", ":", "\",+mips16\"", ";", "else", "if", "(", "hasNoMips16Attr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"-mips16\"", ":", "\",-mips16\"", ";", "if", "(", "HasMicroMipsAttr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+micromips\"", ":", "\",+micromips\"", ";", "else", "if", "(", "HasNoMicroMipsAttr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"-micromips\"", ":", "\",-micromips\"", ";", "if", "(", "softFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "MipsSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "isLittle", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"target-cpu\"", "\"target-features\"", "Mips", "\"mips16\"", "Mips", "\"nomips16\"", "Mips", "\"micromips\"", "Mips", "\"nomicromips\"", "\"use-soft-float\"", "\"use-soft-float\"", "\"true\"", "Mips", "\"+mips16\"", "\",+mips16\"", "Mips", "\"-mips16\"", "\",-mips16\"", "Mips", "\"+micromips\"", "\",+micromips\"", "Mips", "\"-micromips\"", "\",-micromips\"", "\"+soft-float\"", "\",+soft-float\"", "Mips" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "SW", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSW", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::SW", "RISCV::FPR32RegClass", "RISCV::FSW", "\"Can't store this register to stack slot\"", "0" ]

[]

[ "<s>", "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "std", "::", "string", "Key", "=", "CPU", "+", "FS", ";", "if", "(", "F", ".", "optForMinSize", "(", ")", ")", "Key", "+=", "\"+minsize\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "F", ".", "optForMinSize", "(", ")", ")", ";", "if", "(", "!", "I", "->", "isThumb", "(", ")", "&&", "!", "I", "->", "hasARMOps", "(", ")", ")", "F", ".", "getContext", "(", ")", ".", "emitError", "(", "\"Function '\"", "+", "F", ".", "getName", "(", ")", "+", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "\"+minsize\"", "ARM", "ARM", "\"Function '\"", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"" ]

[]

[ "<s>", "static", "int", "nds32_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "from", "==", "HIGH_REGS", "||", "to", "==", "HIGH_REGS", ")", "return", "6", ";", "return", "2", ";", "}", "</s>" ]

[ "Describing", "Relative", "Costs", "of", "Operations", "." ]

[ "nds32", "6", "2" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "Fast", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "!", "IsMemset", "&&", "Size", ">=", "16", "&&", "!", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoImplicitFloat", ")", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "||", "(", "allowsUnalignedMemoryAccesses", "(", "MVT", "::", "f128", ",", "0", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "return", "MVT", "::", "f128", ";", "return", "Size", ">=", "8", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "16", "16", "MVT::f128", "0", "MVT::f128", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "static", "rtx", "arc_builtin_setjmp_frame_value", "(", "void", ")", "{", "return", "gen_raw_REG", "(", "Pmode", ",", "FRAME_POINTER_REGNUM", ")", ";", "}", "</s>" ]

[ "Return", "the", "frame", "pointer", "value", "to", "be", "backed", "up", "in", "the", "setjmp", "buffer", "." ]

[ "arc" ]

[]

[ "<s>", "static", "enum", "mips_split_type", "mips_insn_split_type", "(", "rtx", "insn", ")", "{", "basic_block", "bb", "=", "BLOCK_FOR_INSN", "(", "insn", ")", ";", "if", "(", "bb", ")", "{", "if", "(", "optimize_bb_for_speed_p", "(", "bb", ")", ")", "return", "SPLIT_FOR_SPEED", ";", "else", "return", "SPLIT_FOR_SIZE", ";", "}", "return", "SPLIT_IF_NECESSARY", ";", "}", "</s>" ]

[ "Return", "the", "split", "type", "for", "instruction", "INSN", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "supported_simd_type", "(", "tree", "t", ")", "{", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "t", ")", "||", "INTEGRAL_TYPE_P", "(", "t", ")", "||", "POINTER_TYPE_P", "(", "t", ")", ")", "{", "HOST_WIDE_INT", "s", "=", "tree_to_shwi", "(", "TYPE_SIZE_UNIT", "(", "t", ")", ")", ";", "return", "s", "==", "1", "||", "s", "==", "2", "||", "s", "==", "4", "||", "s", "==", "8", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "for", "types", "that", "could", "be", "supported", "as", "SIMD", "return", "or", "argument", "types", "." ]

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

[]

[ "<s>", "static", "void", "replace_swapped_aligned_load", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "swap_insn", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "swap_insn", ")", ";", "gcc_assert", "(", "insn_entry", "[", "uid", "]", ".", "is_swap", "&&", "!", "insn_entry", "[", "uid", "]", ".", "is_load", ")", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "swap_insn", ")", ";", "df_ref", "use", "=", "DF_INSN_INFO_USES", "(", "insn_info", ")", ";", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "gcc_assert", "(", "def_link", "&&", "!", "def_link", "->", "next", ")", ";", "gcc_assert", "(", "def_link", "&&", "def_link", "->", "ref", "&&", "!", "DF_REF_IS_ARTIFICIAL", "(", "def_link", "->", "ref", ")", "&&", "!", "def_link", "->", "next", ")", ";", "rtx_insn", "*", "def_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "unsigned", "uid2", "=", "INSN_UID", "(", "def_insn", ")", ";", "gcc_assert", "(", "insn_entry", "[", "uid2", "]", ".", "is_load", "&&", "insn_entry", "[", "uid2", "]", ".", "is_swap", ")", ";", "rtx", "body", "=", "PATTERN", "(", "def_insn", ")", ";", "gcc_assert", "(", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "&&", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "==", "MEM", ")", ")", ";", "rtx", "src_exp", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "src_exp", ")", ";", "rtx", "lvx", "=", "rs6000_gen_lvx", "(", "mode", ",", "SET_DEST", "(", "body", ")", ",", "src_exp", ")", ";", "rtx_insn", "*", "new_insn", "=", "emit_insn_before", "(", "lvx", ",", "def_insn", ")", ";", "rtx", "new_body", "=", "PATTERN", "(", "new_insn", ")", ";", "gcc_assert", "(", "(", "GET_CODE", "(", "new_body", ")", "==", "SET", ")", "&&", "(", "GET_CODE", "(", "SET_SRC", "(", "new_body", ")", ")", "==", "MEM", ")", ")", ";", "set_block_for_insn", "(", "new_insn", ",", "BLOCK_FOR_INSN", "(", "def_insn", ")", ")", ";", "df_insn_rescan", "(", "new_insn", ")", ";", "df_insn_delete", "(", "def_insn", ")", ";", "remove_insn", "(", "def_insn", ")", ";", "def_insn", "->", "set_deleted", "(", ")", ";", "mark_swaps_for_removal", "(", "insn_entry", ",", "uid", ")", ";", "replace_swap_with_copy", "(", "insn_entry", ",", "uid", ")", ";", "}", "</s>" ]

[ "Given", "that", "SWAP_INSN", "represents", "a", "swap", "of", "an", "aligned", "load-with-swap", ",", "replace", "the", "load", "with", "an", "aligned", "load", "(", "without", "swap", ")", "and", "replace", "the", "swap", "with", "a", "copy", "insn", "." ]

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

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedScatter", "(", "Type", "*", "DataType", ")", "{", "if", "(", "!", "ST", "->", "hasAVX512", "(", ")", ")", "return", "false", ";", "return", "isLegalMaskedGather", "(", "DataType", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "MipsFrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "bool", "isPIC", "=", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", ";", "adjustMipsStackFrame", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "int", "FPOffset", "=", "MipsFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MipsFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOREORDER", ")", ")", ";", "if", "(", "isPIC", "&&", "STI", ".", "isABI_O32", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPLOAD", ")", ")", ".", "addReg", "(", "RegInfo", "->", "getPICCallReg", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOMACRO", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "RA", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "needGPSaveRestore", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPRESTORE", ")", ")", ".", "addImm", "(", "MipsFI", "->", "getGPStackOffset", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "Mips", "Mips", "Mips::NOREORDER", "Mips::CPLOAD", "Mips::NOMACRO", "Mips::ADDiu", "Mips::SP", "Mips::SP", "Mips::SW", "Mips::RA", "Mips::SP", "Mips::SW", "Mips::FP", "Mips::SP", "Mips::ADDu", "Mips::FP", "Mips::SP", "Mips::ZERO", "Mips", "Mips::CPRESTORE", "Mips" ]

[]

[ "<s>", "static", "bool", "rs6000_secondary_reload_simple_move", "(", "enum", "rs6000_reg_type", "to_type", ",", "enum", "rs6000_reg_type", "from_type", ",", "machine_mode", "mode", ")", "{", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_DIRECT_MOVE", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "||", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "{", "if", "(", "TARGET_POWERPC64", ")", "{", "if", "(", "size", "==", "8", ")", "return", "true", ";", "if", "(", "size", "==", "16", "&&", "TARGET_P9_VECTOR", "&&", "mode", "!=", "TDmode", ")", "return", "true", ";", "}", "if", "(", "TARGET_P8_VECTOR", ")", "{", "if", "(", "mode", "==", "SImode", ")", "return", "true", ";", "if", "(", "TARGET_P9_VECTOR", "&&", "(", "mode", "==", "HImode", "||", "mode", "==", "QImode", ")", ")", "return", "true", ";", "}", "if", "(", "mode", "==", "SDmode", ")", "return", "true", ";", "}", "else", "if", "(", "(", "size", "==", "4", "||", "(", "TARGET_POWERPC64", "&&", "size", "==", "8", ")", ")", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "SPR_REG_TYPE", ")", "||", "(", "to_type", "==", "SPR_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rs6000_secondary_reload", "to", "return", "true", "if", "a", "move", "to", "a", "different", "register", "classe", "is", "really", "a", "simple", "move", "." ]

[ "rs6000", "8", "16", "4", "8" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CALL", ":", "return", "LowerCALL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FORMAL_ARGUMENTS", ":", "return", "LowerFORMAL_ARGUMENTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RET", ":", "return", "LowerRET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::AND", "ISD::BRCOND", "ISD::CALL", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::FORMAL_ARGUMENTS", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::OR", "ISD::RET", "ISD::SELECT", "ISD::SETCC" ]

[]

[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "AT", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "SP", "}", ";", "static", "const", "uint16_t", "ReservedCPU64Regs", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "AT_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "SP_64", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "const_iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPU64Regs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPU64Regs", "[", "I", "]", ")", ";", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "AFGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "AFGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "else", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "CPU64RegsRegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "CPU64RegsRegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "FGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "FGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "FP_64", ")", ";", "}", "Reserved", ".", "set", "(", "Mips", "::", "HWR29", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "HWR29_64", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "RA", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "RA_64", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "Mips", "Mips", "Mips::ZERO", "Mips::AT", "Mips::K0", "Mips::K1", "Mips::SP", "Mips::ZERO_64", "Mips::AT_64", "Mips::K0_64", "Mips::K1_64", "Mips::SP_64", "0", "Mips", "0", "Mips::AFGR64RegClass", "Mips::AFGR64RegClass", "Mips::CPU64RegsRegClass", "Mips::CPU64RegsRegClass", "Mips::FGR64RegClass", "Mips::FGR64RegClass", "Mips::FP", "Mips::FP_64", "Mips::HWR29", "Mips::HWR29_64", "Mips", "Mips::RA", "Mips::RA_64" ]

[]

[ "<s>", "static", "void", "xtensa_asm_trampoline_template", "(", "FILE", "*", "stream", ")", "{", "bool", "use_call0", "=", "(", "TARGET_CONST16", "||", "TARGET_ABSOLUTE_LITERALS", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.begin no-transform\\n\"", ")", ";", "if", "(", "TARGET_WINDOWED_ABI", ")", "{", "fprintf", "(", "stream", ",", "\"\\tentry\\tsp, %d\\n\"", ",", "MIN_FRAME_SIZE", ")", ";", "if", "(", "use_call0", ")", "{", "fprintf", "(", "stream", ",", "\"\\tmov\\ta10, a0\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tcall0\\t.Lskipconsts\\n\"", ")", ";", "}", "else", "fprintf", "(", "stream", ",", "\"\\tj\\t.Lskipconsts\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.align\\t4\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\".Lchainval:%s0\\n\"", ",", "integer_asm_op", "(", "4", ",", "TRUE", ")", ")", ";", "fprintf", "(", "stream", ",", "\".Lfnaddr:%s0\\n\"", ",", "integer_asm_op", "(", "4", ",", "TRUE", ")", ")", ";", "fprintf", "(", "stream", ",", "\".Lskipconsts:\\n\"", ")", ";", "if", "(", "use_call0", ")", "{", "fprintf", "(", "stream", ",", "\"\\taddi\\ta0, a0, 3\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tl32i\\ta9, a0, 0\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tl32i\\ta8, a0, 4\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "stream", ",", "\"\\tl32r\\ta9, .Lchainval\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tl32r\\ta8, .Lfnaddr\\n\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\ts32i\\ta9, sp, %d\\n\"", ",", "MIN_FRAME_SIZE", "-", "20", ")", ";", "fprintf", "(", "stream", ",", "\"\\tl32i\\ta9, a8, 0\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\textui\\ta9, a9, %d, 12\\n\"", ",", "TARGET_BIG_ENDIAN", "?", "8", ":", "12", ")", ";", "fprintf", "(", "stream", ",", "\"\\tslli\\ta9, a9, 3\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\taddi\\ta9, a9, %d\\n\"", ",", "-", "MIN_FRAME_SIZE", ")", ";", "fprintf", "(", "stream", ",", "\"\\tsub\\ta9, sp, a9\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tmovsp\\tsp, a9\\n\"", ")", ";", "if", "(", "use_call0", ")", "fprintf", "(", "stream", ",", "\"\\tmov\\ta0, a10\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\taddi\\ta8, a8, 3\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tjx\\ta8\\n\"", ")", ";", "if", "(", "use_call0", ")", "fprintf", "(", "stream", ",", "\"\\t.byte\\t0\\n\"", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\tnop\\n\"", ")", ";", "}", "else", "{", "if", "(", "use_call0", ")", "{", "fprintf", "(", "stream", ",", "\"\\tmov\\ta10, a0\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tcall0\\t.Lskipconsts\\n\"", ")", ";", "}", "else", "fprintf", "(", "stream", ",", "\"\\tj\\t.Lskipconsts\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.align\\t4\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\".Lchainval:%s0\\n\"", ",", "integer_asm_op", "(", "4", ",", "TRUE", ")", ")", ";", "fprintf", "(", "stream", ",", "\".Lfnaddr:%s0\\n\"", ",", "integer_asm_op", "(", "4", ",", "TRUE", ")", ")", ";", "fprintf", "(", "stream", ",", "\".Lskipconsts:\\n\"", ")", ";", "if", "(", "use_call0", ")", "{", "fprintf", "(", "stream", ",", "\"\\taddi\\ta0, a0, 3\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tl32i\\ta8, a0, 0\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tl32i\\ta9, a0, 4\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tmov\\ta0, a10\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "stream", ",", "\"\\tl32r\\ta8, .Lchainval\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"\\tl32r\\ta9, .Lfnaddr\\n\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\tjx\\ta9\\n\"", ")", ";", "if", "(", "use_call0", ")", "fprintf", "(", "stream", ",", "\"\\t.byte\\t0\\n\"", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\tnop\\n\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\t.end no-transform\\n\"", ")", ";", "}", "</s>" ]

[ "TRAMPOLINE_TEMPLATE", ":", "For", "Xtensa", ",", "the", "trampoline", "must", "perform", "an", "ENTRY", "instruction", "with", "a", "minimal", "stack", "frame", "in", "order", "to", "get", "some", "free", "registers", ".", "Once", "the", "actual", "call", "target", "is", "known", ",", "the", "proper", "stack", "frame", "size", "is", "extracted", "from", "the", "ENTRY", "instruction", "at", "the", "target", "and", "the", "current", "frame", "is", "adjusted", "to", "match", ".", "The", "trampoline", "then", "transfers", "control", "to", "the", "instruction", "following", "the", "ENTRY", "at", "the", "target", ".", "Note", ":", "this", "assumes", "that", "the", "target", "begins", "with", "an", "ENTRY", "instruction", "." ]

[ "xtensa", "\"\\t.begin no-transform\\n\"", "\"\\tentry\\tsp, %d\\n\"", "\"\\tmov\\ta10, a0\\n\"", "\"\\tcall0\\t.Lskipconsts\\n\"", "\"\\tj\\t.Lskipconsts\\n\"", "\"\\t.align\\t4\\n\"", "\".Lchainval:%s0\\n\"", "4", "\".Lfnaddr:%s0\\n\"", "4", "\".Lskipconsts:\\n\"", "\"\\taddi\\ta0, a0, 3\\n\"", "\"\\tl32i\\ta9, a0, 0\\n\"", "\"\\tl32i\\ta8, a0, 4\\n\"", "\"\\tl32r\\ta9, .Lchainval\\n\"", "\"\\tl32r\\ta8, .Lfnaddr\\n\"", "\"\\ts32i\\ta9, sp, %d\\n\"", "20", "\"\\tl32i\\ta9, a8, 0\\n\"", "\"\\textui\\ta9, a9, %d, 12\\n\"", "8", "12", "\"\\tslli\\ta9, a9, 3\\n\"", "\"\\taddi\\ta9, a9, %d\\n\"", "\"\\tsub\\ta9, sp, a9\\n\"", "\"\\tmovsp\\tsp, a9\\n\"", "\"\\tmov\\ta0, a10\\n\"", "\"\\taddi\\ta8, a8, 3\\n\"", "\"\\tjx\\ta8\\n\"", "\"\\t.byte\\t0\\n\"", "\"\\tnop\\n\"", "\"\\tmov\\ta10, a0\\n\"", "\"\\tcall0\\t.Lskipconsts\\n\"", "\"\\tj\\t.Lskipconsts\\n\"", "\"\\t.align\\t4\\n\"", "\".Lchainval:%s0\\n\"", "4", "\".Lfnaddr:%s0\\n\"", "4", "\".Lskipconsts:\\n\"", "\"\\taddi\\ta0, a0, 3\\n\"", "\"\\tl32i\\ta8, a0, 0\\n\"", "\"\\tl32i\\ta9, a0, 4\\n\"", "\"\\tmov\\ta0, a10\\n\"", "\"\\tl32r\\ta8, .Lchainval\\n\"", "\"\\tl32r\\ta9, .Lfnaddr\\n\"", "\"\\tjx\\ta9\\n\"", "\"\\t.byte\\t0\\n\"", "\"\\tnop\\n\"", "\"\\t.end no-transform\\n\"" ]

[]

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

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::SREM", "ISD::UREM", "ISD::SDIVREM", "ISD::UDIVREM", "0", "2", "\"DivRem needs two values\"", "0", "1", "ISD::READCYCLECOUNTER", "ISD::UDIV", "ISD::SDIV", "\"can only expand DIV on Windows\"", "0", "ISD::SDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "void", "Z80TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ReplaceNodeResults: \"", ";", "N", "->", "dump", "(", "&", "DAG", ")", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"ReplaceNodeResults: \"" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreRegBankSelect", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "addPass", "(", "createAMDGPUPostLegalizeCombiner", "(", "IsOptNone", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "s390_hard_regno_call_part_clobbered", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "TARGET_ZARCH", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "(", "(", "regno", ">=", "6", "&&", "regno", "<=", "15", ")", "||", "regno", "==", "32", ")", ")", "return", "true", ";", "if", "(", "TARGET_VX", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "8", "&&", "(", "(", "(", "TARGET_64BIT", "&&", "regno", ">=", "24", "&&", "regno", "<=", "31", ")", ")", "||", "(", "!", "TARGET_64BIT", "&&", "(", "regno", "==", "18", "||", "regno", "==", "19", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_CALL_PART_CLOBBERED", ".", "When", "generating", "code", "that", "runs", "in", "z/Architecture", "mode", ",", "but", "conforms", "to", "the", "31-bit", "ABI", ",", "GPRs", "can", "hold", "8", "bytes", ";", "the", "ABI", "guarantees", "only", "that", "the", "lower", "4", "bytes", "are", "saved", "across", "calls", ",", "however", "." ]

[ "s390", "4", "6", "15", "32", "8", "24", "31", "18", "19" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "Lanai" ]

[]

[ "<s>", "static", "void", "s390_chunkify_cancel", "(", "struct", "constant_pool", "*", "pool_list", ")", "{", "struct", "constant_pool", "*", "curr_pool", "=", "NULL", ";", "rtx_insn", "*", "insn", ";", "for", "(", "curr_pool", "=", "pool_list", ";", "curr_pool", ";", "curr_pool", "=", "curr_pool", "->", "next", ")", "{", "rtx_insn", "*", "barrier", "=", "PREV_INSN", "(", "curr_pool", "->", "pool_insn", ")", ";", "rtx_insn", "*", "jump", "=", "barrier", "?", "PREV_INSN", "(", "barrier", ")", ":", "NULL", ";", "rtx_insn", "*", "label", "=", "NEXT_INSN", "(", "curr_pool", "->", "pool_insn", ")", ";", "if", "(", "jump", "&&", "JUMP_P", "(", "jump", ")", "&&", "barrier", "&&", "BARRIER_P", "(", "barrier", ")", "&&", "label", "&&", "LABEL_P", "(", "label", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "jump", ")", ")", "==", "SET", "&&", "SET_DEST", "(", "PATTERN", "(", "jump", ")", ")", "==", "pc_rtx", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "jump", ")", ")", ")", "==", "LABEL_REF", "&&", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "jump", ")", ")", ",", "0", ")", "==", "label", ")", "{", "remove_insn", "(", "jump", ")", ";", "remove_insn", "(", "barrier", ")", ";", "remove_insn", "(", "label", ")", ";", "}", "remove_insn", "(", "curr_pool", "->", "pool_insn", ")", ";", "}", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", ")", "{", "rtx_insn", "*", "next_insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "1", ")", "==", "UNSPEC_RELOAD_BASE", ")", "remove_insn", "(", "insn", ")", ";", "insn", "=", "next_insn", ";", "}", "while", "(", "pool_list", ")", "{", "struct", "constant_pool", "*", "next", "=", "pool_list", "->", "next", ";", "s390_free_pool", "(", "pool_list", ")", ";", "pool_list", "=", "next", ";", "}", "}", "</s>" ]

[ "POOL_LIST", "is", "a", "chunk", "list", "as", "prepared", "by", "s390_chunkify_start", ".", "We", "have", "decided", "we", "can", "not", "use", "this", "list", ",", "so", "revert", "all", "changes", "to", "the", "current", "function", "that", "were", "done", "by", "s390_chunkify_start", "." ]

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

[]

[ "<s>", "bool", "isThumb", "(", ")", "const", "{", "return", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "ModeThumb", "]", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "is", "Thumb", "(", "little", "and", "big", "endian", ")", "." ]

[ "ARM", "ARM::ModeThumb" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "fnmask", ";", "if", "(", "code", ">=", "RS6000_BUILTIN_COUNT", ")", "return", "error_mark_node", ";", "fnmask", "=", "rs6000_builtin_info", "[", "code", "]", ".", "mask", ";", "if", "(", "(", "fnmask", "&", "rs6000_builtin_mask", ")", "!=", "fnmask", ")", "{", "rs6000_invalid_builtin", "(", "(", "enum", "rs6000_builtins", ")", "code", ")", ";", "return", "error_mark_node", ";", "}", "return", "rs6000_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Returns", "the", "rs6000", "builtin", "decl", "for", "CODE", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "fix_range", "(", "const", "char", "*", "const_str", ")", "{", "int", "i", ",", "first", ",", "last", ";", "char", "*", "str", ",", "*", "dash", ",", "*", "comma", ";", "i", "=", "strlen", "(", "const_str", ")", ";", "str", "=", "(", "char", "*", ")", "alloca", "(", "i", "+", "1", ")", ";", "memcpy", "(", "str", ",", "const_str", ",", "i", "+", "1", ")", ";", "while", "(", "1", ")", "{", "dash", "=", "strchr", "(", "str", ",", "'-'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "0", ",", "\"value of %<-mfixed-range%> must have form REG1-REG2\"", ")", ";", "return", ";", "}", "*", "dash", "=", "'\\0'", ";", "comma", "=", "strchr", "(", "dash", "+", "1", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "str", ")", ";", "return", ";", "}", "last", "=", "decode_reg_name", "(", "dash", "+", "1", ")", ";", "if", "(", "last", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "*", "dash", "=", "'-'", ";", "if", "(", "first", ">", "last", ")", "{", "warning", "(", "0", ",", "\"%s-%s is an empty range\"", ",", "str", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "for", "(", "i", "=", "first", ";", "i", "<=", "last", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "!", "comma", ")", "break", ";", "*", "comma", "=", "','", ";", "str", "=", "comma", "+", "1", ";", "}", "}", "</s>" ]

[ "Parse", "the", "-mfixed-range=", "option", "string", "." ]

[ "ia64", "1", "1", "1", "0", "\"value of %<-mfixed-range%> must have form REG1-REG2\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "\"%s-%s is an empty range\"", "1", "1", "1" ]

[]

[ "<s>", "static", "const", "char", "*", "get_round_mode_suffix", "(", "void", ")", "{", "enum", "attr_round_suffix", "s", "=", "get_attr_round_suffix", "(", "current_output_insn", ")", ";", "switch", "(", "s", ")", "{", "case", "ROUND_SUFFIX_NONE", ":", "return", "NULL", ";", "case", "ROUND_SUFFIX_NORMAL", ":", "switch", "(", "alpha_fprm", ")", "{", "case", "ALPHA_FPRM_NORM", ":", "return", "NULL", ";", "case", "ALPHA_FPRM_MINF", ":", "return", "\"m\"", ";", "case", "ALPHA_FPRM_CHOP", ":", "return", "\"c\"", ";", "case", "ALPHA_FPRM_DYN", ":", "return", "\"d\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "ROUND_SUFFIX_C", ":", "return", "\"c\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "rounding", "mode", "suffix", "applicable", "to", "the", "current", "instruction", ",", "or", "NULL", "." ]

[ "alpha", "\"m\"", "\"c\"", "\"d\"", "\"c\"" ]

[]

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

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

[ "F2003f", "F2003f" ]

[]

[ "<s>", "bool", "WebAssemblyRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", ".", "initWARegs", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "if", "(", "!", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "break", ";", "int64_t", "Imm", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg VReg \"", "<<", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "<<", "\" -> WAReg \"", "<<", "Imm", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "Imm", ")", ";", "}", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "NumStackRegs", "=", "0", ";", "unsigned", "CurReg", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "for", "(", "unsigned", "VRegIdx", "=", "0", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "unsigned", "VReg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "VReg", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "(", "INT32_MIN", "|", "NumStackRegs", ")", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "INT32_MIN", "|", "NumStackRegs", "++", ")", ";", "continue", ";", "}", "if", "(", "MFI", ".", "getWAReg", "(", "VReg", ")", "==", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "CurReg", "++", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly::isArgument", "1", "\"Arg VReg \"", "0", "\" -> WAReg \"", "\"\\n\"", "0", "0", "0", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"", "WebAssembly", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"" ]

[]

[ "<s>", "static", "bool", "s390_return_in_memory", "(", "tree", "type", ",", "tree", "fundecl", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "OFFSET_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", ")", "return", "int_size_in_bytes", "(", "type", ")", ">", "8", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "return", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "return", "values", "of", "type", "TYPE", "should", "be", "returned", "in", "a", "memory", "buffer", "whose", "address", "is", "passed", "by", "the", "caller", "as", "hidden", "first", "argument", "." ]

[ "s390", "8" ]

[]

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

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitStoreConditional", "(", "IRBuilderBase", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "isReleaseOrStronger", "(", "Ord", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "aarch64_stlxp", ":", "Intrinsic", "::", "aarch64_stxp", ";", "Function", "*", "Stxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int64Ty", "=", "Type", "::", "getInt64Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int64Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "64", ")", ",", "Int64Ty", ",", "\"hi\"", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Stxr", ",", "{", "Lo", ",", "Hi", ",", "Addr", "}", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "aarch64_stlxr", ":", "Intrinsic", "::", "aarch64_stxr", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Stxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "const", "DataLayout", "&", "DL", "=", "M", "->", "getDataLayout", "(", ")", ";", "IntegerType", "*", "IntValTy", "=", "Builder", ".", "getIntNTy", "(", "DL", ".", "getTypeSizeInBits", "(", "Val", "->", "getType", "(", ")", ")", ")", ";", "Val", "=", "Builder", ".", "CreateBitCast", "(", "Val", ",", "IntValTy", ")", ";", "CallInst", "*", "CI", "=", "Builder", ".", "CreateCall", "(", "Stxr", ",", "{", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Stxr", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", "}", ")", ";", "CI", "->", "addParamAttr", "(", "1", ",", "Attribute", "::", "get", "(", "Builder", ".", "getContext", "(", ")", ",", "Attribute", "::", "ElementType", ",", "Val", "->", "getType", "(", ")", ")", ")", ";", "return", "CI", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_stlxp", "Intrinsic::aarch64_stxp", "Intrinsic::getDeclaration", "\"lo\"", "64", "\"hi\"", "Intrinsic::ID", "Intrinsic::aarch64_stlxr", "Intrinsic::aarch64_stxr", "Intrinsic::getDeclaration", "0", "1" ]

[]

[ "<s>", "SDValue", "SHUXITargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "IsVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SHUXI", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "SHUXIISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "ISD::OutputArg", "\"VarArg not supported\"", "16", "SHUXI", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "SHUXIISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "rtx", "aarch64_expand_fcmla_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "int", "fcode", ")", "{", "int", "bcode", "=", "fcode", "-", "AARCH64_SIMD_FCMLA_LANEQ_BUILTIN_BASE", "-", "1", ";", "aarch64_fcmla_laneq_builtin_datum", "*", "d", "=", "&", "aarch64_fcmla_lane_builtin_data", "[", "bcode", "]", ";", "machine_mode", "quadmode", "=", "GET_MODE_2XWIDER_MODE", "(", "d", "->", "mode", ")", ".", "require", "(", ")", ";", "rtx", "op0", "=", "force_reg", "(", "d", "->", "mode", ",", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ")", ";", "rtx", "op1", "=", "force_reg", "(", "d", "->", "mode", ",", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ")", ";", "rtx", "op2", "=", "force_reg", "(", "quadmode", ",", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ")", ";", "tree", "tmp", "=", "CALL_EXPR_ARG", "(", "exp", ",", "3", ")", ";", "rtx", "lane_idx", "=", "expand_expr", "(", "tmp", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_INITIALIZER", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "lane_idx", ")", ")", "{", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"argument %d must be a constant immediate\"", ",", "4", ")", ";", "return", "const0_rtx", ";", "}", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "quadmode", ")", ".", "to_constant", "(", ")", ";", "aarch64_simd_lane_bounds", "(", "lane_idx", ",", "0", ",", "nunits", "/", "2", ",", "exp", ")", ";", "int", "lane", "=", "INTVAL", "(", "lane_idx", ")", ";", "if", "(", "lane", "<", "nunits", "/", "4", ")", "op2", "=", "simplify_gen_subreg", "(", "d", "->", "mode", ",", "op2", ",", "quadmode", ",", "subreg_lowpart_offset", "(", "d", "->", "mode", ",", "quadmode", ")", ")", ";", "else", "{", "rtx", "temp1", "=", "gen_reg_rtx", "(", "d", "->", "mode", ")", ";", "rtx", "temp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "temp1", "=", "simplify_gen_subreg", "(", "d", "->", "mode", ",", "op2", ",", "quadmode", ",", "subreg_lowpart_offset", "(", "d", "->", "mode", ",", "quadmode", ")", ")", ";", "temp1", "=", "simplify_gen_subreg", "(", "V2DImode", ",", "temp1", ",", "d", "->", "mode", ",", "0", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_aarch64_get_lanev2di", "(", "temp2", ",", "temp1", ",", "const0_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_aarch64_get_lanev2di", "(", "temp2", ",", "temp1", ",", "const1_rtx", ")", ")", ";", "op2", "=", "simplify_gen_subreg", "(", "d", "->", "mode", ",", "temp2", ",", "GET_MODE", "(", "temp2", ")", ",", "0", ")", ";", "lane", "-=", "nunits", "/", "4", ";", "}", "lane_idx", "=", "aarch64_endian_lane_rtx", "(", "V2DImode", ",", "lane", ")", ";", "if", "(", "!", "target", "||", "!", "REG_P", "(", "target", ")", "||", "GET_MODE", "(", "target", ")", "!=", "d", "->", "mode", ")", "target", "=", "gen_reg_rtx", "(", "d", "->", "mode", ")", ";", "rtx", "pat", "=", "NULL_RTX", ";", "if", "(", "d", "->", "lane", ")", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ",", "lane_idx", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "FCMLA", "lane", "expression", "EXP", "with", "code", "FCODE", "and", "result", "going", "to", "TARGET", "if", "that", "is", "convenient", "." ]

[ "aarch64", "1", "0", "1", "2", "3", "\"argument %d must be a constant immediate\"", "4", "0", "2", "4", "0", "0", "4" ]

[]

[ "<s>", "static", "void", "mips_emit_loadgp", "(", "void", ")", "{", "rtx", "addr", ",", "offset", ",", "incoming_address", ",", "base", ",", "index", ",", "pic_reg", ";", "pic_reg", "=", "TARGET_MIPS16", "?", "MIPS16_PIC_TEMP", ":", "pic_offset_table_rtx", ";", "switch", "(", "mips_current_loadgp_style", "(", ")", ")", "{", "case", "LOADGP_ABSOLUTE", ":", "if", "(", "mips_gnu_local_gp", "==", "NULL", ")", "{", "mips_gnu_local_gp", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__gnu_local_gp\"", ")", ";", "SYMBOL_REF_FLAGS", "(", "mips_gnu_local_gp", ")", "|=", "SYMBOL_FLAG_LOCAL", ";", "}", "emit_insn", "(", "PMODE_INSN", "(", "gen_loadgp_absolute", ",", "(", "pic_reg", ",", "mips_gnu_local_gp", ")", ")", ")", ";", "break", ";", "case", "LOADGP_OLDABI", ":", "break", ";", "case", "LOADGP_NEWABI", ":", "addr", "=", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ";", "offset", "=", "mips_unspec_address", "(", "addr", ",", "SYMBOL_GOTOFF_LOADGP", ")", ";", "incoming_address", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ";", "emit_insn", "(", "PMODE_INSN", "(", "gen_loadgp_newabi", ",", "(", "pic_reg", ",", "offset", ",", "incoming_address", ")", ")", ")", ";", "break", ";", "case", "LOADGP_RTP", ":", "base", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "VXWORKS_GOTT_BASE", ")", ")", ";", "index", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "VXWORKS_GOTT_INDEX", ")", ")", ";", "emit_insn", "(", "PMODE_INSN", "(", "gen_loadgp_rtp", ",", "(", "pic_reg", ",", "base", ",", "index", ")", ")", ")", ";", "break", ";", "default", ":", "return", ";", "}", "if", "(", "TARGET_MIPS16", ")", "emit_insn", "(", "PMODE_INSN", "(", "gen_copygp_mips16", ",", "(", "pic_offset_table_rtx", ",", "pic_reg", ")", ")", ")", ";", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", "||", "crtl", "->", "profile", ")", "emit_insn", "(", "gen_loadgp_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "If", "we", "'re", "generating", "n32", "or", "n64", "abicalls", ",", "emit", "instructions", "to", "set", "up", "the", "global", "pointer", "." ]

[ "mips", "\"__gnu_local_gp\"", "0" ]

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "12", ">", "(", "Imm", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "12" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "{", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "O", "<<", "'\\n'", ";", "if", "(", "!", "GVNonLazyPtrs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "2", ")", ";", "for", "(", "StringMap", "<", "std", "::", "string", ">", "::", "iterator", "I", "=", "GVNonLazyPtrs", ".", "begin", "(", ")", ",", "E", "=", "GVNonLazyPtrs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "O", "<<", "I", "->", "second", "<<", "\":\\n\"", ";", "O", "<<", "\"\\t.indirect_symbol \"", "<<", "I", "->", "getKeyData", "(", ")", "<<", "\"\\n\"", ";", "O", "<<", "\"\\t.long\\t0\\n\"", ";", "}", "}", "if", "(", "!", "HiddenGVNonLazyPtrs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "EmitAlignment", "(", "2", ")", ";", "for", "(", "StringMap", "<", "std", "::", "string", ">", "::", "iterator", "I", "=", "HiddenGVNonLazyPtrs", ".", "begin", "(", ")", ",", "E", "=", "HiddenGVNonLazyPtrs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "O", "<<", "I", "->", "second", "<<", "\":\\n\"", ";", "O", "<<", "\"\\t.long \"", "<<", "I", "->", "getKeyData", "(", ")", "<<", "\"\\n\"", ";", "}", "}", "O", "<<", "\"\\t.subsections_via_symbols\\n\"", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "ARM", "ARM", "2", "\":\\n\"", "\"\\t.indirect_symbol \"", "\"\\n\"", "\"\\t.long\\t0\\n\"", "2", "\":\\n\"", "\"\\t.long \"", "\"\\n\"", "\"\\t.subsections_via_symbols\\n\"" ]

[]

[ "<s>", "machine_mode", "memory_vector_mode", "(", "const", "function_instance", "&", ")", "const", "OVERRIDE", "{", "return", "m_mode", ";", "}", "</s>" ]

[ "If", "the", "function", "addresses", "memory", ",", "return", "a", "vector", "mode", "whose", "GET_MODE_NUNITS", "is", "the", "number", "of", "elements", "addressed", "and", "whose", "GET_MODE_INNER", "is", "the", "mode", "of", "a", "single", "scalar", "memory", "element", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "Nios2RegisterInfo", "::", "intRegClass", "(", "unsigned", "Size", ")", "const", "{", "return", "&", "Nios2", "::", "CPURegsRegClass", ";", "}", "</s>" ]

[ "Return", "GPR", "register", "class", "." ]

[ "Nios2", "Nios2", "Nios2::CPURegsRegClass" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isSafeMemOpType", "(", "MVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "X86ScalarSSEf32", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "X86ScalarSSEf64", ";", "return", "TargetLowering", "::", "isSafeMemOpType", "(", "VT", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "'s", "safe", "to", "use", "load", "/", "store", "of", "the", "specified", "type", "to", "expand", "memcpy", "/", "memset", "inline", "." ]

[ "X86", "X86", "MVT::f32", "X86", "MVT::f64", "X86" ]

[]

[ "<s>", "int", "mems_ok_for_quad_peep", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "addr1", ",", "addr2", ";", "unsigned", "int", "reg1", ",", "reg2", ";", "int", "offset1", ",", "offset2", ";", "if", "(", "MEM_VOLATILE_P", "(", "mem1", ")", "||", "MEM_VOLATILE_P", "(", "mem2", ")", ")", "return", "0", ";", "addr1", "=", "XEXP", "(", "mem1", ",", "0", ")", ";", "addr2", "=", "XEXP", "(", "mem2", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr1", ")", "==", "PLUS", ")", "{", "if", "(", "!", "REG_P", "(", "XEXP", "(", "addr1", ",", "0", ")", ")", ")", "return", "0", ";", "else", "{", "reg1", "=", "REGNO", "(", "XEXP", "(", "addr1", ",", "0", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "addr1", ",", "1", ")", ")", ")", "return", "0", ";", "offset1", "=", "INTVAL", "(", "XEXP", "(", "addr1", ",", "1", ")", ")", ";", "}", "}", "else", "if", "(", "!", "REG_P", "(", "addr1", ")", ")", "return", "0", ";", "else", "{", "reg1", "=", "REGNO", "(", "addr1", ")", ";", "offset1", "=", "0", ";", "}", "if", "(", "GET_CODE", "(", "addr2", ")", "==", "PLUS", ")", "{", "if", "(", "!", "REG_P", "(", "XEXP", "(", "addr2", ",", "0", ")", ")", ")", "return", "0", ";", "else", "{", "reg2", "=", "REGNO", "(", "XEXP", "(", "addr2", ",", "0", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "addr2", ",", "1", ")", ")", ")", "return", "0", ";", "offset2", "=", "INTVAL", "(", "XEXP", "(", "addr2", ",", "1", ")", ")", ";", "}", "}", "else", "if", "(", "!", "REG_P", "(", "addr2", ")", ")", "return", "0", ";", "else", "{", "reg2", "=", "REGNO", "(", "addr2", ")", ";", "offset2", "=", "0", ";", "}", "if", "(", "reg1", "!=", "reg2", ")", "return", "0", ";", "if", "(", "offset2", "!=", "offset1", "+", "8", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "addr1", "and", "addr2", "are", "suitable", "for", "lfq", "or", "stfq", "insn", ".", "addr1", "and", "addr2", "must", "be", "in", "consecutive", "memory", "locations", "(", "addr2", "==", "addr1", "+", "8", ")", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "0", "8", "0", "1" ]

[]

[ "<s>", "MachineBasicBlock", "*", "AArch64TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "MI", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Unexpected instruction for custom inserter!\"", ")", ";", "case", "AArch64", "::", "F128CSEL", ":", "return", "EmitF128CSEL", "(", "MI", ",", "BB", ")", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "case", "TargetOpcode", "::", "STATEPOINT", ":", "return", "emitPatchPoint", "(", "MI", ",", "BB", ")", ";", "case", "AArch64", "::", "CATCHRET", ":", "return", "EmitLoweredCatchRet", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Unexpected instruction for custom inserter!\"", "AArch64::F128CSEL", "AArch64::CATCHRET" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "CSKY" ]

[]

[ "<s>", "unsigned", "GCNSubtarget", "::", "getOccupancyWithNumVGPRs", "(", "unsigned", "VGPRs", ")", "const", "{", "unsigned", "MaxWaves", "=", "getMaxWavesPerEU", "(", ")", ";", "unsigned", "Granule", "=", "getVGPRAllocGranule", "(", ")", ";", "if", "(", "VGPRs", "<", "Granule", ")", "return", "MaxWaves", ";", "unsigned", "RoundedRegs", "=", "(", "(", "VGPRs", "+", "Granule", "-", "1", ")", "/", "Granule", ")", "*", "Granule", ";", "return", "std", "::", "min", "(", "getTotalNumVGPRs", "(", ")", "/", "RoundedRegs", ",", "MaxWaves", ")", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "waves", "per", "SIMD", "for", "kernels", "using", "VGPRs", "VGPRs", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "bool", "X86DomainReassignment", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DisableX86DomainReassignment", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function before Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "hasAVX512", "(", ")", "||", "!", "STI", "->", "hasBWI", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "initConverters", "(", ")", ";", "bool", "Changed", "=", "false", ";", "EnclosedEdges", ".", "clear", "(", ")", ";", "EnclosedInstrs", ".", "clear", "(", ")", ";", "std", "::", "vector", "<", "Closure", ">", "Closures", ";", "unsigned", "ClosureID", "=", "0", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "++", "Idx", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "Idx", ")", ";", "if", "(", "!", "isGPR", "(", "MRI", "->", "getRegClass", "(", "Reg", ")", ")", ")", "continue", ";", "if", "(", "EnclosedEdges", ".", "count", "(", "Reg", ")", ")", "continue", ";", "Closure", "C", "(", "ClosureID", "++", ",", "{", "MaskDomain", "}", ")", ";", "buildClosure", "(", "C", ",", "Reg", ")", ";", "if", "(", "!", "C", ".", "empty", "(", ")", "&&", "C", ".", "isLegal", "(", "MaskDomain", ")", ")", "Closures", ".", "push_back", "(", "std", "::", "move", "(", "C", ")", ")", ";", "}", "for", "(", "Closure", "&", "C", ":", "Closures", ")", "{", "LLVM_DEBUG", "(", "C", ".", "dump", "(", "MRI", ")", ")", ";", "if", "(", "isReassignmentProfitable", "(", "C", ",", "MaskDomain", ")", ")", "{", "reassign", "(", "C", ",", "MaskDomain", ")", ";", "++", "NumClosuresConverted", ";", "Changed", "=", "true", ";", "}", "}", "DeleteContainerSeconds", "(", "Converters", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function after Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"***** Machine Function before Domain Reassignment *****\\n\"", "X86", "\"Expected MIR to be in SSA form\"", "0", "0", "\"***** Machine Function after Domain Reassignment *****\\n\"" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "Align", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte stores to stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created store reg=\"", "<<", "printReg", "(", "SrcReg", ",", "TRI", ")", "<<", "\" to FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "ST_rs9", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte stores to stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created store reg=\"", "\" to FrameIndex=\"", "\"\\n\"", "ARC::ST_rs9", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "X86", "::", "GR8_NOREXRegisterClass", ")", "return", "RC", ";", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "X86", "::", "GR8RegClassID", ":", "case", "X86", "::", "GR16RegClassID", ":", "case", "X86", "::", "GR32RegClassID", ":", "case", "X86", "::", "GR64RegClassID", ":", "case", "X86", "::", "FR32RegClassID", ":", "case", "X86", "::", "FR64RegClassID", ":", "case", "X86", "::", "RFP32RegClassID", ":", "case", "X86", "::", "RFP64RegClassID", ":", "case", "X86", "::", "RFP80RegClassID", ":", "case", "X86", "::", "VR128RegClassID", ":", "case", "X86", "::", "VR256RegClassID", ":", "if", "(", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "X86", "X86", "X86::GR8_NOREXRegisterClass", "X86::GR8RegClassID", "X86::GR16RegClassID", "X86::GR32RegClassID", "X86::GR64RegClassID", "X86::FR32RegClassID", "X86::FR64RegClassID", "X86::RFP32RegClassID", "X86::RFP64RegClassID", "X86::RFP80RegClassID", "X86::VR128RegClassID", "X86::VR256RegClassID" ]

[]

[ "<s>", "bool", "riscv_legitimize_move", "(", "enum", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "!", "register_operand", "(", "dest", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "src", ",", "mode", ")", ")", "{", "riscv_emit_move", "(", "dest", ",", "force_reg", "(", "mode", ",", "src", ")", ")", ";", "return", "true", ";", "}", "if", "(", "CONSTANT_P", "(", "src", ")", "&&", "!", "move_operand", "(", "src", ",", "mode", ")", ")", "{", "riscv_legitimize_const_move", "(", "mode", ",", "dest", ",", "src", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "src", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "(", "set", "DEST", "SRC", ")", "is", "not", "a", "valid", "move", "instruction", ",", "emit", "an", "equivalent", "sequence", "that", "is", "valid", "." ]

[ "riscv" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "MCSymbol", "*", "Sym", "=", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ";", "if", "(", "isa", "<", "MCSymbolELF", ">", "(", "Sym", ")", ")", "return", "Sym", ";", "MCSymbolWasm", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Sym", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "return", "WasmSym", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "GetSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "WasmSym", "->", "setReturns", "(", "std", "::", "move", "(", "Returns", ")", ")", ";", "WasmSym", "->", "setParams", "(", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setIsFunction", "(", "true", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "wasm::ValType", "4", "wasm::ValType", "4" ]

[]

[ "<s>", "static", "rtx", "s390_function_value", "(", "const_tree", "ret_type", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", ")", "{", "return", "s390_function_and_libcall_value", "(", "TYPE_MODE", "(", "ret_type", ")", ",", "ret_type", ",", "fn_decl_or_type", ",", "outgoing", ")", ";", "}", "</s>" ]

[ "Define", "where", "to", "return", "a", "(", "scalar", ")", "value", "of", "type", "TYPE", ".", "If", "TYPE", "is", "null", ",", "define", "where", "to", "return", "a", "(", "scalar", ")", "value", "of", "mode", "MODE", "from", "a", "libcall", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "ia64_legitimate_constant_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "case", "LABEL_REF", ":", "return", "true", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "return", "true", ";", "return", "CONST_DOUBLE_OK_FOR_G", "(", "x", ")", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "return", "tls_symbolic_operand_type", "(", "x", ")", "==", "0", ";", "case", "CONST_VECTOR", ":", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "mode", "==", "V2SFmode", ")", "return", "ia64_extra_constraint", "(", "x", ",", "'Y'", ")", ";", "return", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "8", ")", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "constant", "that", "is", "valid", "for", "some", "immediate", "field", "in", "an", "instruction", "." ]

[ "ia64", "0", "8" ]

[]

[ "<s>", "static", "void", "spu_canonicalize_comparison", "(", "int", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "op0_preserve_value", ")", "{", "if", "(", "!", "op0_preserve_value", "&&", "(", "*", "code", "==", "LE", "||", "*", "code", "==", "LT", "||", "*", "code", "==", "LEU", "||", "*", "code", "==", "LTU", ")", ")", "{", "rtx", "tem", "=", "*", "op0", ";", "*", "op0", "=", "*", "op1", ";", "*", "op1", "=", "tem", ";", "*", "code", "=", "(", "int", ")", "swap_condition", "(", "(", "enum", "rtx_code", ")", "*", "code", ")", ";", "}", "}", "</s>" ]

[ "Canonicalize", "a", "comparison", "from", "one", "we", "do", "n't", "have", "to", "one", "we", "do", "have", "." ]

[ "spu" ]

[]

[ "<s>", "void", "cris_asm_output_ident", "(", "const", "char", "*", "string", ")", "{", "if", "(", "symtab", "->", "state", "!=", "PARSING", ")", "return", ";", "default_asm_output_ident_directive", "(", "string", ")", ";", "}", "</s>" ]

[ "Queue", "an", ".ident", "string", "in", "the", "queue", "of", "top-level", "asm", "statements", ".", "If", "the", "front-end", "is", "done", ",", "we", "must", "be", "being", "called", "from", "toplev.cc", ".", "In", "that", "case", ",", "do", "nothing", "." ]

[ "cris" ]

[]

[ "<s>", "void", "riscv_move_integer", "(", "rtx", "temp", ",", "rtx", "dest", ",", "HOST_WIDE_INT", "value", ")", "{", "struct", "riscv_integer_op", "codes", "[", "RISCV_MAX_INTEGER_OPS", "]", ";", "machine_mode", "mode", ";", "int", "i", ",", "num_ops", ";", "rtx", "x", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "num_ops", "=", "riscv_build_integer", "(", "codes", ",", "value", ",", "mode", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", "&&", "num_ops", ">", "2", "&&", "num_ops", ">=", "riscv_split_integer_cost", "(", "value", ")", ")", "x", "=", "riscv_split_integer", "(", "value", ",", "mode", ")", ";", "else", "{", "x", "=", "GEN_INT", "(", "codes", "[", "0", "]", ".", "value", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "num_ops", ";", "i", "++", ")", "{", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "x", "=", "riscv_emit_set", "(", "temp", ",", "x", ")", ";", "else", "x", "=", "force_reg", "(", "mode", ",", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "codes", "[", "i", "]", ".", "code", ",", "mode", ",", "x", ",", "GEN_INT", "(", "codes", "[", "i", "]", ".", "value", ")", ")", ";", "}", "}", "riscv_emit_set", "(", "dest", ",", "x", ")", ";", "}", "</s>" ]

[ "Load", "VALUE", "into", "DEST", ".", "TEMP", "is", "as", "for", "riscv_force_temporary", "." ]

[ "riscv", "2", "0", "1" ]

[]

[ "<s>", "void", "RISCVDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "HandleSDNode", "Dummy", "(", "CurDAG", "->", "getRoot", "(", ")", ")", ";", "SelectionDAG", "::", "allnodes_iterator", "Position", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "Position", "!=", "CurDAG", "->", "allnodes_begin", "(", ")", ")", "{", "SDNode", "*", "N", "=", "&", "*", "--", "Position", ";", "if", "(", "N", "->", "use_empty", "(", ")", "||", "!", "N", "->", "isMachineOpcode", "(", ")", ")", "continue", ";", "MadeChange", "|=", "doPeepholeSExtW", "(", "N", ")", ";", "MadeChange", "|=", "doPeepholeLoadStoreADDI", "(", "N", ")", ";", "MadeChange", "|=", "doPeepholeMaskedRVV", "(", "N", ")", ";", "}", "CurDAG", "->", "setRoot", "(", "Dummy", ".", "getValue", "(", ")", ")", ";", "if", "(", "MadeChange", ")", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "bool", "ix86_expand_sse_fp_minmax", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "if_true", ",", "rtx", "if_false", ")", "{", "enum", "machine_mode", "mode", ";", "bool", "is_min", ";", "rtx", "tmp", ";", "if", "(", "code", "==", "LT", ")", ";", "else", "if", "(", "code", "==", "UNGE", ")", "{", "tmp", "=", "if_true", ";", "if_true", "=", "if_false", ";", "if_false", "=", "tmp", ";", "}", "else", "return", "false", ";", "if", "(", "rtx_equal_p", "(", "cmp_op0", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op1", ",", "if_false", ")", ")", "is_min", "=", "true", ";", "else", "if", "(", "rtx_equal_p", "(", "cmp_op1", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op0", ",", "if_false", ")", ")", "is_min", "=", "false", ";", "else", "return", "false", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "!", "flag_unsafe_math_optimizations", ")", "{", "int", "u", "=", "is_min", "?", "UNSPEC_IEEE_MIN", ":", "UNSPEC_IEEE_MAX", ";", "rtvec", "v", ";", "if_true", "=", "force_reg", "(", "mode", ",", "if_true", ")", ";", "v", "=", "gen_rtvec", "(", "2", ",", "if_true", ",", "if_false", ")", ";", "tmp", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "v", ",", "u", ")", ";", "}", "else", "{", "code", "=", "is_min", "?", "SMIN", ":", "SMAX", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "if_true", ",", "if_false", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "tmp", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Detect", "conditional", "moves", "that", "exactly", "match", "min/max", "operational", "semantics", ".", "Note", "that", "this", "is", "IEEE", "safe", ",", "as", "long", "as", "we", "do", "n't", "interchange", "the", "operands", ".", "Returns", "FALSE", "if", "this", "conditional", "move", "does", "n't", "match", "a", "MIN/MAX", ",", "and", "TRUE", "if", "the", "operation", "is", "successful", "and", "instructions", "are", "emitted", "." ]

[ "i386", "2" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Optimize Call Frame\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Optimize Call Frame\"" ]

[]

[ "<s>", "void", "loongarch_expand_epilogue", "(", "bool", "sibcall_p", ")", "{", "struct", "loongarch_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "HOST_WIDE_INT", "step1", "=", "frame", "->", "total_size", ";", "HOST_WIDE_INT", "step2", "=", "0", ";", "rtx", "ra", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "insn", ";", "bool", "need_barrier_p", "=", "(", "get_frame_size", "(", ")", "+", "cfun", "->", "machine", "->", "frame", ".", "arg_pointer_offset", ")", "!=", "0", ";", "if", "(", "!", "sibcall_p", "&&", "loongarch_can_use_return_insn", "(", ")", ")", "{", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "return", ";", "}", "if", "(", "cfun", "->", "calls_alloca", ")", "{", "loongarch_emit_stack_tie", "(", ")", ";", "need_barrier_p", "=", "false", ";", "rtx", "adjust", "=", "GEN_INT", "(", "-", "frame", "->", "hard_frame_pointer_offset", ")", ";", "if", "(", "!", "IMM12_OPERAND", "(", "INTVAL", "(", "adjust", ")", ")", ")", "{", "loongarch_emit_move", "(", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ",", "adjust", ")", ";", "adjust", "=", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ";", "}", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "adjust", ")", ")", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "rtx", "minus_offset", "=", "GEN_INT", "(", "-", "frame", "->", "hard_frame_pointer_offset", ")", ";", "rtx", "cfa_adjust_value", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "minus_offset", ")", ";", "rtx", "cfa_adjust_rtx", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "cfa_adjust_value", ")", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_ADJUST_CFA", ",", "cfa_adjust_rtx", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "}", "if", "(", "(", "frame", "->", "mask", "|", "frame", "->", "fmask", ")", "!=", "0", ")", "{", "step2", "=", "loongarch_first_stack_step", "(", "frame", ")", ";", "step1", "-=", "step2", ";", "}", "if", "(", "step1", ">", "0", ")", "{", "loongarch_emit_stack_tie", "(", ")", ";", "need_barrier_p", "=", "false", ";", "rtx", "adjust", "=", "GEN_INT", "(", "step1", ")", ";", "if", "(", "!", "IMM12_OPERAND", "(", "step1", ")", ")", "{", "loongarch_emit_move", "(", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ",", "adjust", ")", ";", "adjust", "=", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ";", "}", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "adjust", ")", ")", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "rtx", "cfa_adjust_rtx", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "step2", ")", ")", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "cfa_adjust_rtx", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "}", "loongarch_for_each_saved_reg", "(", "frame", "->", "total_size", "-", "step2", ",", "loongarch_restore_reg", ")", ";", "if", "(", "need_barrier_p", ")", "loongarch_emit_stack_tie", "(", ")", ";", "if", "(", "step2", ">", "0", ")", "{", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "step2", ")", ")", ")", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "rtx", "cfa_adjust_rtx", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "const0_rtx", ")", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "cfa_adjust_rtx", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "!", "sibcall_p", ")", "emit_jump_insn", "(", "gen_simple_return_internal", "(", "ra", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "``", "epilogue", "''", "or", "``", "sibcall_epilogue", "''", "pattern", ";", "SIBCALL_P", "says", "which", "." ]

[ "loongarch", "0", "0", "1", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "mips_eh_uses", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "reload_completed", "&&", "!", "TARGET_ABSOLUTE_JUMPS", ")", "{", "if", "(", "mips_cfun_has_cprestore_slot_p", "(", ")", ")", "{", "if", "(", "regno", "==", "CPRESTORE_SLOT_REGNUM", ")", "return", "true", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "global_pointer", "==", "regno", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "EH_USES", "." ]

[ "mips" ]

[]

[ "<s>", "SDValue", "XtensaTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "ret", ";", "return", "ret", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "ISD::OutputArg" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ",", "unsigned", "ScalarizationCostPassed", ")", "{", "if", "(", "ID", "==", "Intrinsic", "::", "bswap", "&&", "ST", "->", "hasP9Vector", "(", ")", ")", "return", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ".", "first", ";", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Tys", ",", "FMF", ",", "ScalarizationCostPassed", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "PowerPC", "PPC", "Intrinsic::ID", "Intrinsic::bswap" ]

[]

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

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "static", "rtx", "nds32_expand_builtin_store", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "nds32_read_argument", "(", "exp", ",", "0", ")", ";", "rtx", "op1", "=", "nds32_read_argument", "(", "exp", ",", "1", ")", ";", "rtx", "addr_helper", "=", "gen_reg_rtx", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ")", ";", "op0", "=", "nds32_legitimize_argument", "(", "icode", ",", "0", ",", "op0", ")", ";", "op1", "=", "nds32_legitimize_argument", "(", "icode", ",", "2", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "addr_helper", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_move_insn", "(", "addr_helper", ",", "GEN_INT", "(", "0", ")", ")", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "for", "store", "." ]

[ "nds32", "0", "1", "1", "0", "2", "0" ]

[]

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

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

[ "LC3", "LC3", "0" ]

[]

[ "<s>", "bool", "X86IntelAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "unsigned", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "X86_StdCall", "||", "CC", "==", "CallingConv", "::", "X86_FastCall", ")", "FunctionInfoMap", "[", "F", "]", "=", "*", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "decorateName", "(", "CurrentFnName", ",", "F", ")", ";", "SwitchToTextSection", "(", "\"_text\"", ",", "F", ")", ";", "unsigned", "FnAlign", "=", "4", ";", "if", "(", "F", "->", "hasFnAttr", "(", "Attribute", "::", "OptimizeForSize", ")", ")", "FnAlign", "=", "1", ";", "switch", "(", "F", "->", "getLinkage", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Unsupported linkage type!\"", ")", ";", "case", "Function", "::", "PrivateLinkage", ":", "case", "Function", "::", "InternalLinkage", ":", "EmitAlignment", "(", "FnAlign", ")", ";", "break", ";", "case", "Function", "::", "DLLExportLinkage", ":", "DLLExportedFns", ".", "insert", "(", "CurrentFnName", ")", ";", "case", "Function", "::", "ExternalLinkage", ":", "O", "<<", "\"\\tpublic \"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "EmitAlignment", "(", "FnAlign", ")", ";", "break", ";", "}", "O", "<<", "CurrentFnName", "<<", "\"\\tproc near\\n\"", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "pred_empty", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "O", "<<", "CurrentFnName", "<<", "\"\\tendp\\n\"", ";", "O", ".", "flush", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"\\n\\n\"", "X86", "X86", "X86", "\"_text\"", "4", "1", "0", "\"Unsupported linkage type!\"", "\"\\tpublic \"", "\"\\n\"", "\"\\tproc near\\n\"", "\"\\tendp\\n\"" ]

[]

[ "<s>", "bool", "Cpu0AsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "MCOp", "=", "MCInstLowering", ".", "LowerOperand", "(", "MO", ")", ";", "return", "MCOp", ".", "isValid", "(", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "bool", "aarch64_sve_data_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "aarch64_classify_vector_mode", "(", "mode", ")", "&", "VEC_SVE_DATA", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "an", "SVE", "data", "vector", "mode", ";", "either", "a", "single", "vector", "or", "a", "structure", "of", "vectors", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "HSAILInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "HSAIL", "::", "ARG_SCOPE_START", ")", "{", "InArgScope", "=", "true", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "HSAIL", "::", "ARG_SCOPE_END", ")", "{", "InArgScope", "=", "false", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "InArgScope", ")", "OS", "<<", "'\\t'", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "HSAIL", "::", "CALL", ")", "{", "unsigned", "I", "=", "1", ";", "OS", "<<", "'('", ";", "const", "MCOperand", "*", "Op", "=", "&", "MI", "->", "getOperand", "(", "1", ")", ";", "while", "(", "!", "Op", "->", "isImm", "(", ")", ")", "{", "printOperand", "(", "MI", ",", "I", "++", ",", "OS", ")", ";", "Op", "=", "&", "MI", "->", "getOperand", "(", "I", ")", ";", "}", "assert", "(", "(", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "getImm", "(", ")", "==", "0", ")", "&&", "\"Unexpected target call instruction operand list!\"", ")", ";", "++", "I", ";", "OS", "<<", "\") (\"", ";", "unsigned", "N", "=", "MI", "->", "getNumOperands", "(", ")", ";", "while", "(", "I", "<", "N", ")", "{", "printOperand", "(", "MI", ",", "I", "++", ",", "OS", ")", ";", "if", "(", "I", "<", "N", ")", "OS", "<<", "\", \"", ";", "}", "OS", "<<", "\");\"", ";", "}", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "HSAIL::ARG_SCOPE_START", "HSAIL::ARG_SCOPE_END", "HSAIL::CALL", "1", "1", "0", "\"Unexpected target call instruction operand list!\"", "\") (\"", "\", \"", "\");\"" ]

[]

[ "<s>", "static", "const", "char", "*", "getName", "(", ")", "{", "return", "DEBUG_TYPE", ";", "}", "</s>" ]

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

[ "RISCV" ]

[]

[ "<s>", "size_t", "THMToTHMStub", "::", "size", "(", ")", "const", "{", "return", "m_Size", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "canUseRedZone", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "EnableRedZone", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "unsigned", "NumBytes", "=", "AFI", "->", "getLocalStackSize", "(", ")", ";", "return", "!", "(", "MFI", "->", "hasCalls", "(", ")", "||", "hasFP", "(", "MF", ")", "||", "NumBytes", ">", "128", ")", ";", "}", "</s>" ]

[ "Can", "this", "function", "use", "the", "red", "zone", "for", "local", "allocations", "." ]

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

[]

[ "<s>", "bool", "pass_vsetvl", "::", "cleanup_illegal_dirty_blocks", "(", "void", ")", "{", "bool", "changed_p", "=", "false", ";", "for", "(", "const", "bb_info", "*", "bb", ":", "crtl", "->", "ssa", "->", "bbs", "(", ")", ")", "{", "basic_block", "cfg_bb", "=", "bb", "->", "cfg_bb", "(", ")", ";", "const", "auto", "&", "prop", "=", "m_vector_manager", "->", "vector_block_infos", "[", "cfg_bb", "->", "index", "]", ".", "reaching_out", ";", "if", "(", "!", "prop", ".", "valid_or_dirty_p", "(", ")", ")", "continue", ";", "if", "(", "hard_empty_block_p", "(", "bb", ",", "prop", ")", ")", "{", "m_vector_manager", "->", "vector_block_infos", "[", "cfg_bb", "->", "index", "]", ".", "local_dem", "=", "vector_insn_info", "::", "get_hard_empty", "(", ")", ";", "m_vector_manager", "->", "vector_block_infos", "[", "cfg_bb", "->", "index", "]", ".", "reaching_out", "=", "vector_insn_info", "::", "get_hard_empty", "(", ")", ";", "changed_p", "=", "true", ";", "continue", ";", "}", "}", "return", "changed_p", ";", "}", "</s>" ]

[ "Cleanup", "illegal", "dirty", "blocks", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "auto", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "X86MaterializeInt", "(", "CI", ",", "VT", ")", ";", "if", "(", "const", "auto", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "X86MaterializeFP", "(", "CFP", ",", "VT", ")", ";", "if", "(", "const", "auto", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "X86MaterializeGV", "(", "GV", ",", "VT", ")", ";", "if", "(", "isa", "<", "UndefValue", ">", "(", "C", ")", ")", "{", "unsigned", "Opc", "=", "0", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "f32", ":", "if", "(", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", "Opc", "=", "X86", "::", "LD_Fp032", ";", "break", ";", "case", "MVT", "::", "f64", ":", "if", "(", "!", "Subtarget", "->", "hasSSE2", "(", ")", ")", "Opc", "=", "X86", "::", "LD_Fp064", ";", "break", ";", "case", "MVT", "::", "f80", ":", "Opc", "=", "X86", "::", "LD_Fp080", ";", "break", ";", "}", "if", "(", "Opc", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ";", "return", "ResultReg", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

[ "X86", "X86", "0", "X86", "X86", "X86", "0", "MVT::f32", "X86::LD_Fp032", "MVT::f64", "X86::LD_Fp064", "MVT::f80", "X86::LD_Fp080", "0" ]

[]

[ "<s>", "static", "void", "loongarch_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gp_saved", ";", "local_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "loongarch_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "arg", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_gprs", ";", "if", "(", "!", "no_rtl", "&&", "gp_saved", ">", "0", ")", "{", "rtx", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "-", "gp_saved", "*", "UNITS_PER_WORD", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "num_gprs", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "==", "0", ")", "cfun", "->", "machine", "->", "varargs_size", "=", "gp_saved", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "loongarch", "0", "0" ]

[]

[ "<s>", "static", "void", "riscv_set_frame_expr", "(", "rtx", "frame_pattern", ")", "{", "rtx", "insn", ";", "insn", "=", "get_last_insn", "(", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "frame_pattern", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Make", "the", "last", "instruction", "frame-related", "and", "note", "that", "it", "performs", "the", "operation", "described", "by", "FRAME_PATTERN", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "SDValue", "ResValue", "=", "Outs", "[", "i", "]", ".", "Val", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ResValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "ResValue", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ResValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "ResValue", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "AExt", ")", "ResValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "ResValue", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "ResValue", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::OutputArg", "16", "SystemZ", "0", "0", "\"Can only return in registers!\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "1", "SystemZISD::RET_FLAG", "MVT::Other", "SystemZISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "LowerSMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "LowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "ExpandADDSUB", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::BR_JT", "ISD::LOAD", "ISD::STORE", "ISD::SELECT_CC", "ISD::VAARG", "ISD::VASTART", "ISD::SMUL_LOHI", "ISD::UMUL_LOHI", "ISD::ADD", "ISD::SUB", "ISD::FRAMEADDR", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "\"unimplemented operand\"" ]

[]

[ "<s>", "void", "addInst", "(", "MachineInstr", "*", "MI", ",", "SetVector", "<", "MachineInstr", "*", ">", "&", "Preds", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM Loops: Adding predicated MI: \"", "<<", "*", "MI", ")", ";", "if", "(", "!", "Divergent", "&&", "!", "set_difference", "(", "Preds", ",", "PredicateThen", "->", "Predicates", ")", ".", "empty", "(", ")", ")", "{", "Divergent", "=", "&", "Insts", ".", "back", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" - has divergent predicate: \"", "<<", "*", "Divergent", "->", "MI", ")", ";", "}", "Insts", ".", "emplace_back", "(", "MI", ",", "Preds", ")", ";", "assert", "(", "Insts", ".", "size", "(", ")", "<=", "4", "&&", "\"Too many instructions in VPT block!\"", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCInst", "operand", "." ]

[ "ARM", "\"ARM Loops: Adding predicated MI: \"", "\" - has divergent predicate: \"", "4", "\"Too many instructions in VPT block!\"" ]

[]

[ "<s>", "static", "bool", "aarch64_libgcc_floating_mode_supported_p", "(", "scalar_float_mode", "mode", ")", "{", "return", "(", "mode", "==", "HFmode", "?", "true", ":", "default_libgcc_floating_mode_supported_p", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBGCC_FLOATING_POINT_MODE_SUPPORTED_P", "-", "return", "TRUE", "if", "MODE", "is", "HFmode", ",", "and", "punt", "to", "the", "generic", "implementation", "otherwise", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "areJTsAllowed", "(", "const", "Function", "*", "Fn", ")", "const", "{", "if", "(", "Subtarget", ".", "useRetpolineIndirectBranches", "(", ")", ")", "return", "false", ";", "return", "TargetLowering", "::", "areJTsAllowed", "(", "Fn", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "lowering", "to", "a", "jump", "table", "is", "allowed", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyLocalReference", "(", "const", "GlobalValue", "*", "GV", ")", "const", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "isTargetELF", "(", ")", ")", "{", "switch", "(", "TM", ".", "getCodeModel", "(", ")", ")", "{", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Kernel", ":", "return", "X86II", "::", "MO_NO_FLAG", ";", "case", "CodeModel", "::", "Large", ":", "return", "X86II", "::", "MO_GOTOFF", ";", "case", "CodeModel", "::", "Medium", ":", "if", "(", "isa", "<", "Function", ">", "(", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_GOTOFF", ";", "}", "llvm_unreachable", "(", "\"invalid code model\"", ")", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "if", "(", "isTargetCOFF", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "&&", "(", "GV", "->", "isDeclarationForLinker", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "return", "X86II", "::", "MO_GOTOFF", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "\"invalid code model\"", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_GOTOFF" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "PBQPRAConstraint", ">", "AArch64Subtarget", "::", "getCustomPBQPConstraints", "(", ")", "const", "{", "return", "balanceFPOps", "(", ")", "?", "llvm", "::", "make_unique", "<", "A57ChainingConstraint", ">", "(", ")", ":", "nullptr", ";", "}", "</s>" ]

[ "Return", "PBQPConstraint", "(", "s", ")", "for", "the", "target", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "int", "shl_and_length", "(", "rtx", "insn", ")", "{", "rtx", "set_src", ",", "left_rtx", ",", "mask_rtx", ";", "int", "attributes", "[", "3", "]", ";", "set_src", "=", "SET_SRC", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", ";", "left_rtx", "=", "XEXP", "(", "XEXP", "(", "set_src", ",", "0", ")", ",", "1", ")", ";", "mask_rtx", "=", "XEXP", "(", "set_src", ",", "1", ")", ";", "shl_and_kind", "(", "left_rtx", ",", "mask_rtx", ",", "attributes", ")", ";", "return", "attributes", "[", "1", "]", ";", "}", "</s>" ]

[ "This", "is", "used", "in", "length", "attributes", "of", "the", "unnamed", "instructions", "corresponding", "to", "shl_and_kind", "return", "values", "of", "1", "and", "2", "." ]

[ "sh", "3", "0", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 vzeroupper inserter\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 vzeroupper inserter\"" ]

[]

[ "<s>", "bool", "MBlazeAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "isLandingPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "PI", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", ";", "return", "I", "==", "Pred", "->", "end", "(", ")", "||", "!", "I", "->", "getDesc", "(", ")", ".", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "SDValue", "SICTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC" ]

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ",", "unsigned", "ScalarizationCostPassed", ",", "const", "Instruction", "*", "I", ")", "{", "if", "(", "ID", "==", "Intrinsic", "::", "bswap", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", ".", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "return", "LT", ".", "first", "+", "2", ";", "}", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Tys", ",", "FMF", ",", "ScalarizationCostPassed", ",", "I", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "Hexagon", "Hexagon", "Intrinsic::ID", "Intrinsic::bswap", "2" ]

[]

[ "<s>", "static", "bool", "nios2_symbolic_constant_p", "(", "rtx", "x", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "flag_pic", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "else", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "{", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "return", "(", "SYMBOL_REF_P", "(", "base", ")", "&&", "!", "SYMBOL_REF_TLS_MODEL", "(", "base", ")", "&&", "!", "gprel_constant_p", "(", "base", ")", "&&", "!", "r0rel_constant_p", "(", "base", ")", "&&", "SMALL_INT", "(", "INTVAL", "(", "offset", ")", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "constant", "expression", "with", "a", "reference", "to", "an", "``", "ordinary", "''", "symbol", ";", "not", "GOT-relative", ",", "not", "GP-relative", ",", "not", "TLS", "." ]

[ "nios2" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "KudeyarRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "Kudeyar", "::", "GPRRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "Kudeyar", "Kudeyar", "Kudeyar::GPRRegClass" ]

[]

[ "<s>", "static", "void", "get_scratch_register_on_entry", "(", "struct", "scratch_reg", "*", "sr", ")", "{", "int", "regno", ";", "sr", "->", "saved", "=", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "regno", "=", "R11_REG", ";", "}", "else", "{", "tree", "decl", "=", "current_function_decl", ",", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "bool", "fastcall_p", "=", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "!=", "NULL_TREE", ";", "bool", "thiscall_p", "=", "lookup_attribute", "(", "\"thiscall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "!=", "NULL_TREE", ";", "bool", "static_chain_p", "=", "DECL_STATIC_CHAIN", "(", "decl", ")", ";", "int", "regparm", "=", "ix86_function_regparm", "(", "fntype", ",", "decl", ")", ";", "int", "drap_regno", "=", "crtl", "->", "drap_reg", "?", "REGNO", "(", "crtl", "->", "drap_reg", ")", ":", "INVALID_REGNUM", ";", "if", "(", "(", "regparm", "<", "1", "||", "(", "fastcall_p", "&&", "!", "static_chain_p", ")", ")", "&&", "drap_regno", "!=", "AX_REG", ")", "regno", "=", "AX_REG", ";", "else", "if", "(", "thiscall_p", "&&", "!", "static_chain_p", "&&", "drap_regno", "!=", "AX_REG", ")", "regno", "=", "AX_REG", ";", "else", "if", "(", "regparm", "<", "2", "&&", "!", "thiscall_p", "&&", "drap_regno", "!=", "DX_REG", ")", "regno", "=", "DX_REG", ";", "else", "if", "(", "regparm", "<", "3", "&&", "!", "fastcall_p", "&&", "!", "thiscall_p", "&&", "!", "static_chain_p", "&&", "drap_regno", "!=", "CX_REG", ")", "regno", "=", "CX_REG", ";", "else", "if", "(", "ix86_save_reg", "(", "BX_REG", ",", "true", ",", "false", ")", ")", "regno", "=", "BX_REG", ";", "else", "if", "(", "!", "(", "regparm", "==", "3", "&&", "static_chain_p", ")", "&&", "ix86_save_reg", "(", "SI_REG", ",", "true", ",", "false", ")", ")", "regno", "=", "SI_REG", ";", "else", "if", "(", "ix86_save_reg", "(", "DI_REG", ",", "true", ",", "false", ")", ")", "regno", "=", "DI_REG", ";", "else", "{", "regno", "=", "(", "drap_regno", "==", "AX_REG", "?", "DX_REG", ":", "AX_REG", ")", ";", "sr", "->", "saved", "=", "true", ";", "}", "}", "sr", "->", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "if", "(", "sr", "->", "saved", ")", "{", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_push", "(", "sr", "->", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Return", "a", "short-lived", "scratch", "register", "for", "use", "on", "function", "entry", ".", "In", "32-bit", "mode", ",", "it", "is", "valid", "only", "after", "the", "registers", "are", "saved", "in", "the", "prologue", ".", "This", "register", "must", "be", "released", "by", "means", "of", "release_scratch_register_on_entry", "once", "it", "is", "dead", "." ]

[ "i386", "\"fastcall\"", "\"thiscall\"", "1", "2", "3", "3", "1" ]

[]

[ "<s>", "static", "unsigned", "int", "m32c_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "rv", "=", "m32c_hard_regno_nregs_1", "(", "regno", ",", "mode", ")", ";", "return", "rv", "?", "rv", ":", "1", ";", "}", "</s>" ]

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

[ "m32c", "1" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", ":", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "CM", "?", "*", "CM", ":", "CodeModel", "::", "Large", ",", "OL", ")", ",", "TLOF", "(", "TT", ".", "isOSBinFormatELF", "(", ")", "?", "static_cast", "<", "TargetLoweringObjectFile", "*", ">", "(", "new", "WebAssemblyTargetObjectFileELF", "(", ")", ")", ":", "static_cast", "<", "TargetLoweringObjectFile", "*", ">", "(", "new", "WebAssemblyTargetObjectFile", "(", ")", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "if", "(", "!", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "{", "this", "->", "Options", ".", "FunctionSections", "=", "true", ";", "this", "->", "Options", ".", "DataSections", "=", "true", ";", "this", "->", "Options", ".", "UniqueSectionNames", "=", "true", ";", "}", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "isLegalMaskedGather", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "return", "isLegalMaskedGatherScatter", "(", "DataType", ",", "Alignment", ")", ";", "}", "</s>" ]

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

[ "RISCV" ]

[]

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

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

[ "XCore", "XCore", "1", "0", "0U", "XCore::GRRegsRegClass" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "case", "Match_Success", ":", "ProcessInstruction", "(", "Inst", ",", "Operands", ")", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "PPCMnemonicSpellCheck", "(", "(", "(", "PPCOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "PPCOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "PPCOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"instruction use requires an option to be enabled\"", "PPC", "PPC", "0", "\"invalid instruction\"", "PPC", "0", "0ULL", "\"too few operands for instruction\"", "PPC", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "Reset", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Reset hazard recognizer\\n\"", ")", ";", "Resources", "->", "clearResources", "(", ")", ";", "PacketNum", "=", "0", ";", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "UsesLoad", "=", "false", ";", "PrefVectorStoreNew", "=", "nullptr", ";", "RegDefs", ".", "clear", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Reset hazard recognizer\\n\"", "0", "1" ]

[]

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

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "MCS51" ]

[]

[ "<s>", "bool", "mips_const_vector_same_int_p", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "HOST_WIDE_INT", "low", ",", "HOST_WIDE_INT", "high", ")", "{", "HOST_WIDE_INT", "value", ";", "rtx", "elem0", ";", "if", "(", "!", "mips_const_vector_same_val_p", "(", "op", ",", "mode", ")", ")", "return", "false", ";", "elem0", "=", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elem0", ")", ")", "return", "false", ";", "value", "=", "INTVAL", "(", "elem0", ")", ";", "return", "(", "value", ">=", "low", "&&", "value", "<=", "high", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "constant", "vector", "with", "the", "number", "of", "units", "in", "MODE", ",", "and", "each", "unit", "has", "the", "same", "integer", "value", "in", "the", "range", "[", "LOW", ",", "HIGH", "]", "." ]

[ "mips", "0" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getOpcodeAfterMemoryUnfold", "(", "unsigned", "Opc", ",", "bool", "UnfoldLoad", ",", "bool", "UnfoldStore", ",", "unsigned", "*", "LoadRegIndex", ")", "const", "{", "auto", "I", "=", "MemOp2RegOpTable", ".", "find", "(", "Opc", ")", ";", "if", "(", "I", "==", "MemOp2RegOpTable", ".", "end", "(", ")", ")", "return", "0", ";", "bool", "FoldedLoad", "=", "I", "->", "second", ".", "second", "&", "TB_FOLDED_LOAD", ";", "bool", "FoldedStore", "=", "I", "->", "second", ".", "second", "&", "TB_FOLDED_STORE", ";", "if", "(", "UnfoldLoad", "&&", "!", "FoldedLoad", ")", "return", "0", ";", "if", "(", "UnfoldStore", "&&", "!", "FoldedStore", ")", "return", "0", ";", "if", "(", "LoadRegIndex", ")", "*", "LoadRegIndex", "=", "I", "->", "second", ".", "second", "&", "TB_INDEX_MASK", ";", "return", "I", "->", "second", ".", "first", ";", "}", "</s>" ]

[ "getOpcodeAfterMemoryUnfold", "-", "Returns", "the", "opcode", "of", "the", "would", "be", "new", "instruction", "after", "load", "/", "store", "are", "unfolded", "from", "an", "instruction", "of", "the", "specified", "opcode", "." ]

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

[]

[ "<s>", "bool", "LanaiPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createLanaiISelDag", "(", "getLanaiTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "bfin_hardware_loop", "(", "void", ")", "{", "cfun", "->", "machine", "->", "has_hardware_loops", "++", ";", "}", "</s>" ]

[ "Increment", "the", "counter", "for", "the", "number", "of", "loop", "instructions", "in", "the", "current", "function", "." ]

[ "bfin" ]

[]