Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "P2Subtarget", "*", "P2TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "{", "return", "&", "subtarget", ";", "}", "</s>" ]

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

[ "P2", "P2", "P2" ]

[]

[ "<s>", "static", "tree", "ix86_vector_shift_count", "(", "tree", "arg1", ")", "{", "if", "(", "tree_fits_uhwi_p", "(", "arg1", ")", ")", "return", "arg1", ";", "else", "if", "(", "TREE_CODE", "(", "arg1", ")", "==", "VECTOR_CST", "&&", "CHAR_BIT", "==", "8", ")", "{", "unsigned", "char", "buf", "[", "16", "]", ";", "int", "len", "=", "native_encode_expr", "(", "arg1", ",", "buf", ",", "16", ")", ";", "if", "(", "len", "==", "0", ")", "return", "NULL_TREE", ";", "tree", "t", "=", "native_interpret_expr", "(", "uint64_type_node", ",", "buf", ",", "len", ")", ";", "if", "(", "t", "&&", "tree_fits_uhwi_p", "(", "t", ")", ")", "return", "t", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "the", "shift", "count", "of", "a", "vector", "by", "scalar", "shift", "builtin", "second", "argument", "ARG1", "." ]

[ "i386", "8", "16", "16", "0" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownOne", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "APInt", "KnownZero2", ";", "APInt", "KnownOne2", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imin", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umin", ":", "computeKnownBitsForMinMax", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "Op", ".", "getOperand", "(", "2", ")", ",", "KnownZero", ",", "KnownOne", ",", "DAG", ",", "Depth", ")", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "}", "case", "AMDGPUISD", "::", "SMAX", ":", "case", "AMDGPUISD", "::", "UMAX", ":", "case", "AMDGPUISD", "::", "SMIN", ":", "case", "AMDGPUISD", "::", "UMIN", ":", "computeKnownBitsForMinMax", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZero", ",", "KnownOne", ",", "DAG", ",", "Depth", ")", ";", "break", ";", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "{", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "32", ",", "31", ")", ";", "break", ";", "}", "case", "AMDGPUISD", "::", "BFE_I32", ":", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "CWidth", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "CWidth", ")", "return", ";", "unsigned", "BitWidth", "=", "32", ";", "uint32_t", "Width", "=", "CWidth", "->", "getZExtValue", "(", ")", "&", "0x1f", ";", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BFE_U32", ")", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "Width", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "R600", "0", "ISD::INTRINSIC_WO_CHAIN", "0", "AMDGPUIntrinsic::AMDGPU_imax", "AMDGPUIntrinsic::AMDGPU_umax", "AMDGPUIntrinsic::AMDGPU_imin", "AMDGPUIntrinsic::AMDGPU_umin", "1", "2", "AMDGPUISD::SMAX", "AMDGPUISD::UMAX", "AMDGPUISD::SMIN", "AMDGPUISD::UMIN", "0", "1", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "32", "31", "AMDGPUISD::BFE_I32", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "AMDGPUISD::BFE_U32" ]

[]

[ "<s>", "void", "arm_d_target_versions", "(", "void", ")", "{", "d_add_builtin_version", "(", "\"ARM\"", ")", ";", "if", "(", "TARGET_THUMB", "||", "TARGET_THUMB2", ")", "{", "d_add_builtin_version", "(", "\"Thumb\"", ")", ";", "d_add_builtin_version", "(", "\"ARM_Thumb\"", ")", ";", "}", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "d_add_builtin_version", "(", "\"ARM_HardFloat\"", ")", ";", "else", "{", "if", "(", "TARGET_SOFT_FLOAT", ")", "d_add_builtin_version", "(", "\"ARM_SoftFloat\"", ")", ";", "else", "if", "(", "TARGET_HARD_FLOAT", ")", "d_add_builtin_version", "(", "\"ARM_SoftFP\"", ")", ";", "}", "if", "(", "TARGET_SOFT_FLOAT", ")", "d_add_builtin_version", "(", "\"D_SoftFloat\"", ")", ";", "else", "if", "(", "TARGET_HARD_FLOAT", ")", "d_add_builtin_version", "(", "\"D_HardFloat\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_CPU_VERSIONS", "for", "ARM", "targets", "." ]

[ "arm", "\"ARM\"", "\"Thumb\"", "\"ARM_Thumb\"", "\"ARM_HardFloat\"", "\"ARM_SoftFloat\"", "\"ARM_SoftFP\"", "\"D_SoftFloat\"", "\"D_HardFloat\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getIncrementValue", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "Value", ")", "const", "{", "if", "(", "isPostIncrement", "(", "MI", ")", ")", "{", "unsigned", "BasePos", "=", "0", ",", "OffsetPos", "=", "0", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MI", ",", "BasePos", ",", "OffsetPos", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "OffsetOp", "=", "MI", ".", "getOperand", "(", "OffsetPos", ")", ";", "if", "(", "OffsetOp", ".", "isImm", "(", ")", ")", "{", "Value", "=", "OffsetOp", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "A2_addi", ")", "{", "const", "MachineOperand", "&", "AddOp", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "AddOp", ".", "isImm", "(", ")", ")", "{", "Value", "=", "AddOp", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "instruction", "is", "an", "increment", "of", "a", "constant", "value", ",", "return", "the", "amount", "." ]

[ "Hexagon", "Hexagon", "0", "0", "Hexagon::A2_addi", "2" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "(", "NoFramePointerElim", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "||", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "mips_frame_set", "(", "rtx", "mem", ",", "rtx", "reg", ")", "{", "rtx", "set", ";", "set", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "Return", "a", "frame-related", "rtx", "that", "stores", "register", "REGNO", "at", "(", "SP", "+", "OFFSET", ")", ".", "The", "expression", "should", "only", "be", "used", "to", "store", "single", "registers", "." ]

[ "mips", "1" ]

[]

[ "<s>", "static", "void", "arm_option_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ")", "{", "ptr", "->", "x_arm_arch_string", "=", "opts", "->", "x_arm_arch_string", ";", "ptr", "->", "x_arm_cpu_string", "=", "opts", "->", "x_arm_cpu_string", ";", "ptr", "->", "x_arm_tune_string", "=", "opts", "->", "x_arm_tune_string", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_SAVE", "." ]

[ "arm" ]

[]

[ "<s>", "static", "unsigned", "int", "insn_is_load_p", "(", "rtx", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "MEM", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "==", "MEM", ")", "return", "1", ";", "return", "0", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "!=", "PARALLEL", ")", "return", "0", ";", "rtx", "set", "=", "XVECEXP", "(", "body", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "MEM", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "iff", "INSN", "is", "a", "load", "insn", ",", "including", "permuting", "loads", "that", "represent", "an", "lvxd2x", "instruction", ";", "else", "return", "0", "." ]

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

[]

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

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

[ "AAP" ]

[]

[ "<s>", "static", "bool", "spu_truly_noop_truncation", "(", "poly_uint64", "outprec", ",", "poly_uint64", "inprec", ")", "{", "return", "inprec", "<=", "32", "&&", "outprec", "<=", "inprec", ";", "}", "</s>" ]

[ "Implement", "TARGET_TRULY_NOOP_TRUNCATION", "." ]

[ "spu", "32" ]

[]

[ "<s>", "static", "bool", "aarch64_multiply_add_p", "(", "vec_info", "*", "vinfo", ",", "stmt_vec_info", "stmt_info", ")", "{", "gassign", "*", "assign", "=", "dyn_cast", "<", "gassign", "*", ">", "(", "stmt_info", "->", "stmt", ")", ";", "if", "(", "!", "assign", ")", "return", "false", ";", "tree_code", "code", "=", "gimple_assign_rhs_code", "(", "assign", ")", ";", "if", "(", "code", "!=", "PLUS_EXPR", "&&", "code", "!=", "MINUS_EXPR", ")", "return", "false", ";", "if", "(", "CONSTANT_CLASS_P", "(", "gimple_assign_rhs1", "(", "assign", ")", ")", "||", "CONSTANT_CLASS_P", "(", "gimple_assign_rhs2", "(", "assign", ")", ")", ")", "return", "false", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "3", ";", "++", "i", ")", "{", "tree", "rhs", "=", "gimple_op", "(", "assign", ",", "i", ")", ";", "if", "(", "TREE_CODE", "(", "rhs", ")", "!=", "SSA_NAME", ")", "continue", ";", "stmt_vec_info", "def_stmt_info", "=", "vinfo", "->", "lookup_def", "(", "rhs", ")", ";", "if", "(", "!", "def_stmt_info", "||", "STMT_VINFO_DEF_TYPE", "(", "def_stmt_info", ")", "!=", "vect_internal_def", ")", "continue", ";", "gassign", "*", "rhs_assign", "=", "dyn_cast", "<", "gassign", "*", ">", "(", "def_stmt_info", "->", "stmt", ")", ";", "if", "(", "!", "rhs_assign", "||", "gimple_assign_rhs_code", "(", "rhs_assign", ")", "!=", "MULT_EXPR", ")", "continue", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "STMT_INFO", "is", "the", "second", "part", "of", "a", "two-statement", "multiply-add", "or", "multiply-subtract", "sequence", "that", "might", "be", "suitable", "for", "fusing", "into", "a", "single", "instruction", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "GBZ80FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "assert", "(", "Amount", "==", "0", "&&", "\"call frame with stack not yet implemented!\"", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "TFI", ".", "getStackAlignment", "(", ")", "==", "1", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "true", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "GB", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "GB", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "SPREAD", ")", ",", "GB", "::", "R31R30", ")", ".", "addReg", "(", "GB", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "GB", "::", "R31R30", ")", ".", "addReg", "(", "GB", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "SPWRITE", ")", ",", "GB", "::", "SP", ")", ".", "addReg", "(", "GB", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</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", ")", "." ]

[ "GBZ80", "GB", "GB", "GB", "GB", "0", "\"call frame with stack not yet implemented!\"", "0", "1", "\"Unsupported stack alignment\"", "6", "GB::ADIWRdK", "GB::SUBIWRdK", "GB::SPREAD", "GB::R31R30", "GB::SP", "GB::R31R30", "GB::R31R30", "3", "GB::SPWRITE", "GB::SP", "GB::R31R30" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "DataLayoutPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "(", "\"stack-protector\"", ")", ";", "AU", ".", "addPreserved", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "\"stack-protector\"" ]

[]

[ "<s>", "static", "void", "aarch64_emit_store_exclusive", "(", "machine_mode", "mode", ",", "rtx", "bval", ",", "rtx", "rval", ",", "rtx", "mem", ",", "rtx", "model_rtx", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "gen", "=", "gen_aarch64_store_exclusiveqi", ";", "break", ";", "case", "E_HImode", ":", "gen", "=", "gen_aarch64_store_exclusivehi", ";", "break", ";", "case", "E_SImode", ":", "gen", "=", "gen_aarch64_store_exclusivesi", ";", "break", ";", "case", "E_DImode", ":", "gen", "=", "gen_aarch64_store_exclusivedi", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "bval", ",", "rval", ",", "mem", ",", "model_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "store", "exclusive", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "TPCPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createTPCSetSpillBase", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "TPC", "TPC", "TPC" ]

[]

[ "<s>", "void", "M68kAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "}", "</s>" ]

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

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "const", "MCInstrInfo", "*", "MCII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MCInstrDesc", "const", "&", "Desc", "=", "MCII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "auto", "&", "OI", ":", "enumerate", "(", "Desc", ".", "operands", "(", ")", ")", ")", "{", "unsigned", "OpType", "=", "OI", ".", "value", "(", ")", ".", "OperandType", ";", "if", "(", "OpType", ">=", "RISCVOp", "::", "OPERAND_FIRST_RISCV_IMM", "&&", "OpType", "<=", "RISCVOp", "::", "OPERAND_LAST_RISCV_IMM", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OI", ".", "index", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "bool", "Ok", ";", "switch", "(", "OpType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected operand type\"", ")", ";", "case", "RISCVOp", "::", "OPERAND_UIMM4", ":", "Ok", "=", "isUInt", "<", "4", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM5", ":", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM12", ":", "Ok", "=", "isUInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM12M1", ":", "Ok", "=", "isUInt", "<", "12", ">", "(", "Imm", ")", "&&", "(", "Imm", "!=", "0", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM3", ":", "Ok", "=", "isUInt", "<", "3", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM12", ":", "Ok", "=", "isInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM20", ":", "Ok", "=", "isUInt", "<", "20", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMMLOG2XLEN", ":", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", ")", "Ok", "=", "isUInt", "<", "6", ">", "(", "Imm", ")", ";", "else", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "}", "if", "(", "!", "Ok", ")", "{", "ErrInfo", "=", "\"Invalid immediate\"", ";", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "RI5CY", "RISCV", "RISCVOp::OPERAND_FIRST_RISCV_IMM", "RISCVOp::OPERAND_LAST_RISCV_IMM", "\"Unexpected operand type\"", "RISCVOp::OPERAND_UIMM4", "4", "RISCVOp::OPERAND_UIMM5", "5", "RISCVOp::OPERAND_UIMM12", "12", "RISCVOp::OPERAND_UIMM12M1", "12", "0", "RISCVOp::OPERAND_UIMM3", "3", "RISCVOp::OPERAND_SIMM12", "12", "RISCVOp::OPERAND_UIMM20", "20", "RISCVOp::OPERAND_UIMMLOG2XLEN", "6", "5", "\"Invalid immediate\"" ]

[]

[ "<s>", "static", "bool", "isNodeHidden", "(", "const", "T", ",", "const", "agraph", "&", "G", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Do", "not", "print", "nodes", "that", "are", "part", "of", "a", "pi-block", "separately", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "SHUXIInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "\"Invalid Xbranch condition!\"", ")", ";", "SHUXICC", "::", "CondCodes", "CC", "=", "static_cast", "<", "SHUXICC", "::", "CondCodes", ">", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid branch condition!\"", ")", ";", "case", "SHUXICC", "::", "COND_C", ":", "CC", "=", "SHUXICC", "::", "COND_NC", ";", "break", ";", "case", "SHUXICC", "::", "COND_N", ":", "CC", "=", "SHUXICC", "::", "COND_NN", ";", "break", ";", "case", "SHUXICC", "::", "COND_V", ":", "CC", "=", "SHUXICC", "::", "COND_NV", ";", "break", ";", "case", "SHUXICC", "::", "COND_Z", ":", "CC", "=", "SHUXICC", "::", "COND_NZ", ";", "break", ";", "case", "SHUXICC", "::", "COND_GE", ":", "CC", "=", "SHUXICC", "::", "COND_L", ";", "break", ";", "case", "SHUXICC", "::", "COND_NC", ":", "CC", "=", "SHUXICC", "::", "COND_C", ";", "break", ";", "case", "SHUXICC", "::", "COND_NN", ":", "CC", "=", "SHUXICC", "::", "COND_N", ";", "break", ";", "case", "SHUXICC", "::", "COND_NV", ":", "CC", "=", "SHUXICC", "::", "COND_V", ";", "break", ";", "case", "SHUXICC", "::", "COND_NZ", ":", "CC", "=", "SHUXICC", "::", "COND_Z", ";", "break", ";", "case", "SHUXICC", "::", "COND_L", ":", "CC", "=", "SHUXICC", "::", "COND_GE", ";", "break", ";", "}", "Cond", "[", "0", "]", ".", "setImm", "(", "CC", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "SHUXI", "SHUXI", "1", "\"Invalid Xbranch condition!\"", "SHUXICC::CondCodes", "SHUXICC::CondCodes", "0", "\"Invalid branch condition!\"", "SHUXICC::COND_C", "SHUXICC::COND_NC", "SHUXICC::COND_N", "SHUXICC::COND_NN", "SHUXICC::COND_V", "SHUXICC::COND_NV", "SHUXICC::COND_Z", "SHUXICC::COND_NZ", "SHUXICC::COND_GE", "SHUXICC::COND_L", "SHUXICC::COND_NC", "SHUXICC::COND_C", "SHUXICC::COND_NN", "SHUXICC::COND_N", "SHUXICC::COND_NV", "SHUXICC::COND_V", "SHUXICC::COND_NZ", "SHUXICC::COND_Z", "SHUXICC::COND_L", "SHUXICC::COND_GE", "0" ]

[]

[ "<s>", "bool", "check", "(", "function_checker", "&", "c", ")", "const", "override", "{", "return", "c", ".", "require_immediate_range", "(", "2", ",", "0", ",", "7", ")", ";", "}", "</s>" ]

[ "Perform", "semantic", "checks", "on", "the", "call", ".", "Return", "true", "if", "the", "call", "is", "valid", ",", "otherwise", "report", "a", "suitable", "error", "." ]

[ "aarch64", "2", "0", "7" ]

[]

[ "<s>", "static", "bool", "riscv_memmodel_needs_release_fence", "(", "enum", "memmodel", "model", ")", "{", "switch", "(", "model", ")", "{", "case", "MEMMODEL_ACQ_REL", ":", "case", "MEMMODEL_SEQ_CST", ":", "case", "MEMMODEL_SYNC_SEQ_CST", ":", "case", "MEMMODEL_RELEASE", ":", "case", "MEMMODEL_SYNC_RELEASE", ":", "return", "true", ";", "case", "MEMMODEL_ACQUIRE", ":", "case", "MEMMODEL_CONSUME", ":", "case", "MEMMODEL_SYNC_ACQUIRE", ":", "case", "MEMMODEL_RELAXED", ":", "return", "false", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "a", "FENCE", "should", "be", "emitted", "to", "before", "a", "memory", "access", "to", "implement", "the", "release", "portion", "of", "memory", "model", "MODEL", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "LanaiAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IdLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SMLoc", "ErrorLoc", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "case", "Match_Success", ":", "Out", ".", "EmitInstruction", "(", "Inst", ",", "SubtargetInfo", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IdLoc", ",", "\"Instruction use requires option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IdLoc", ",", "\"Unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "ErrorLoc", "=", "IdLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IdLoc", ",", "\"Too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "LanaiOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IdLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"Invalid operand for instruction\"", ")", ";", "}", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"Unknown match type detected!\"", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "\"Instruction use requires option to be enabled\"", "\"Unrecognized instruction mnemonic\"", "0U", "\"Too few operands for instruction\"", "Lanai", "\"Invalid operand for instruction\"", "\"Unknown match type detected!\"" ]

[]

[ "<s>", "static", "void", "s390_dump_pool", "(", "struct", "constant_pool", "*", "pool", ",", "bool", "remote_label", ")", "{", "struct", "constant", "*", "c", ";", "rtx_insn", "*", "insn", "=", "pool", "->", "pool_insn", ";", "size_t", "i", ";", "insn", "=", "emit_insn_after", "(", "gen_pool_section_start", "(", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "insn", "=", "emit_insn_after", "(", "gen_pool_align", "(", "GEN_INT", "(", "8", ")", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "if", "(", "!", "remote_label", ")", "{", "insn", "=", "emit_label_after", "(", "pool", "->", "label", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "NR_C_MODES", ";", "i", "++", ")", "for", "(", "c", "=", "pool", "->", "constants", "[", "i", "]", ";", "c", ";", "c", "=", "c", "->", "next", ")", "{", "rtx", "value", "=", "copy_rtx", "(", "c", "->", "value", ")", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "value", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "value", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_LTREL_OFFSET", "&&", "XVECLEN", "(", "XEXP", "(", "value", ",", "0", ")", ",", "0", ")", "==", "1", ")", "value", "=", "s390_pool_offset", "(", "pool", ",", "XVECEXP", "(", "XEXP", "(", "value", ",", "0", ")", ",", "0", ",", "0", ")", ")", ";", "insn", "=", "emit_label_after", "(", "c", "->", "label", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "value", "=", "gen_rtx_UNSPEC_VOLATILE", "(", "constant_modes", "[", "i", "]", ",", "gen_rtvec", "(", "1", ",", "value", ")", ",", "UNSPECV_POOL_ENTRY", ")", ";", "insn", "=", "emit_insn_after", "(", "value", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "}", "insn", "=", "emit_insn_after", "(", "gen_pool_align", "(", "GEN_INT", "(", "2", ")", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "for", "(", "c", "=", "pool", "->", "execute", ";", "c", ";", "c", "=", "c", "->", "next", ")", "{", "insn", "=", "emit_label_after", "(", "c", "->", "label", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "insn", "=", "emit_insn_after", "(", "s390_execute_target", "(", "c", "->", "value", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "}", "insn", "=", "emit_insn_after", "(", "gen_pool_section_end", "(", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "insn", "=", "emit_barrier_after", "(", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "1", ")", ";", "remove_insn", "(", "pool", "->", "pool_insn", ")", ";", "}", "</s>" ]

[ "Dump", "out", "the", "constants", "in", "POOL", ".", "If", "REMOTE_LABEL", "is", "true", ",", "do", "not", "emit", "the", "pool", "base", "label", "." ]

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

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "resolveFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "rewriteFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "static", "void", "ix86_adjust_counter", "(", "rtx", "countreg", ",", "HOST_WIDE_INT", "value", ")", "{", "if", "(", "GET_MODE", "(", "countreg", ")", "==", "DImode", ")", "emit_insn", "(", "gen_adddi3", "(", "countreg", ",", "countreg", ",", "GEN_INT", "(", "-", "value", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "countreg", ",", "countreg", ",", "GEN_INT", "(", "-", "value", ")", ")", ")", ";", "}", "</s>" ]

[ "Adjust", "COUNTER", "by", "the", "VALUE", "." ]

[ "i386" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getPrefetchDistance", "(", ")", "{", "return", "PrefDist", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "prefetch", "distance", "in", "terms", "of", "instructions", "." ]

[ "PowerPC", "PPC" ]

[]

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

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

[ "Z80", "Z80" ]

[]

[ "<s>", "Instruction", "*", "PPCTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicOrdering", "Ord", ",", "bool", "IsStore", ",", "bool", "IsLoad", ")", "const", "{", "if", "(", "Ord", "==", "SequentiallyConsistent", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_sync", ")", ";", "if", "(", "isAtLeastRelease", "(", "Ord", ")", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_lwsync", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "PowerPC", "PPC", "Intrinsic::ppc_sync", "Intrinsic::ppc_lwsync" ]

[]

[ "<s>", "MSP430Subtarget", "::", "MSP430Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "MSP430GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "\"generic\"" ]

[]

[ "<s>", "bool", "MipsCallEntry", "::", "isAliased", "(", "const", "MachineFrameInfo", "*", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Test", "whether", "the", "memory", "pointed", "to", "by", "this", "PseudoSourceValue", "may", "also", "be", "pointed", "to", "by", "an", "LLVM", "IR", "Value", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "SMLoc", "Z80Operand", "::", "getStartLoc", "(", ")", "const", "{", "return", "this", "->", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "EVT", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "override", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "return", "MVT", "::", "i1", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "NVPTX", "MVT::getVectorVT", "MVT::i1", "MVT::i1" ]

[]

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

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

[ "RI5CY" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "hasBasePointer", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "isSpecialLLVMGlobalArrayToSkip", "(", "GV", ")", "||", "isSpecialLLVMGlobalArrayForStaticInit", "(", "GV", ")", ")", "return", ";", "assert", "(", "!", "GV", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.\"", ")", "&&", "\"Unhandled intrinsic global variable.\"", ")", ";", "ValidateGV", "(", "GV", ")", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "if", "(", "GV", "->", "isDeclarationForLinker", "(", ")", ")", "{", "emitLinkage", "(", "GV", ",", "GVSym", ")", ";", "return", ";", "}", "SectionKind", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ";", "if", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"", ")", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", ",", "TM", ")", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{", "Align", "Alignment", "=", "GV", "->", "getAlign", "(", ")", ".", "getValueOr", "(", "DL", ".", "getPreferredAlign", "(", "GV", ")", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "if", "(", "GVKind", ".", "isBSSLocal", "(", ")", ")", "OutStreamer", "->", "emitXCOFFLocalCommonSymbol", "(", "OutContext", ".", "getOrCreateSymbol", "(", "GVSym", "->", "getSymbolTableName", "(", ")", ")", ",", "Size", ",", "GVSym", ",", "Alignment", ".", "value", "(", ")", ")", ";", "else", "OutStreamer", "->", "emitCommonSymbol", "(", "GVSym", ",", "Size", ",", "Alignment", ".", "value", "(", ")", ")", ";", "return", ";", "}", "MCSymbol", "*", "EmittedInitSym", "=", "GVSym", ";", "emitLinkage", "(", "GV", ",", "EmittedInitSym", ")", ";", "emitAlignment", "(", "getGVAlignment", "(", "GV", ",", "DL", ")", ",", "GV", ")", ";", "if", "(", "!", "TM", ".", "getDataSections", "(", ")", ")", "OutStreamer", "->", "emitLabel", "(", "EmittedInitSym", ")", ";", "llvm", "::", "for_each", "(", "GOAliasMap", "[", "GV", "]", ",", "[", "this", "]", "(", "const", "GlobalAlias", "*", "Alias", ")", "{", "OutStreamer", "->", "emitLabel", "(", "getSymbol", "(", "Alias", ")", ")", ";", "}", ")", ";", "emitGlobalConstant", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getInitializer", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "PowerPC", "PPC", "\"llvm.\"", "\"Unhandled intrinsic global variable.\"", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TrueBlock", ",", "MachineBasicBlock", "*", "&", "FalseBlock", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Condition", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Instruction", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "Instruction", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "Instruction", ";", "if", "(", "Instruction", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "Instruction", ")", ")", "break", ";", "if", "(", "!", "Instruction", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "Instruction", "->", "getOpcode", "(", ")", "==", "Lanai", "::", "BT", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TrueBlock", "=", "Instruction", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "Instruction", ")", "!=", "MBB", ".", "end", "(", ")", ")", "{", "std", "::", "next", "(", "Instruction", ")", "->", "eraseFromParent", "(", ")", ";", "}", "Condition", ".", "clear", "(", ")", ";", "FalseBlock", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "Instruction", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TrueBlock", "=", "nullptr", ";", "Instruction", "->", "eraseFromParent", "(", ")", ";", "Instruction", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TrueBlock", "=", "Instruction", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "unsigned", "Opcode", "=", "Instruction", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "Lanai", "::", "BRCC", ")", "return", "true", ";", "if", "(", "Condition", ".", "empty", "(", ")", ")", "{", "LPCC", "::", "CondCode", "BranchCond", "=", "static_cast", "<", "LPCC", "::", "CondCode", ">", "(", "Instruction", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "FalseBlock", "=", "TrueBlock", ";", "TrueBlock", "=", "Instruction", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Condition", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCond", ")", ")", ";", "continue", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "Lanai", "Lanai", "Lanai::BT", "0", "0", "0", "Lanai::BRCC", "1", "0" ]

[]

[ "<s>", "int", "AArch64TTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Store", ":", "ImmIdx", "=", "0", ";", "break", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "URem", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "ICmp", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "if", "(", "Idx", "==", "1", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Instruction", "::", "Trunc", ":", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Select", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "break", ";", "}", "if", "(", "Idx", "==", "ImmIdx", ")", "{", "int", "NumConstants", "=", "(", "BitSize", "+", "63", ")", "/", "64", ";", "int", "Cost", "=", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "return", "(", "Cost", "<=", "NumConstants", "*", "TTI", "::", "TCC_Basic", ")", "?", "static_cast", "<", "int", ">", "(", "TTI", "::", "TCC_Free", ")", ":", "Cost", ";", "}", "return", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "AArch64", "AArch64", "0", "0U", "0", "2", "0", "1", "1", "63", "64", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "ix86_init_pic_reg", "(", "void", ")", "{", "edge", "entry_edge", ";", "rtx_insn", "*", "seq", ";", "if", "(", "!", "ix86_use_pseudo_pic_reg", "(", ")", ")", "return", ";", "start_sequence", "(", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "ix86_cmodel", "==", "CM_LARGE_PIC", ")", "ix86_init_large_pic_reg", "(", "R11_REG", ")", ";", "else", "emit_insn", "(", "gen_set_got_rex64", "(", "pic_offset_table_rtx", ")", ")", ";", "}", "else", "{", "rtx", "reg", "=", "crtl", "->", "profile", "?", "gen_rtx_REG", "(", "Pmode", ",", "REAL_PIC_OFFSET_TABLE_REGNUM", ")", ":", "pic_offset_table_rtx", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_set_got", "(", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "crtl", "->", "profile", ")", "emit_move_insn", "(", "pic_offset_table_rtx", ",", "reg", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_FLUSH_QUEUE", ",", "NULL_RTX", ")", ";", "}", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "entry_edge", "=", "single_succ_edge", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ";", "insert_insn_on_edge", "(", "seq", ",", "entry_edge", ")", ";", "commit_one_edge_insertion", "(", "entry_edge", ")", ";", "}", "</s>" ]

[ "Create", "and", "initialize", "PIC", "register", "if", "required", "." ]

[ "i386", "1" ]

[]

[ "<s>", "void", "arm_expand_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "bval", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ",", "x", ";", "machine_mode", "mode", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "bval", "=", "operands", "[", "0", "]", ";", "rval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "operands", "[", "5", "]", ";", "mod_s", "=", "operands", "[", "6", "]", ";", "mod_f", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "if", "(", "TARGET_HAVE_LDACQ", "&&", "is_mm_acquire", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_f", ")", ")", ")", "&&", "is_mm_release", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_s", ")", ")", ")", ")", "mod_s", "=", "GEN_INT", "(", "MEMMODEL_ACQ_REL", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "rval", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "oldval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "oldval", ",", "true", ")", ";", "case", "SImode", ":", "if", "(", "!", "arm_add_operand", "(", "oldval", ",", "SImode", ")", ")", "oldval", "=", "force_reg", "(", "SImode", ",", "oldval", ")", ";", "break", ";", "case", "DImode", ":", "if", "(", "!", "cmpdi_operand", "(", "oldval", ",", "mode", ")", ")", "oldval", "=", "force_reg", "(", "mode", ",", "oldval", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "gen", "=", "gen_atomic_compare_and_swapqi_1", ";", "break", ";", "case", "HImode", ":", "gen", "=", "gen_atomic_compare_and_swaphi_1", ";", "break", ";", "case", "SImode", ":", "gen", "=", "gen_atomic_compare_and_swapsi_1", ";", "break", ";", "case", "DImode", ":", "gen", "=", "gen_atomic_compare_and_swapdi_1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ")", ";", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "gen_lowpart", "(", "mode", ",", "rval", ")", ")", ";", "x", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_EQ", "(", "SImode", ",", "x", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "bval", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "compare", "and", "swap", "pattern", "." ]

[ "arm", "0", "1", "2", "3", "4", "5", "6", "7", "1" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "TriCore" ]

[]

[ "<s>", "void", "PIC16AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "RISCVFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "const", "RISCVSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "size_t", "Reg", "=", "0", ";", "Reg", "<", "getNumRegs", "(", ")", ";", "Reg", "++", ")", "{", "if", "(", "STI", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X9", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "C0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "C2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "C3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "C4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "C8", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "C9", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "DDC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VL", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VTYPE", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VXSAT", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VXRM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FRM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FFLAGS", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FCSR", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "0", "RISCV::X0", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8", "RISCV::X9", "RISCV::C0", "RISCV::C2", "RISCV::C3", "RISCV::C4", "RISCV::C8", "RISCV::C9", "RISCV::DDC", "RISCV::VL", "RISCV::VTYPE", "RISCV::VXSAT", "RISCV::VXRM", "RISCV::FRM", "RISCV::FFLAGS", "RISCV::FCSR" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDPtrQRr", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDWPtrQRr", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "0", "MVT::i8", "AVR::STDPtrQRr", "MVT::i16", "AVR::STDWPtrQRr", "\"Cannot store this register into a stack slot!\"", "0" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "SetVector", "<", "Function", "*", ">", "Functions", ";", "AnalysisGetter", "AG", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "Functions", ".", "insert", "(", "&", "F", ")", ";", "}", "CallGraphUpdater", "CGUpdater", ";", "BumpPtrAllocator", "Allocator", ";", "AMDGPUInformationCache", "InfoCache", "(", "M", ",", "AG", ",", "Allocator", ",", "nullptr", ",", "*", "TM", ")", ";", "DenseSet", "<", "const", "char", "*", ">", "Allowed", "(", "{", "&", "AAAMDAttributes", "::", "ID", ",", "&", "AAUniformWorkGroupSize", "::", "ID", ",", "&", "AAAMDFlatWorkGroupSize", "::", "ID", ",", "&", "AACallEdges", "::", "ID", ",", "&", "AAPointerInfo", "::", "ID", "}", ")", ";", "AttributorConfig", "AC", "(", "CGUpdater", ")", ";", "AC", ".", "Allowed", "=", "&", "Allowed", ";", "AC", ".", "IsModulePass", "=", "true", ";", "AC", ".", "DefaultInitializeLiveInternals", "=", "false", ";", "Attributor", "A", "(", "Functions", ",", "InfoCache", ",", "AC", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDAttributes", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "A", ".", "getOrCreateAAFor", "<", "AAUniformWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "if", "(", "!", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", ".", "getCallingConv", "(", ")", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDFlatWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "}", "}", "}", "ChangeStatus", "Change", "=", "A", ".", "run", "(", ")", ";", "return", "Change", "==", "ChangeStatus", "::", "CHANGED", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isEntryFunctionCC" ]

[]

[ "<s>", "gimple", "*", "gimple_folder", "::", "redirect_call", "(", "const", "function_instance", "&", "instance", ")", "{", "registered_function", "*", "rfn", "=", "function_table", "->", "find_with_hash", "(", "instance", ",", "instance", ".", "hash", "(", ")", ")", ";", "if", "(", "!", "rfn", ")", "return", "NULL", ";", "gimple_call_set_fndecl", "(", "call", ",", "rfn", "->", "decl", ")", ";", "return", "call", ";", "}", "</s>" ]

[ "Fold", "the", "call", "to", "a", "call", "to", "INSTANCE", ",", "with", "the", "same", "arguments", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "thumb_far_jump_used_p", "(", "int", "in_prologue", ")", "{", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "far_jump_used", ")", "return", "1", ";", "if", "(", "!", "in_prologue", ")", "{", "if", "(", "regs_ever_live", "[", "ARG_POINTER_REGNUM", "]", ")", "cfun", "->", "machine", "->", "arg_pointer_live", "=", "1", ";", "else", "if", "(", "!", "cfun", "->", "machine", "->", "arg_pointer_live", ")", "return", "0", ";", "}", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_far_jump", "(", "insn", ")", "==", "FAR_JUMP_YES", ")", "{", "cfun", "->", "machine", "->", "far_jump_used", "=", "1", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Returns", "non-zero", "if", "the", "current", "function", "contains", ",", "or", "might", "contain", "a", "far", "jump", "." ]

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

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "ExpandMOVX_RR", "(", "MachineInstrBuilder", "&", "MIB", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "unsigned", "Move", "=", "MVTDst", "==", "MVT", "::", "i16", "?", "M68k", "::", "MOV16rr", ":", "M68k", "::", "MOV32rr", ";", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Dst", "!=", "Src", "&&", "\"You cannot use the same Regs with MOVX_RR\"", ")", ";", "const", "auto", "&", "TRI", "=", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RCDst", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Dst", ",", "MVTDst", ")", ";", "const", "auto", "*", "RCSrc", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Src", ",", "MVTSrc", ")", ";", "assert", "(", "RCDst", "&&", "RCSrc", "&&", "\"Wrong use of MOVX_RR\"", ")", ";", "assert", "(", "RCDst", "!=", "RCSrc", "&&", "\"You cannot use the same Reg Classes with MOVX_RR\"", ")", ";", "unsigned", "SSrc", "=", "RI", ".", "getMatchingMegaReg", "(", "Src", ",", "RCDst", ")", ";", "assert", "(", "SSrc", "&&", "\"No viable MEGA register available\"", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Dst", "==", "SSrc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Remove \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "'\\n'", ")", ";", "MIB", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to MOV\\n\"", ")", ";", "MIB", "->", "setDesc", "(", "get", "(", "Move", ")", ")", ";", "MIB", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "SSrc", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Move", "across", "register", "classes", "without", "extension", "." ]

[ "M68k", "M68k", "MVT::i16", "M68k::MOV16rr", "M68k::MOV32rr", "0", "1", "\"You cannot use the same Regs with MOVX_RR\"", "\"Wrong use of MOVX_RR\"", "\"You cannot use the same Reg Classes with MOVX_RR\"", "\"No viable MEGA register available\"", "\"Remove \"", "\"Expand \"", "\" to MOV\\n\"", "1" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "is64Bit", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "X86GISelActualAccessor", "*", "GISel", "=", "new", "X86GISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "this", ",", "TM", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "createX86InstructionSelector", "(", "TM", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "rs6000_loop_align", "(", "rtx", "label", ")", "{", "basic_block", "bb", ";", "int", "ninsns", ";", "if", "(", "!", "can_override_loop_align", ")", "return", "align_loops_log", ";", "bb", "=", "BLOCK_FOR_INSN", "(", "label", ")", ";", "ninsns", "=", "num_loop_insns", "(", "bb", "->", "loop_father", ")", ";", "if", "(", "ninsns", ">", "4", "&&", "ninsns", "<=", "8", "&&", "(", "rs6000_cpu", "==", "PROCESSOR_POWER4", "||", "rs6000_cpu", "==", "PROCESSOR_POWER5", "||", "rs6000_cpu", "==", "PROCESSOR_POWER6", "||", "rs6000_cpu", "==", "PROCESSOR_POWER7", "||", "rs6000_cpu", "==", "PROCESSOR_POWER8", "||", "rs6000_cpu", "==", "PROCESSOR_POWER9", ")", ")", "return", "5", ";", "else", "return", "align_loops_log", ";", "}", "</s>" ]

[ "Implement", "LOOP_ALIGN", "." ]

[ "rs6000", "4", "8", "5" ]

[]

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

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "VE" ]

[]

[ "<s>", "void", "setReg", "(", "unsigned", "Reg", ")", "{", "assert", "(", "isRegBase", "(", ")", "&&", "\"Invalid base register access!\"", ")", ";", "Base", ".", "Reg", "=", "Reg", ";", "}", "</s>" ]

[ "Assigns", "the", "associated", "register", "for", "this", "edge", "." ]

[ "Mips", "\"Invalid base register access!\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "WebAssemblyAsmTypeCheck", "::", "getGlobal", "(", "SMLoc", "ErrorLoc", ",", "const", "MCInst", "&", "Inst", ",", "wasm", "::", "ValType", "&", "Type", ")", "{", "const", "MCSymbolRefExpr", "*", "SymRef", ";", "if", "(", "getSymRef", "(", "ErrorLoc", ",", "Inst", ",", "SymRef", ")", ")", "return", "true", ";", "auto", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "&", "SymRef", "->", "getSymbol", "(", ")", ")", ";", "switch", "(", "WasmSym", "->", "getType", "(", ")", ".", "getValueOr", "(", "wasm", "::", "WASM_SYMBOL_TYPE_DATA", ")", ")", "{", "case", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ":", "Type", "=", "static_cast", "<", "wasm", "::", "ValType", ">", "(", "WasmSym", "->", "getGlobalType", "(", ")", ".", "Type", ")", ";", "break", ";", "case", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ":", "case", "wasm", "::", "WASM_SYMBOL_TYPE_DATA", ":", "switch", "(", "SymRef", "->", "getKind", "(", ")", ")", "{", "case", "MCSymbolRefExpr", "::", "VK_GOT", ":", "case", "MCSymbolRefExpr", "::", "VK_WASM_GOT_TLS", ":", "Type", "=", "is64", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ";", "return", "false", ";", "default", ":", "break", ";", "}", "LLVM_FALLTHROUGH", ";", "default", ":", "return", "typeError", "(", "ErrorLoc", ",", "StringRef", "(", "\"symbol \"", ")", "+", "WasmSym", "->", "getName", "(", ")", "+", "\" missing .globaltype\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Get", "the", "Init", "value", "of", "the", "specified", "global", "variable", "." ]

[ "WebAssembly", "WebAssembly", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_DATA", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WASM_SYMBOL_TYPE_DATA", "wasm::ValType", "wasm::ValType", "\"symbol \"", "\" missing .globaltype\"" ]

[]

[ "<s>", "tree", "function_resolver", "::", "get_vector_type", "(", "type_suffix_index", "type", ")", "{", "return", "acle_vector_types", "[", "0", "]", "[", "type_suffixes", "[", "type", "]", ".", "vector_type", "]", ";", "}", "</s>" ]

[ "Return", "the", "vector", "type", "associated", "with", "type", "suffix", "TYPE", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "WebAssemblyTargetELFStreamer", "::", "emitIndIdx", "(", "const", "MCExpr", "*", "Value", ")", "{", "llvm_unreachable", "(", "\".indidx encoding not yet implemented\"", ")", ";", "}", "</s>" ]

[ ".indidx" ]

[ "WebAssembly", "WebAssembly", "\".indidx encoding not yet implemented\"" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

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

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

[ "AAP", "AAP" ]

[]

[ "<s>", "bool", "WebAssemblyInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a condition expression\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "Cond", "[", "1", "]", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "Cond", "[", "1", "]", ".", "isReg", "(", ")", "&&", "MRI", ".", "getRegClass", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ")", "==", "&", "WebAssembly", "::", "EXCEPT_REFRegClass", ")", "return", "true", ";", "Cond", ".", "front", "(", ")", "=", "MachineOperand", "::", "CreateImm", "(", "!", "Cond", ".", "front", "(", ")", ".", "getImm", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "WebAssembly", "WebAssembly", "2", "\"Expected a flag and a condition expression\"", "1", "1", "1", "WebAssembly::EXCEPT_REFRegClass" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "hasHardQuad", "=", "Subtarget", "->", "hasHardQuad", "(", ")", ";", "bool", "is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "bool", "isV9", "=", "Subtarget", "->", "isV9", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerF128Load", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerF128Store", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "ADD_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "SUB_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "MUL_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "DIV_F128", ")", ",", "2", ")", ";", "case", "ISD", "::", "FSQRT", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "SQRT_F128", ")", ",", "1", ")", ";", "case", "ISD", "::", "FNEG", ":", "return", "LowerFNEG", "(", "Op", ",", "DAG", ",", "*", "this", ",", "is64Bit", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ",", "isV9", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "return", "LowerF128_FPEXTEND", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "LowerF128_FPROUND", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "ADDC", ":", "case", "ISD", "::", "ADDE", ":", "case", "ISD", "::", "SUBC", ":", "case", "ISD", "::", "SUBE", ":", "return", "LowerADDC_ADDE_SUBC_SUBE", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::VAARG", "ISD::DYNAMIC_STACKALLOC", "ISD::LOAD", "ISD::STORE", "ISD::FADD", "2", "ISD::FSUB", "2", "ISD::FMUL", "2", "ISD::FDIV", "2", "ISD::FSQRT", "1", "ISD::FNEG", "ISD::FABS", "ISD::FP_EXTEND", "ISD::FP_ROUND", "ISD::ADDC", "ISD::ADDE", "ISD::SUBC", "ISD::SUBE" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MIPS DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Mips", "\"MIPS DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "ARCTargetMachine", "::", "ARCTargetMachine", "(", "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", ",", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"", "\"f32:32:32-i64:32-f64:32-a:0:32-n32\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getRelocModel", "(", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Small", ")", ",", "OL", ")", ",", "TLOF", "(", "std", "::", "make_unique", "<", "TargetLoweringObjectFileELF", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "std", "::", "string", "(", "CPU", ")", ",", "std", "::", "string", "(", "FS", ")", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "ARCTargetMachine", "ctor", "-", "Create", "an", "ILP32", "architecture", "model", "." ]

[ "ARC", "ARC", "ARC", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"", "\"f32:32:32-i64:32-f64:32-a:0:32-n32\"" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIdx", ")", ">=", "RC", "->", "getSize", "(", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "RC", "->", "getSize", "(", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Stack slot too small for store\"", "16" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "{", "return", "Kind", "==", "k_Mem", ";", "}", "</s>" ]

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

[ "MSP430" ]

[]

[ "<s>", "BitVector", "JVMRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "resRegs", "(", "getNumRegs", "(", ")", ")", ";", "return", "resRegs", ".", "set", "(", ")", ";", "}", "</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", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "const", "char", "*", "output_cbcond", "(", "rtx", "op", ",", "rtx", "dest", ",", "rtx_insn", "*", "insn", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "const", "char", "*", "cond_str", ",", "*", "tmpl", ";", "int", "far", ",", "emit_nop", ",", "len", ";", "static", "char", "string", "[", "64", "]", ";", "char", "size_char", ";", "len", "=", "get_attr_length", "(", "insn", ")", ";", "far", "=", "len", "==", "4", ";", "emit_nop", "=", "len", "==", "2", ";", "if", "(", "far", ")", "code", "=", "reverse_condition", "(", "code", ")", ";", "size_char", "=", "(", "(", "mode", "==", "SImode", ")", "?", "'w'", ":", "'x'", ")", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "cond_str", "=", "\"ne\"", ";", "break", ";", "case", "EQ", ":", "cond_str", "=", "\"e\"", ";", "break", ";", "case", "GE", ":", "cond_str", "=", "\"ge\"", ";", "break", ";", "case", "GT", ":", "cond_str", "=", "\"g\"", ";", "break", ";", "case", "LE", ":", "cond_str", "=", "\"le\"", ";", "break", ";", "case", "LT", ":", "cond_str", "=", "\"l\"", ";", "break", ";", "case", "GEU", ":", "cond_str", "=", "\"cc\"", ";", "break", ";", "case", "GTU", ":", "cond_str", "=", "\"gu\"", ";", "break", ";", "case", "LEU", ":", "cond_str", "=", "\"leu\"", ";", "break", ";", "case", "LTU", ":", "cond_str", "=", "\"cs\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "far", ")", "{", "int", "veryfar", "=", "1", ",", "delta", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "delta", "=", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "dest", ")", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "delta", ">=", "-", "260000", "&&", "delta", "<", "260000", ")", "veryfar", "=", "0", ";", "}", "if", "(", "veryfar", ")", "tmpl", "=", "\"c%cb%s\\t%%1, %%2, .+16\\n\\tnop\\n\\tb\\t%%3\\n\\tnop\"", ";", "else", "tmpl", "=", "\"c%cb%s\\t%%1, %%2, .+16\\n\\tnop\\n\\tba,pt\\t%%%%xcc, %%3\\n\\tnop\"", ";", "}", "else", "{", "if", "(", "emit_nop", ")", "tmpl", "=", "\"c%cb%s\\t%%1, %%2, %%3\\n\\tnop\"", ";", "else", "tmpl", "=", "\"c%cb%s\\t%%1, %%2, %%3\"", ";", "}", "snprintf", "(", "string", ",", "sizeof", "(", "string", ")", ",", "tmpl", ",", "size_char", ",", "cond_str", ")", ";", "return", "string", ";", "}", "</s>" ]

[ "Return", "the", "string", "to", "output", "a", "compare", "and", "branch", "instruction", "to", "DEST", ".", "DEST", "is", "the", "destination", "insn", "(", "i.e", ".", "the", "label", ")", ",", "INSN", "is", "the", "source", ",", "and", "OP", "is", "the", "conditional", "expression", "." ]

[ "sparc", "0", "64", "4", "2", "\"ne\"", "\"e\"", "\"ge\"", "\"g\"", "\"le\"", "\"l\"", "\"cc\"", "\"gu\"", "\"leu\"", "\"cs\"", "1", "260000", "260000", "0", "\"c%cb%s\\t%%1, %%2, .+16\\n\\tnop\\n\\tb\\t%%3\\n\\tnop\"", "\"c%cb%s\\t%%1, %%2, .+16\\n\\tnop\\n\\tba,pt\\t%%%%xcc, %%3\\n\\tnop\"", "\"c%cb%s\\t%%1, %%2, %%3\\n\\tnop\"", "\"c%cb%s\\t%%1, %%2, %%3\"" ]

[]

[ "<s>", "int", "SystemZTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "int", "Cost", "=", "getVectorIntrinsicInstrCost", "(", "ICA", ".", "getID", "(", ")", ",", "ICA", ".", "getReturnType", "(", ")", ")", ";", "if", "(", "Cost", "!=", "-", "1", ")", "return", "Cost", ";", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitBasicBlockEnd", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "AsmPrinter", "::", "emitBasicBlockEnd", "(", "MBB", ")", ";", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "if", "(", "MBB", ".", "empty", "(", ")", ")", "TS", ".", "emitDirectiveInsn", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "ix86_frame_pointer_required", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "accesses_prev_frame", ")", "return", "true", ";", "if", "(", "SUBTARGET_FRAME_POINTER_REQUIRED", ")", "return", "true", ";", "if", "(", "TARGET_32BIT_MS_ABI", "&&", "cfun", "->", "calls_setjmp", ")", "return", "true", ";", "if", "(", "TARGET_64BIT_MS_ABI", "&&", "get_frame_size", "(", ")", ">", "SEH_MAX_FRAME_SIZE", ")", "return", "true", ";", "if", "(", "TARGET_64BIT_MS_ABI", "&&", "ix86_incoming_stack_boundary", "<", "128", ")", "return", "true", ";", "if", "(", "TARGET_OMIT_LEAF_FRAME_POINTER", "&&", "(", "!", "crtl", "->", "is_leaf", "||", "ix86_current_function_calls_tls_descriptor", ")", ")", "return", "true", ";", "if", "(", "crtl", "->", "profile", "&&", "!", "flag_fentry", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Value", "should", "be", "nonzero", "if", "functions", "must", "have", "frame", "pointers", ".", "Zero", "means", "the", "frame", "pointer", "need", "not", "be", "set", "up", "(", "and", "parms", "may", "be", "accessed", "via", "the", "stack", "pointer", ")", "in", "functions", "that", "seem", "suitable", "." ]

[ "i386", "128" ]

[]

[ "<s>", "void", "set", "(", "size_type", "Idx", ")", "{", "V", ".", "set", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Set", "the", "generated", "scalar", "V", "for", "Def", "and", "the", "given", "Instance", "." ]

[ "X86" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginFunctionImpl", "(", "const", "MachineFunction", "*", "MF", ")", "{", "auto", "*", "SP", "=", "MF", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "auto", "*", "Unit", "=", "SP", "->", "getUnit", "(", ")", ";", "if", "(", "Unit", "->", "getEmissionKind", "(", ")", "==", "DICompileUnit", "::", "NoDebug", ")", "{", "SkipInstruction", "=", "true", ";", "return", ";", "}", "SkipInstruction", "=", "false", ";", "if", "(", "MapDefNotCollected", ")", "{", "processGlobals", "(", "true", ")", ";", "MapDefNotCollected", "=", "false", ";", "}", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "FuncArgNames", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "{", "visitTypeEntry", "(", "DV", "->", "getType", "(", ")", ")", ";", "FuncArgNames", "[", "Arg", "]", "=", "DV", "->", "getName", "(", ")", ";", "}", "}", "}", "uint32_t", "ProtoTypeId", ";", "visitSubroutineType", "(", "SP", "->", "getType", "(", ")", ",", "true", ",", "FuncArgNames", ",", "ProtoTypeId", ")", ";", "auto", "FuncTypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeFunc", ">", "(", "SP", "->", "getName", "(", ")", ",", "ProtoTypeId", ")", ";", "uint32_t", "FuncTypeId", "=", "addType", "(", "std", "::", "move", "(", "FuncTypeEntry", ")", ")", ";", "for", "(", "const", "auto", "&", "TypeEntry", ":", "TypeEntries", ")", "TypeEntry", "->", "completeType", "(", "*", "this", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "BTFFuncInfo", "FuncInfo", ";", "FuncInfo", ".", "Label", "=", "FuncLabel", ";", "FuncInfo", ".", "TypeId", "=", "FuncTypeId", ";", "if", "(", "FuncLabel", "->", "isInSection", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "FuncLabel", "->", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "\"Null section for Function Label\"", ")", ";", "SecNameOff", "=", "addString", "(", "SectionELF", "->", "getSectionName", "(", ")", ")", ";", "}", "else", "{", "SecNameOff", "=", "addString", "(", "\".text\"", ")", ";", "}", "FuncInfoTable", "[", "SecNameOff", "]", ".", "push_back", "(", "FuncInfo", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "debug", "information", "." ]

[ "BPF", "\"Null section for Function Label\"", "\".text\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "int64_t", "NumBytes", ",", "bool", "InEpilogue", ")", "const", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "if", "(", "Offset", ">", "Chunk", ")", "{", "unsigned", "Reg", "=", "0", ";", "if", "(", "isSub", "&&", "!", "isEAXLiveIn", "(", "*", "MBB", ".", "getParent", "(", ")", ")", ")", "Reg", "=", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ";", "else", "Reg", "=", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "unsigned", "Opc", "=", "Is64Bit", "?", "X86", "::", "MOV64ri", ":", "X86", "::", "MOV32ri", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addImm", "(", "Offset", ")", ";", "Opc", "=", "isSub", "?", "getSUBrrOpcode", "(", "Is64Bit", ")", ":", "getADDrrOpcode", "(", "Is64Bit", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addReg", "(", "Reg", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "=", "0", ";", "continue", ";", "}", "}", "uint64_t", "ThisVal", "=", "std", "::", "min", "(", "Offset", ",", "Chunk", ")", ";", "if", "(", "ThisVal", "==", "(", "Is64Bit", "?", "8", ":", "4", ")", ")", "{", "unsigned", "Reg", "=", "isSub", "?", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ":", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "unsigned", "Opc", "=", "isSub", "?", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ":", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "!", "isSub", ")", "|", "getUndefRegState", "(", "isSub", ")", ")", ";", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "continue", ";", "}", "}", "MachineInstrBuilder", "MI", "=", "BuildStackAdjustment", "(", "MBB", ",", "MBBI", ",", "DL", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ",", "InEpilogue", ")", ";", "if", "(", "isSub", ")", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "X86", "X86", "0", "1LL", "31", "1", "0", "X86::RAX", "X86::EAX", "X86::MOV64ri", "X86::MOV32ri", "3", "0", "8", "4", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::POP64r", "X86::POP32r" ]

[]

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

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

[ "SPIRV" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "AVR" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_mode_ok_uncached", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "last_regno", "=", "regno", "+", "rs6000_hard_regno_nregs", "[", "mode", "]", "[", "regno", "]", "-", "1", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "if", "(", "mode", "==", "PTImode", ")", "return", "(", "IN_RANGE", "(", "regno", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", "&&", "IN_RANGE", "(", "last_regno", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", "&&", "(", "(", "regno", "&", "1", ")", "==", "0", ")", ")", ";", "if", "(", "TARGET_VSX", "&&", "VSX_REGNO_P", "(", "regno", ")", "&&", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", "||", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", "||", "mode", "==", "TImode", "||", "(", "TARGET_VADDUQM", "&&", "mode", "==", "V1TImode", ")", ")", ")", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "FP_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "16", "&&", "!", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", ")", "return", "0", ";", "return", "ALTIVEC_REGNO_P", "(", "last_regno", ")", ";", "}", "}", "if", "(", "INT_REGNO_P", "(", "regno", ")", ")", "return", "INT_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", "&&", "(", "mode", "!=", "TDmode", "||", "(", "regno", "%", "2", ")", "==", "0", ")", "&&", "FP_REGNO_P", "(", "last_regno", ")", ")", "return", "1", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "UNITS_PER_FP_WORD", ")", "return", "1", ";", "if", "(", "TARGET_P8_VECTOR", "&&", "(", "mode", "==", "SImode", ")", ")", "return", "1", ";", "if", "(", "TARGET_P9_VECTOR", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", ")", "return", "1", ";", "}", "if", "(", "PAIRED_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_PAIRED_FLOAT", "&&", "PAIRED_VECTOR_MODE", "(", "mode", ")", ")", "return", "1", ";", "return", "0", ";", "}", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "CA_REGNO_P", "(", "regno", ")", ")", "return", "mode", "==", "Pmode", "||", "mode", "==", "SImode", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", "||", "mode", "==", "V1TImode", ")", ";", "return", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Value", "is", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

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

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeFloatZero", "(", "const", "ConstantFP", "*", "CF", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "CF", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "bool", "HasAVX512", "=", "Subtarget", "->", "hasAVX512", "(", ")", ";", "unsigned", "Opc", "=", "0", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "0", ";", "case", "MVT", "::", "f32", ":", "if", "(", "X86ScalarSSEf32", ")", "Opc", "=", "HasAVX512", "?", "X86", "::", "AVX512_FsFLD0SS", ":", "X86", "::", "FsFLD0SS", ";", "else", "Opc", "=", "X86", "::", "LD_Fp032", ";", "break", ";", "case", "MVT", "::", "f64", ":", "if", "(", "X86ScalarSSEf64", ")", "Opc", "=", "HasAVX512", "?", "X86", "::", "AVX512_FsFLD0SD", ":", "X86", "::", "FsFLD0SD", ";", "else", "Opc", "=", "X86", "::", "LD_Fp064", ";", "break", ";", "case", "MVT", "::", "f80", ":", "return", "0", ";", "}", "unsigned", "ResultReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ";", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "the", "floating-point", "constant", "+0.0", "in", "a", "register", "using", "target-", "specific", "logic", "." ]

[ "X86", "X86", "0", "0", "0", "MVT::f32", "X86", "X86::AVX512_FsFLD0SS", "X86::FsFLD0SS", "X86::LD_Fp032", "MVT::f64", "X86", "X86::AVX512_FsFLD0SD", "X86::FsFLD0SD", "X86::LD_Fp064", "MVT::f80", "0" ]

[]

[ "<s>", "void", "tilegx_compute_pcrel_plt_address", "(", "rtx", "result", ",", "rtx", "addr", ")", "{", "rtx", "text_label_symbol", "=", "tilegx_text_label_symbol", "(", ")", ";", "rtx", "text_label_rtx", "=", "tilegx_text_label_rtx", "(", ")", ";", "rtx", "temp", ",", "temp2", ",", "temp3", ";", "temp", "=", "create_temp_reg_if_possible", "(", "Pmode", ",", "result", ")", ";", "temp2", "=", "create_temp_reg_if_possible", "(", "Pmode", ",", "result", ")", ";", "if", "(", "TARGET_32BIT", ")", "{", "emit_insn", "(", "gen_mov_plt_pcrel_step1_32bit", "(", "temp", ",", "addr", ",", "text_label_symbol", ")", ")", ";", "emit_insn", "(", "gen_mov_plt_pcrel_step2_32bit", "(", "temp2", ",", "temp", ",", "addr", ",", "text_label_symbol", ")", ")", ";", "emit_move_insn", "(", "result", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "temp2", ",", "text_label_rtx", ")", ")", ";", "}", "else", "{", "temp3", "=", "create_temp_reg_if_possible", "(", "Pmode", ",", "result", ")", ";", "emit_insn", "(", "gen_mov_plt_pcrel_step1", "(", "temp", ",", "addr", ",", "text_label_symbol", ")", ")", ";", "emit_insn", "(", "gen_mov_plt_pcrel_step2", "(", "temp2", ",", "temp", ",", "addr", ",", "text_label_symbol", ")", ")", ";", "emit_insn", "(", "gen_mov_plt_pcrel_step3", "(", "temp3", ",", "temp2", ",", "addr", ",", "text_label_symbol", ")", ")", ";", "emit_move_insn", "(", "result", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "temp3", ",", "text_label_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Returns", "a", "register", "that", "points", "to", "the", "plt", "entry", "of", "ADDR", ",", "a", "symbolic", "address", ",", "by", "computing", "its", "address", "relative", "to", "tilegx_text_label_symbol", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isKnownNeverNaNForTargetNode", "(", "SDValue", "Op", ",", "const", "SelectionDAG", "&", "DAG", ",", "bool", "SNaN", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "AMDGPUISD", "::", "CLAMP", ")", "{", "if", "(", "Subtarget", "->", "enableDX10Clamp", "(", ")", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "return", "AMDGPUTargetLowering", "::", "isKnownNeverNaNForTargetNode", "(", "Op", ",", "DAG", ",", "SNaN", ",", "Depth", ")", ";", "}", "</s>" ]

[ "If", "SNaN", "is", "false", ",", "." ]

[ "AMDGPU", "SI", "AMDGPUISD::CLAMP", "0", "1", "AMDGPU" ]

[]

[ "<s>", "DecodeStatus", "PatmosDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint32_t", "Insn", ";", "Size", "=", "0", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Region", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "bool", "isBundled", "=", "(", "Insn", ">>", "31", ")", ";", "Insn", "&=", "~", "(", "1", "<<", "31", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTablePatmos32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "{", "if", "(", "!", "isBundled", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint32_t", "InsnL", ";", "Result", "=", "readInstruction32", "(", "Region", ",", "Address", "+", "4", ",", "Size", ",", "InsnL", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "{", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint64_t", "Insn64", "=", "(", "1ULL", "<<", "63", ")", "|", "(", "(", "uint64_t", ")", "Insn", "<<", "32", ")", "|", "InsnL", ";", "Result", "=", "decodeInstruction", "(", "DecoderTablePatmos64", ",", "instr", ",", "Insn64", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "isBundled", "=", "false", ";", "}", "instr", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "isBundled", ")", ")", ";", "adjustSignedImm", "(", "instr", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "0", "31", "1", "31", "Patmos", "4", "1ULL", "63", "32", "Patmos" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SLLW", ":", "case", "RISCVISD", "::", "SRAW", ":", "case", "RISCVISD", "::", "SRLW", ":", "case", "RISCVISD", "::", "DIVW", ":", "case", "RISCVISD", "::", "DIVUW", ":", "case", "RISCVISD", "::", "REMUW", ":", "case", "RISCVISD", "::", "ROLW", ":", "case", "RISCVISD", "::", "RORW", ":", "case", "RISCVISD", "::", "GREVIW", ":", "case", "RISCVISD", "::", "GORCIW", ":", "case", "RISCVISD", "::", "FSLW", ":", "case", "RISCVISD", "::", "FSRW", ":", "return", "33", ";", "case", "RISCVISD", "::", "VMV_X_S", ":", "if", "(", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", ">", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "1", ";", "return", "Subtarget", ".", "getXLen", "(", ")", "-", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", "+", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "RI5CY", "RISCV", "RISCVISD::SLLW", "RISCVISD::SRAW", "RISCVISD::SRLW", "RISCVISD::DIVW", "RISCVISD::DIVUW", "RISCVISD::REMUW", "RISCVISD::ROLW", "RISCVISD::RORW", "RISCVISD::GREVIW", "RISCVISD::GORCIW", "RISCVISD::FSLW", "RISCVISD::FSRW", "33", "RISCVISD::VMV_X_S", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "void", "M68kInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DstReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ";", "if", "(", "M68k", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "M68k", "::", "MOV32rr", ";", "else", "if", "(", "M68k", "::", "XR16RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "M68k", "::", "MOV16rr", ";", "else", "if", "(", "M68k", "::", "DR8RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "M68k", "::", "MOV8dd", ";", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "MachineInstrBuilder", "MIB", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "MI", ")", ";", "if", "(", "M68k", "::", "DR8RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "M68k", "::", "XR16RegClass", ".", "contains", "(", "DstReg", ")", ")", "Opc", "=", "M68k", "::", "MOVXd16d8", ";", "else", "if", "(", "M68k", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ")", ")", "Opc", "=", "M68k", "::", "MOVXd32d8", ";", "}", "else", "if", "(", "M68k", "::", "XR16RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "M68k", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ")", ")", "Opc", "=", "M68k", "::", "MOVXd32d16", ";", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "bool", "FromCCR", "=", "SrcReg", "==", "M68k", "::", "CCR", ";", "bool", "FromSR", "=", "SrcReg", "==", "M68k", "::", "SR", ";", "bool", "ToCCR", "=", "DstReg", "==", "M68k", "::", "CCR", ";", "bool", "ToSR", "=", "DstReg", "==", "M68k", "::", "SR", ";", "if", "(", "FromCCR", ")", "{", "assert", "(", "M68k", "::", "DR8RegClass", ".", "contains", "(", "DstReg", ")", "&&", "\"Need DR8 register to copy CCR\"", ")", ";", "Opc", "=", "M68k", "::", "MOV8dc", ";", "}", "else", "if", "(", "ToCCR", ")", "{", "assert", "(", "M68k", "::", "DR8RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Need DR8 register to copy CCR\"", ")", ";", "Opc", "=", "M68k", "::", "MOV8cd", ";", "}", "else", "if", "(", "FromSR", "||", "ToSR", ")", "llvm_unreachable", "(", "\"Cannot emit SR copy instruction\"", ")", ";", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cannot copy \"", "<<", "RI", ".", "getName", "(", "SrcReg", ")", "<<", "\" to \"", "<<", "RI", ".", "getName", "(", "DstReg", ")", "<<", "'\\n'", ")", ";", "llvm_unreachable", "(", "\"Cannot emit physreg copy instruction\"", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "M68k", "M68k", "0", "M68k::XR32RegClass", "M68k::MOV32rr", "M68k::XR16RegClass", "M68k::MOV16rr", "M68k::DR8RegClass", "M68k::MOV8dd", "M68k::DR8RegClass", "M68k::XR16RegClass", "M68k::MOVXd16d8", "M68k::XR32RegClass", "M68k::MOVXd32d8", "M68k::XR16RegClass", "M68k::XR32RegClass", "M68k::MOVXd32d16", "M68k::CCR", "M68k::SR", "M68k::CCR", "M68k::SR", "M68k::DR8RegClass", "\"Need DR8 register to copy CCR\"", "M68k::MOV8dc", "M68k::DR8RegClass", "\"Need DR8 register to copy CCR\"", "M68k::MOV8cd", "\"Cannot emit SR copy instruction\"", "\"Cannot copy \"", "\" to \"", "\"Cannot emit physreg copy instruction\"" ]

[]

[ "<s>", "static", "bool", "operands_ok_ldd_std", "(", "rtx", "rt", ",", "rtx", "rt2", ",", "HOST_WIDE_INT", "offset", ")", "{", "unsigned", "int", "t", ",", "t2", ";", "if", "(", "!", "reload_completed", ")", "return", "true", ";", "if", "(", "!", "(", "SMALL_INT_RANGE", "(", "offset", ",", "(", "GET_MODE_SIZE", "(", "DImode", ")", "-", "1", ")", "&", "(", "~", "0x03", ")", ",", "(", "offset", "&", "(", "GET_MODE_SIZE", "(", "DImode", ")", "-", "1", ")", "&", "3", "?", "0", ":", "-", "(", "-", "GET_MODE_SIZE", "(", "DImode", ")", "|", "(", "~", "0x03", ")", ")", ">>", "1", ")", ")", ")", ")", "return", "false", ";", "t", "=", "REGNO", "(", "rt", ")", ";", "t2", "=", "REGNO", "(", "rt2", ")", ";", "if", "(", "(", "t2", "==", "PCL_REG", ")", "||", "(", "t", "%", "2", "!=", "0", ")", "||", "(", "t2", "!=", "t", "+", "1", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "operands", "are", "valid", "for", "use", "in", "an", "LDD/STD", "instruction", ".", "Assumes", "that", "RT", ",", "and", "RT2", "are", "REG", ".", "This", "is", "guaranteed", "by", "the", "patterns", ".", "Assumes", "that", "the", "address", "in", "the", "base", "register", "RN", "is", "word", "aligned", ".", "Pattern", "guarantees", "that", "both", "memory", "accesses", "use", "the", "same", "base", "register", ",", "the", "offsets", "are", "constants", "within", "the", "range", ",", "and", "the", "gap", "between", "the", "offsets", "is", "4", ".", "If", "reload", "complete", "then", "check", "that", "registers", "are", "legal", "." ]

[ "arc", "1", "0x03", "1", "3", "0", "0x03", "1", "2", "0", "1" ]

[]

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

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

[ "TPC" ]

[]

[ "<s>", "const", "TargetFrameLowering", "::", "SpillSlot", "*", "AMDGPUFrameLowering", "::", "getCalleeSavedSpillSlots", "(", "unsigned", "&", "NumEntries", ")", "const", "{", "NumEntries", "=", "0", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "getCalleeSavedSpillSlots", "-", "This", "method", "returns", "a", "pointer", "to", "an", "array", "of", "pairs", ",", "that", "contains", "an", "entry", "for", "each", "callee", "saved", "register", "that", "must", "be", "spilled", "to", "a", "particular", "stack", "location", "if", "it", "is", "spilled", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "TARGET_ELF", "&&", "tls_referenced_p", "(", "x", ")", ")", "return", "false", ";", "return", "(", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_VECTOR", ")", "||", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "||", "(", "TARGET_POWERPC64", "&&", "mode", "==", "DImode", ")", "||", "easy_fp_constant", "(", "x", ",", "mode", ")", "||", "easy_vector_constant", "(", "x", ",", "mode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", ".", "On", "the", "RS/6000", ",", "all", "integer", "constants", "are", "acceptable", ",", "most", "wo", "n't", "be", "valid", "for", "particular", "insns", ",", "though", ".", "Only", "easy", "FP", "constants", "are", "acceptable", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "rtx_insn", "*", "s390_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", "outputs", ",", "vec", "<", "rtx", ">", "&", "inputs", ",", "vec", "<", "machine_mode", ">", "&", "input_modes", ",", "vec", "<", "const", "char", "*", ">", "&", "constraints", ",", "vec", "<", "rtx", ">", "&", ",", "HARD_REG_SET", "&", ")", "{", "if", "(", "!", "TARGET_VXE", ")", "return", "NULL", ";", "rtx_insn", "*", "after_md_seq", "=", "NULL", ",", "*", "after_md_end", "=", "NULL", ";", "unsigned", "ninputs", "=", "inputs", ".", "length", "(", ")", ";", "unsigned", "noutputs", "=", "outputs", ".", "length", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "noutputs", ";", "i", "++", ")", "{", "if", "(", "GET_MODE", "(", "outputs", "[", "i", "]", ")", "!=", "TFmode", ")", "continue", ";", "const", "char", "*", "constraint", "=", "constraints", "[", "i", "]", ";", "bool", "allows_mem", ",", "allows_reg", ",", "is_inout", ";", "bool", "ok", "=", "parse_output_constraint", "(", "&", "constraint", ",", "i", ",", "ninputs", ",", "noutputs", ",", "&", "allows_mem", ",", "&", "allows_reg", ",", "&", "is_inout", ")", ";", "gcc_assert", "(", "ok", ")", ";", "if", "(", "!", "f_constraint_p", "(", "constraint", ")", ")", "continue", ";", "gcc_assert", "(", "allows_reg", ")", ";", "gcc_assert", "(", "!", "is_inout", ")", ";", "rtx", "fprx2", "=", "gen_reg_rtx", "(", "FPRX2mode", ")", ";", "push_to_sequence2", "(", "after_md_seq", ",", "after_md_end", ")", ";", "emit_insn", "(", "gen_fprx2_to_tf", "(", "outputs", "[", "i", "]", ",", "fprx2", ")", ")", ";", "after_md_seq", "=", "get_insns", "(", ")", ";", "after_md_end", "=", "get_last_insn", "(", ")", ";", "end_sequence", "(", ")", ";", "outputs", "[", "i", "]", "=", "fprx2", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "ninputs", ";", "i", "++", ")", "{", "if", "(", "GET_MODE", "(", "inputs", "[", "i", "]", ")", "!=", "TFmode", ")", "continue", ";", "const", "char", "*", "constraint", "=", "constraints", "[", "noutputs", "+", "i", "]", ";", "bool", "allows_mem", ",", "allows_reg", ";", "bool", "ok", "=", "parse_input_constraint", "(", "&", "constraint", ",", "i", ",", "ninputs", ",", "noutputs", ",", "0", ",", "constraints", ".", "address", "(", ")", ",", "&", "allows_mem", ",", "&", "allows_reg", ")", ";", "gcc_assert", "(", "ok", ")", ";", "if", "(", "!", "f_constraint_p", "(", "constraint", ")", ")", "continue", ";", "gcc_assert", "(", "allows_reg", ")", ";", "rtx", "fprx2", "=", "gen_reg_rtx", "(", "FPRX2mode", ")", ";", "emit_insn", "(", "gen_tf_to_fprx2", "(", "fprx2", ",", "inputs", "[", "i", "]", ")", ")", ";", "inputs", "[", "i", "]", "=", "fprx2", ";", "input_modes", "[", "i", "]", "=", "FPRX2mode", ";", "}", "return", "after_md_seq", ";", "}", "</s>" ]

[ "Implement", "TARGET_MD_ASM_ADJUST", "hook", "in", "order", "to", "fix", "up", "``", "f", "''", "constraints", "when", "long", "doubles", "are", "stored", "in", "vector", "registers", "." ]

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

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "X86RegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "X86", "::", "GR64RegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "X86", "X86", "X86", "X86::GR64RegClass", "X86::GR64RegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ",", "const", "TargetRegisterInfo", "*", "TRI", "=", "nullptr", ")", "const", "{", "if", "(", "isReg", "(", ")", ")", "{", "OS", "<<", "\"register: \"", "<<", "printReg", "(", "Contents", ".", "R", ".", "Reg", ",", "TRI", ",", "Contents", ".", "R", ".", "Sub", ")", "<<", "'\\n'", ";", "}", "if", "(", "isImm", "(", ")", ")", "{", "OS", "<<", "\"immediate: \"", "<<", "Contents", ".", "ImmVal", "<<", "'\\n'", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "RI5CY", "\"register: \"", "\"immediate: \"" ]

[]

[ "<s>", "bool", "prepare_move_operands", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "1", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "0", "]", ",", "Pmode", ")", ")", "operands", "[", "0", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "0", "]", ")", ";", "else", "if", "(", "mode", "==", "SImode", "&&", "flag_pic", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "{", "emit_pic_move", "(", "operands", ",", "SImode", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "!=", "MEM", "&&", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "move_dest_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "{", "rtx", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "addr", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "if", "(", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "pat", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Prepare", "operands", "for", "a", "move", "define_expand", "in", "MODE", "." ]

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

[]

[ "<s>", "scalar_chain", "::", "scalar_chain", "(", "enum", "machine_mode", "smode_", ",", "enum", "machine_mode", "vmode_", ")", "{", "smode", "=", "smode_", ";", "vmode", "=", "vmode_", ";", "chain_id", "=", "++", "max_id", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Created a new instruction chain #%d\\n\"", ",", "chain_id", ")", ";", "bitmap_obstack_initialize", "(", "NULL", ")", ";", "insns", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "defs", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "defs_conv", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "insns_conv", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "queue", "=", "NULL", ";", "n_sse_to_integer", "=", "0", ";", "n_integer_to_sse", "=", "0", ";", "max_visits", "=", "x86_stv_max_visits", ";", "}", "</s>" ]

[ "Initialize", "new", "chain", "." ]

[ "i386", "\"Created a new instruction chain #%d\\n\"", "0", "0" ]

[]

[ "<s>", "bool", "cris_bdap_index_p", "(", "const_rtx", "x", ",", "bool", "strict", ")", "{", "return", "(", "(", "MEM_P", "(", "x", ")", "&&", "GET_MODE", "(", "x", ")", "==", "SImode", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTEND", "&&", "MEM_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "(", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "HImode", "||", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "QImode", ")", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ",", "strict", ")", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "X", "is", "a", "valid", "(", "register", ")", "index", "for", "BDAP", ",", "i.e", ".", "[", "Rs", "]", ".S", "or", "[", "Rs+", "]", ".S", "." ]

[ "cris", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createAMDGPUConvertToISAPass", "(", "*", "TM", ")", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createR600VectorRegMerger", "(", "*", "TM", ")", ")", ";", "}", "else", "{", "addPass", "(", "createSIFixSGPRCopiesPass", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'a'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", "{", "printSymbolOperand", "(", "MO", ")", ";", "return", "false", ";", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'('", ";", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "O", "<<", "')'", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'c'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", "printSymbolOperand", "(", "MO", ")", ";", "else", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "case", "'A'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'*'", ";", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ")", ";", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "case", "'P'", ":", "print_pcrel_imm", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "case", "'n'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "-", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "O", "<<", "'-'", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

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

[]

[ "<s>", "SparcTargetLowering", "::", "ConstraintType", "SparcTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'f'", ":", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "return", "C_Other", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "Sparc", "Sparc", "Sparc", "1", "0" ]

[]

[ "<s>", "void", "Z80oldFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "0", ")", ";", "if", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ">", "0x80", ")", "{", "RS", "->", "addScavengingFrameIndex", "(", "MFI", ".", "CreateStackObject", "(", "SlotSize", ",", "1", ",", "false", ")", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "Z80old", "Z80old", "0", "0x80", "1" ]

[]

[ "<s>", "static", "void", "cris_asm_output_mi_thunk", "(", "FILE", "*", "stream", ",", "tree", "thunkdecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "tree", "funcdecl", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunkdecl", ")", ")", ";", "assemble_start_function", "(", "thunkdecl", ",", "fnname", ")", ";", "final_start_function", "(", "emit_barrier", "(", ")", ",", "stream", ",", "1", ")", ";", "if", "(", "delta", ">", "0", ")", "fprintf", "(", "stream", ",", "\"\\tadd%s \"", "HOST_WIDE_INT_PRINT_DEC", "\",$%s\\n\"", ",", "ADDITIVE_SIZE_MODIFIER", "(", "delta", ")", ",", "delta", ",", "reg_names", "[", "CRIS_FIRST_ARG_REG", "]", ")", ";", "else", "if", "(", "delta", "<", "0", ")", "fprintf", "(", "stream", ",", "\"\\tsub%s \"", "HOST_WIDE_INT_PRINT_DEC", "\",$%s\\n\"", ",", "ADDITIVE_SIZE_MODIFIER", "(", "-", "delta", ")", ",", "-", "delta", ",", "reg_names", "[", "CRIS_FIRST_ARG_REG", "]", ")", ";", "fprintf", "(", "stream", ",", "\"\\tjump \"", ")", ";", "assemble_name", "(", "stream", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "funcdecl", ")", ",", "0", ")", ",", "0", ")", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunkdecl", ",", "fnname", ")", ";", "}", "</s>" ]

[ "The", "ASM_OUTPUT_MI_THUNK", "worker", "." ]

[ "cris", "1", "0", "\"\\tadd%s \"", "\",$%s\\n\"", "0", "\"\\tsub%s \"", "\",$%s\\n\"", "\"\\tjump \"", "0", "0", "\"\\n\"" ]

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "return", "(", "IsGlobalInSmallSectionImpl", "(", "GV", ",", "TM", ")", "&&", "(", "Kind", ".", "isDataRel", "(", ")", "||", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "ia64_split_tmode_move", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "in", "[", "2", "]", ",", "out", "[", "2", "]", ",", "insn", ";", "rtx", "fixup", "[", "2", "]", ";", "bool", "dead", "=", "false", ";", "bool", "reversed", "=", "false", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "MEM", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "rtx", "base", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "while", "(", "GET_CODE", "(", "base", ")", "!=", "REG", ")", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "if", "(", "REGNO", "(", "base", ")", "==", "REGNO", "(", "operands", "[", "0", "]", ")", ")", "reversed", "=", "true", ";", "if", "(", "refers_to_regno_p", "(", "REGNO", "(", "operands", "[", "0", "]", ")", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "2", ",", "base", ",", "0", ")", ")", "dead", "=", "true", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "REG", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", "reversed", "=", "true", ";", "fixup", "[", "0", "]", "=", "ia64_split_tmode", "(", "in", ",", "operands", "[", "1", "]", ",", "reversed", ",", "dead", ")", ";", "fixup", "[", "1", "]", "=", "ia64_split_tmode", "(", "out", ",", "operands", "[", "0", "]", ",", "reversed", ",", "dead", ")", ";", "if", "(", "GET_CODE", "(", "EXP", ")", "==", "MEM", "\\", "&&", "(", "GET_CODE", "(", "XEXP", "(", "EXP", ",", "0", ")", ")", "==", "POST_MODIFY", "\\", "||", "GET_CODE", "(", "XEXP", "(", "EXP", ",", "0", ")", ")", "==", "POST_INC", "\\", "||", "GET_CODE", "(", "XEXP", "(", "EXP", ",", "0", ")", ")", "==", "POST_DEC", ")", ")", "\\", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "XEXP", "(", "XEXP", "(", "EXP", ",", "0", ")", ",", "0", ")", ")", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "out", "[", "0", "]", ",", "in", "[", "0", "]", ")", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "in", "[", "0", "]", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "out", "[", "0", "]", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "out", "[", "1", "]", ",", "in", "[", "1", "]", ")", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "in", "[", "1", "]", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "out", "[", "1", "]", ")", ";", "if", "(", "fixup", "[", "0", "]", ")", "emit_insn", "(", "fixup", "[", "0", "]", ")", ";", "if", "(", "fixup", "[", "1", "]", ")", "emit_insn", "(", "fixup", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Split", "a", "TImode", "or", "TFmode", "move", "instruction", "after", "reload", ".", "This", "is", "used", "by", "*", "movtf_internal", "and", "*", "movti_internal", "." ]

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

[]

[ "<s>", "const", "MCFixup", "*", "RISCVMCExpr", "::", "getPCRelHiFixup", "(", "const", "MCFragment", "*", "*", "DFOut", ")", "const", "{", "MCValue", "AUIPCLoc", ";", "if", "(", "!", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "AUIPCLoc", ",", "nullptr", ",", "nullptr", ")", ")", "return", "nullptr", ";", "const", "MCSymbolRefExpr", "*", "AUIPCSRE", "=", "AUIPCLoc", ".", "getSymA", "(", ")", ";", "if", "(", "!", "AUIPCSRE", ")", "return", "nullptr", ";", "const", "MCSymbol", "*", "AUIPCSymbol", "=", "&", "AUIPCSRE", "->", "getSymbol", "(", ")", ";", "const", "auto", "*", "DF", "=", "dyn_cast_or_null", "<", "MCDataFragment", ">", "(", "AUIPCSymbol", "->", "getFragment", "(", ")", ")", ";", "if", "(", "!", "DF", ")", "return", "nullptr", ";", "uint64_t", "Offset", "=", "AUIPCSymbol", "->", "getOffset", "(", ")", ";", "if", "(", "DF", "->", "getContents", "(", ")", ".", "size", "(", ")", "==", "Offset", ")", "{", "DF", "=", "dyn_cast_or_null", "<", "MCDataFragment", ">", "(", "DF", "->", "getNextNode", "(", ")", ")", ";", "if", "(", "!", "DF", ")", "return", "nullptr", ";", "Offset", "=", "0", ";", "}", "for", "(", "const", "MCFixup", "&", "F", ":", "DF", "->", "getFixups", "(", ")", ")", "{", "if", "(", "F", ".", "getOffset", "(", ")", "!=", "Offset", ")", "continue", ";", "switch", "(", "(", "unsigned", ")", "F", ".", "getKind", "(", ")", ")", "{", "default", ":", "continue", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_hi20", ":", "case", "RISCV", "::", "fixup_riscv_pcrel_hi20", ":", "if", "(", "DFOut", ")", "*", "DFOut", "=", "DF", ";", "return", "&", "F", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Get", "the", "corresponding", "PC-relative", "HI", "fixup", "that", "a", "VK_RISCV_PCREL_LO", "points", "to", ",", "and", "optionally", "the", "fragment", "containing", "it", "." ]

[ "RI5CY", "RISCV", "0", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_tls_got_hi20", "RISCV::fixup_riscv_tls_gd_hi20", "RISCV::fixup_riscv_pcrel_hi20" ]

[]

[ "<s>", "bool", "GCNSubtarget", "::", "zeroesHigh16BitsOfDest", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "V_CVT_F16_F32_e32", ":", "case", "AMDGPU", "::", "V_CVT_F16_F32_e64", ":", "case", "AMDGPU", "::", "V_CVT_F16_U16_e32", ":", "case", "AMDGPU", "::", "V_CVT_F16_U16_e64", ":", "case", "AMDGPU", "::", "V_CVT_F16_I16_e32", ":", "case", "AMDGPU", "::", "V_CVT_F16_I16_e64", ":", "case", "AMDGPU", "::", "V_RCP_F16_e64", ":", "case", "AMDGPU", "::", "V_RCP_F16_e32", ":", "case", "AMDGPU", "::", "V_RSQ_F16_e64", ":", "case", "AMDGPU", "::", "V_RSQ_F16_e32", ":", "case", "AMDGPU", "::", "V_SQRT_F16_e64", ":", "case", "AMDGPU", "::", "V_SQRT_F16_e32", ":", "case", "AMDGPU", "::", "V_LOG_F16_e64", ":", "case", "AMDGPU", "::", "V_LOG_F16_e32", ":", "case", "AMDGPU", "::", "V_EXP_F16_e64", ":", "case", "AMDGPU", "::", "V_EXP_F16_e32", ":", "case", "AMDGPU", "::", "V_SIN_F16_e64", ":", "case", "AMDGPU", "::", "V_SIN_F16_e32", ":", "case", "AMDGPU", "::", "V_COS_F16_e64", ":", "case", "AMDGPU", "::", "V_COS_F16_e32", ":", "case", "AMDGPU", "::", "V_FLOOR_F16_e64", ":", "case", "AMDGPU", "::", "V_FLOOR_F16_e32", ":", "case", "AMDGPU", "::", "V_CEIL_F16_e64", ":", "case", "AMDGPU", "::", "V_CEIL_F16_e32", ":", "case", "AMDGPU", "::", "V_TRUNC_F16_e64", ":", "case", "AMDGPU", "::", "V_TRUNC_F16_e32", ":", "case", "AMDGPU", "::", "V_RNDNE_F16_e64", ":", "case", "AMDGPU", "::", "V_RNDNE_F16_e32", ":", "case", "AMDGPU", "::", "V_FRACT_F16_e64", ":", "case", "AMDGPU", "::", "V_FRACT_F16_e32", ":", "case", "AMDGPU", "::", "V_FREXP_MANT_F16_e64", ":", "case", "AMDGPU", "::", "V_FREXP_MANT_F16_e32", ":", "case", "AMDGPU", "::", "V_FREXP_EXP_I16_F16_e64", ":", "case", "AMDGPU", "::", "V_FREXP_EXP_I16_F16_e32", ":", "case", "AMDGPU", "::", "V_LDEXP_F16_e64", ":", "case", "AMDGPU", "::", "V_LDEXP_F16_e32", ":", "case", "AMDGPU", "::", "V_LSHLREV_B16_e64", ":", "case", "AMDGPU", "::", "V_LSHLREV_B16_e32", ":", "case", "AMDGPU", "::", "V_LSHRREV_B16_e64", ":", "case", "AMDGPU", "::", "V_LSHRREV_B16_e32", ":", "case", "AMDGPU", "::", "V_ASHRREV_I16_e64", ":", "case", "AMDGPU", "::", "V_ASHRREV_I16_e32", ":", "case", "AMDGPU", "::", "V_ADD_U16_e64", ":", "case", "AMDGPU", "::", "V_ADD_U16_e32", ":", "case", "AMDGPU", "::", "V_SUB_U16_e64", ":", "case", "AMDGPU", "::", "V_SUB_U16_e32", ":", "case", "AMDGPU", "::", "V_SUBREV_U16_e64", ":", "case", "AMDGPU", "::", "V_SUBREV_U16_e32", ":", "case", "AMDGPU", "::", "V_MUL_LO_U16_e64", ":", "case", "AMDGPU", "::", "V_MUL_LO_U16_e32", ":", "case", "AMDGPU", "::", "V_ADD_F16_e64", ":", "case", "AMDGPU", "::", "V_ADD_F16_e32", ":", "case", "AMDGPU", "::", "V_SUB_F16_e64", ":", "case", "AMDGPU", "::", "V_SUB_F16_e32", ":", "case", "AMDGPU", "::", "V_SUBREV_F16_e64", ":", "case", "AMDGPU", "::", "V_SUBREV_F16_e32", ":", "case", "AMDGPU", "::", "V_MUL_F16_e64", ":", "case", "AMDGPU", "::", "V_MUL_F16_e32", ":", "case", "AMDGPU", "::", "V_MAX_F16_e64", ":", "case", "AMDGPU", "::", "V_MAX_F16_e32", ":", "case", "AMDGPU", "::", "V_MIN_F16_e64", ":", "case", "AMDGPU", "::", "V_MIN_F16_e32", ":", "case", "AMDGPU", "::", "V_MAX_U16_e64", ":", "case", "AMDGPU", "::", "V_MAX_U16_e32", ":", "case", "AMDGPU", "::", "V_MIN_U16_e64", ":", "case", "AMDGPU", "::", "V_MIN_U16_e32", ":", "case", "AMDGPU", "::", "V_MAX_I16_e64", ":", "case", "AMDGPU", "::", "V_MAX_I16_e32", ":", "case", "AMDGPU", "::", "V_MIN_I16_e64", ":", "case", "AMDGPU", "::", "V_MIN_I16_e32", ":", "case", "AMDGPU", "::", "V_MAD_F16_e64", ":", "case", "AMDGPU", "::", "V_MAD_U16_e64", ":", "case", "AMDGPU", "::", "V_MAD_I16_e64", ":", "case", "AMDGPU", "::", "V_FMA_F16_e64", ":", "case", "AMDGPU", "::", "V_DIV_FIXUP_F16_e64", ":", "return", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "GFX9", ";", "case", "AMDGPU", "::", "V_MADAK_F16", ":", "case", "AMDGPU", "::", "V_MADMK_F16", ":", "case", "AMDGPU", "::", "V_MAC_F16_e64", ":", "case", "AMDGPU", "::", "V_MAC_F16_e32", ":", "case", "AMDGPU", "::", "V_FMAMK_F16", ":", "case", "AMDGPU", "::", "V_FMAAK_F16", ":", "case", "AMDGPU", "::", "V_FMAC_F16_e64", ":", "case", "AMDGPU", "::", "V_FMAC_F16_e32", ":", "return", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "case", "AMDGPU", "::", "V_MAD_MIXLO_F16", ":", "case", "AMDGPU", "::", "V_MAD_MIXHI_F16", ":", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Returns", "if", "the", "result", "of", "this", "instruction", "with", "a", "16-bit", "result", "returned", "in", "a", "32-bit", "register", "implicitly", "zeroes", "the", "high", "16-bits", ",", "rather", "than", "preserve", "the", "original", "value", "." ]

[ "AMDGPU", "AMDGPU::V_CVT_F16_F32_e32", "AMDGPU::V_CVT_F16_F32_e64", "AMDGPU::V_CVT_F16_U16_e32", "AMDGPU::V_CVT_F16_U16_e64", "AMDGPU::V_CVT_F16_I16_e32", "AMDGPU::V_CVT_F16_I16_e64", "AMDGPU::V_RCP_F16_e64", "AMDGPU::V_RCP_F16_e32", "AMDGPU::V_RSQ_F16_e64", "AMDGPU::V_RSQ_F16_e32", "AMDGPU::V_SQRT_F16_e64", "AMDGPU::V_SQRT_F16_e32", "AMDGPU::V_LOG_F16_e64", "AMDGPU::V_LOG_F16_e32", "AMDGPU::V_EXP_F16_e64", "AMDGPU::V_EXP_F16_e32", "AMDGPU::V_SIN_F16_e64", "AMDGPU::V_SIN_F16_e32", "AMDGPU::V_COS_F16_e64", "AMDGPU::V_COS_F16_e32", "AMDGPU::V_FLOOR_F16_e64", "AMDGPU::V_FLOOR_F16_e32", "AMDGPU::V_CEIL_F16_e64", "AMDGPU::V_CEIL_F16_e32", "AMDGPU::V_TRUNC_F16_e64", "AMDGPU::V_TRUNC_F16_e32", "AMDGPU::V_RNDNE_F16_e64", "AMDGPU::V_RNDNE_F16_e32", "AMDGPU::V_FRACT_F16_e64", "AMDGPU::V_FRACT_F16_e32", "AMDGPU::V_FREXP_MANT_F16_e64", "AMDGPU::V_FREXP_MANT_F16_e32", "AMDGPU::V_FREXP_EXP_I16_F16_e64", "AMDGPU::V_FREXP_EXP_I16_F16_e32", "AMDGPU::V_LDEXP_F16_e64", "AMDGPU::V_LDEXP_F16_e32", "AMDGPU::V_LSHLREV_B16_e64", "AMDGPU::V_LSHLREV_B16_e32", "AMDGPU::V_LSHRREV_B16_e64", "AMDGPU::V_LSHRREV_B16_e32", "AMDGPU::V_ASHRREV_I16_e64", "AMDGPU::V_ASHRREV_I16_e32", "AMDGPU::V_ADD_U16_e64", "AMDGPU::V_ADD_U16_e32", "AMDGPU::V_SUB_U16_e64", "AMDGPU::V_SUB_U16_e32", "AMDGPU::V_SUBREV_U16_e64", "AMDGPU::V_SUBREV_U16_e32", "AMDGPU::V_MUL_LO_U16_e64", "AMDGPU::V_MUL_LO_U16_e32", "AMDGPU::V_ADD_F16_e64", "AMDGPU::V_ADD_F16_e32", "AMDGPU::V_SUB_F16_e64", "AMDGPU::V_SUB_F16_e32", "AMDGPU::V_SUBREV_F16_e64", "AMDGPU::V_SUBREV_F16_e32", "AMDGPU::V_MUL_F16_e64", "AMDGPU::V_MUL_F16_e32", "AMDGPU::V_MAX_F16_e64", "AMDGPU::V_MAX_F16_e32", "AMDGPU::V_MIN_F16_e64", "AMDGPU::V_MIN_F16_e32", "AMDGPU::V_MAX_U16_e64", "AMDGPU::V_MAX_U16_e32", "AMDGPU::V_MIN_U16_e64", "AMDGPU::V_MIN_U16_e32", "AMDGPU::V_MAX_I16_e64", "AMDGPU::V_MAX_I16_e32", "AMDGPU::V_MIN_I16_e64", "AMDGPU::V_MIN_I16_e32", "AMDGPU::V_MAD_F16_e64", "AMDGPU::V_MAD_U16_e64", "AMDGPU::V_MAD_I16_e64", "AMDGPU::V_FMA_F16_e64", "AMDGPU::V_DIV_FIXUP_F16_e64", "AMDGPU", "AMDGPU::V_MADAK_F16", "AMDGPU::V_MADMK_F16", "AMDGPU::V_MAC_F16_e64", "AMDGPU::V_MAC_F16_e32", "AMDGPU::V_FMAMK_F16", "AMDGPU::V_FMAAK_F16", "AMDGPU::V_FMAC_F16_e64", "AMDGPU::V_FMAC_F16_e32", "AMDGPU", "AMDGPU::V_MAD_MIXLO_F16", "AMDGPU::V_MAD_MIXHI_F16" ]

[]