Datasets:

---

docz1105

/

ComBack

like 10

[ "<s>", "static", "void", "vr4130_true_reg_dependence_p_1", "(", "rtx", "x", ",", "rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "rtx", "*", "insn_ptr", "=", "data", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "*", "insn_ptr", "!=", "0", "&&", "reg_referenced_p", "(", "x", ",", "PATTERN", "(", "*", "insn_ptr", ")", ")", ")", "*", "insn_ptr", "=", "0", ";", "}", "</s>" ]

[ "A", "note_stores", "callback", "used", "by", "vr4130_true_reg_dependence_p", ".", "DATA", "points", "to", "an", "rtx", "that", "is", "initially", "an", "instruction", ".", "Nullify", "the", "rtx", "if", "the", "instruction", "uses", "the", "value", "of", "register", "X", "." ]

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

[]

[ "<s>", "bool", "ix86_bnd_prefixed_insn_p", "(", "rtx", "insn", ")", "{", "if", "(", "insn", "&&", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "call", "=", "get_call_rtx_from", "(", "insn", ")", ";", "if", "(", "call", ")", "return", "CALL_EXPR_WITH_BOUNDS_P", "(", "call", ")", ";", "}", "return", "chkp_function_instrumented_p", "(", "current_function_decl", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "control", "tansfer", "instruction", "INSN", "should", "be", "encoded", "with", "bnd", "prefix", ".", "If", "insn", "is", "NULL", "then", "return", "1", "when", "control", "transfer", "instructions", "should", "be", "prefixed", "with", "bnd", "by", "default", "for", "current", "function", "." ]

[ "i386" ]

[]

[ "<s>", "void", "mips_expand_conditional_move", "(", "rtx", "*", "operands", ")", "{", "rtx", "cond", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ";", "mips_emit_compare", "(", "&", "code", ",", "&", "op0", ",", "&", "op1", ",", "true", ")", ";", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "op1", ")", ";", "if", "(", "ISA_HAS_SEL", "&&", "INTEGRAL_MODE_P", "(", "GET_MODE", "(", "operands", "[", "2", "]", ")", ")", "&&", "register_operand", "(", "operands", "[", "2", "]", ",", "VOIDmode", ")", "&&", "register_operand", "(", "operands", "[", "3", "]", ",", "VOIDmode", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "temp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "temp2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cond", ",", "operands", "[", "2", "]", ",", "const0_rtx", ")", ")", ")", ";", "cond", "=", "gen_rtx_fmt_ee", "(", "(", "code", "==", "EQ", ")", "?", "NE", ":", "EQ", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp2", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cond", ",", "operands", "[", "3", "]", ",", "const0_rtx", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "mode", ",", "temp", ",", "temp2", ")", ")", ")", ";", "}", "else", "{", "if", "(", "FLOAT_MODE_P", "(", "GET_MODE", "(", "operands", "[", "2", "]", ")", ")", "&&", "!", "ISA_HAS_SEL", ")", "{", "operands", "[", "2", "]", "=", "force_reg", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "2", "]", ")", ";", "operands", "[", "3", "]", "=", "force_reg", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "3", "]", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "cond", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Perform", "the", "comparison", "in", "OPERANDS", "[", "1", "]", ".", "Move", "OPERANDS", "[", "2", "]", "into", "OPERANDS", "[", "0", "]", "if", "the", "condition", "holds", ",", "otherwise", "move", "OPERANDS", "[", "3", "]", "into", "OPERANDS", "[", "0", "]", "." ]

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

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "PowerPC", "MVT::i32" ]

[]

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

[ "Return", "true", "if", "the", "target", "has", "a", "vector", "blend", "instruction", "." ]

[ "X86" ]

[]

[ "<s>", "static", "rtx", "find_next_cycle_insn", "(", "rtx", "insn", ",", "int", "clock", ")", "{", "rtx", "t", "=", "insn", ";", "if", "(", "GET_MODE", "(", "t", ")", "==", "TImode", ")", "t", "=", "next_real_insn", "(", "t", ")", ";", "while", "(", "t", "&&", "GET_MODE", "(", "t", ")", "!=", "TImode", ")", "t", "=", "next_real_insn", "(", "t", ")", ";", "if", "(", "t", "&&", "insn_get_clock", "(", "t", ")", "==", "clock", ")", "return", "t", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Scan", "forwards", "from", "INSN", "until", "we", "find", "the", "next", "insn", "that", "has", "mode", "TImode", "(", "indicating", "it", "starts", "a", "new", "cycle", ")", ",", "and", "occurs", "in", "cycle", "CLOCK", ".", "Return", "it", "if", "we", "find", "such", "an", "insn", ",", "NULL_RTX", "otherwise", "." ]

[ "c6x" ]

[]

[ "<s>", "void", "ARMCodeEmitter", "::", "emitInstruction", "(", "const", "MachineInstr", "&", "MI", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JIT: \"", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "\":\\t\"", "<<", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "true", ")", ";", "NumEmitted", "++", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "{", "default", ":", "{", "llvm_unreachable", "(", "\"Unhandled instruction encoding format!\"", ")", ";", "break", ";", "}", "case", "ARMII", "::", "Pseudo", ":", "emitPseudoInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "DPFrm", ":", "case", "ARMII", "::", "DPSoRegFrm", ":", "emitDataProcessingInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdFrm", ":", "case", "ARMII", "::", "StFrm", ":", "emitLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdMiscFrm", ":", "case", "ARMII", "::", "StMiscFrm", ":", "emitMiscLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdStMulFrm", ":", "emitLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "MulFrm", ":", "emitMulFrmInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ExtFrm", ":", "emitExtendInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ArithMiscFrm", ":", "emitMiscArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrFrm", ":", "emitBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrMiscFrm", ":", "emitMiscBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPUnaryFrm", ":", "case", "ARMII", "::", "VFPBinaryFrm", ":", "emitVFPArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPConv1Frm", ":", "case", "ARMII", "::", "VFPConv2Frm", ":", "case", "ARMII", "::", "VFPConv3Frm", ":", "case", "ARMII", "::", "VFPConv4Frm", ":", "case", "ARMII", "::", "VFPConv5Frm", ":", "emitVFPConversionInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStFrm", ":", "emitVFPLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStMulFrm", ":", "emitVFPLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPMiscFrm", ":", "emitMiscInstruction", "(", "MI", ")", ";", "break", ";", "}", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT: \"", "\":\\t\"", "ARMII::FormMask", "\"Unhandled instruction encoding format!\"", "ARMII::Pseudo", "ARMII::DPFrm", "ARMII::DPSoRegFrm", "ARMII::LdFrm", "ARMII::StFrm", "ARMII::LdMiscFrm", "ARMII::StMiscFrm", "ARMII::LdStMulFrm", "ARMII::MulFrm", "ARMII::ExtFrm", "ARMII::ArithMiscFrm", "ARMII::BrFrm", "ARMII::BrMiscFrm", "ARMII::VFPUnaryFrm", "ARMII::VFPBinaryFrm", "ARMII::VFPConv1Frm", "ARMII::VFPConv2Frm", "ARMII::VFPConv3Frm", "ARMII::VFPConv4Frm", "ARMII::VFPConv5Frm", "ARMII::VFPLdStFrm", "ARMII::VFPLdStMulFrm", "ARMII::VFPMiscFrm" ]

[]

[ "<s>", "static", "int", "mips_issue_rate", "(", "void", ")", "{", "switch", "(", "mips_tune", ")", "{", "case", "PROCESSOR_74KC", ":", "case", "PROCESSOR_74KF2_1", ":", "case", "PROCESSOR_74KF1_1", ":", "case", "PROCESSOR_74KF3_2", ":", "case", "PROCESSOR_R10000", ":", "return", "4", ";", "case", "PROCESSOR_20KC", ":", "case", "PROCESSOR_R4130", ":", "case", "PROCESSOR_R5400", ":", "case", "PROCESSOR_R5500", ":", "case", "PROCESSOR_R5900", ":", "case", "PROCESSOR_R7000", ":", "case", "PROCESSOR_R9000", ":", "case", "PROCESSOR_OCTEON", ":", "case", "PROCESSOR_OCTEON2", ":", "case", "PROCESSOR_OCTEON3", ":", "case", "PROCESSOR_I6400", ":", "case", "PROCESSOR_GS264E", ":", "return", "2", ";", "case", "PROCESSOR_SB1", ":", "case", "PROCESSOR_SB1A", ":", "return", "3", ";", "case", "PROCESSOR_LOONGSON_2E", ":", "case", "PROCESSOR_LOONGSON_2F", ":", "case", "PROCESSOR_GS464", ":", "case", "PROCESSOR_GS464E", ":", "case", "PROCESSOR_P5600", ":", "case", "PROCESSOR_P6600", ":", "return", "4", ";", "case", "PROCESSOR_XLP", ":", "return", "(", "reload_completed", "?", "4", ":", "3", ")", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "that", "can", "be", "issued", "per", "cycle", "." ]

[ "mips", "4", "2", "3", "4", "4", "3", "1" ]

[]

[ "<s>", "unsigned", "HexagonMCCodeEmitter", "::", "getMachineOpValue", "(", "MCInst", "const", "&", "MI", ",", "MCOperand", "const", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "assert", "(", "!", "MO", ".", "isImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isSubInstruction", "(", "MI", ")", ")", "return", "HexagonMCInstrInfo", "::", "getDuplexRegisterNumbering", "(", "Reg", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "A2_tfrrcr", ":", "case", "Hexagon", "::", "A2_tfrcrr", ":", "if", "(", "Reg", "==", "Hexagon", "::", "M0", ")", "Reg", "=", "Hexagon", "::", "C6", ";", "if", "(", "Reg", "==", "Hexagon", "::", "M1", ")", "Reg", "=", "Hexagon", "::", "C7", ";", "}", "return", "MCT", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "}", "return", "getExprOpValue", "(", "MI", ",", "MO", ",", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::A2_tfrrcr", "Hexagon::A2_tfrcrr", "Hexagon::M0", "Hexagon::C6", "Hexagon::M1", "Hexagon::C7" ]

[]

[ "<s>", "rtx", "sh_find_equiv_gbr_addr", "(", "rtx_insn", "*", "insn", ",", "rtx", "mem", ")", "{", "if", "(", "!", "MEM_P", "(", "mem", ")", "||", "gbr_address_mem", "(", "mem", ",", "GET_MODE", "(", "mem", ")", ")", ")", "return", "NULL_RTX", ";", "if", "(", "side_effects_p", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ")", "return", "NULL_RTX", ";", "if", "(", "df", "==", "NULL", ")", "return", "NULL_RTX", ";", "base_reg_disp", "gbr_disp", "=", "sh_find_base_reg_disp", "(", "insn", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "if", "(", "gbr_disp", ".", "is_reg", "(", ")", "&&", "REGNO", "(", "gbr_disp", ".", "reg", "(", ")", ")", "==", "GBR_REG", ")", "{", "for", "(", "df_ref", "d", "=", "DF_REG_DEF_CHAIN", "(", "GBR_REG", ")", ";", "d", "!=", "NULL", ";", "d", "=", "DF_REF_NEXT_REG", "(", "d", ")", ")", "{", "if", "(", "CALL_P", "(", "DF_REF_INSN", "(", "d", ")", ")", ")", "{", "if", "(", "REGNO_REG_SET_P", "(", "regs_invalidated_by_call_regset", ",", "GBR_REG", ")", ")", "return", "NULL_RTX", ";", "else", "continue", ";", "}", "else", "return", "NULL_RTX", ";", "}", "rtx", "disp", "=", "GEN_INT", "(", "gbr_disp", ".", "disp", "(", ")", ")", ";", "if", "(", "gbr_displacement", "(", "disp", ",", "GET_MODE", "(", "mem", ")", ")", ")", "return", "gen_rtx_PLUS", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "GBR_REG", ")", ",", "disp", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Given", "an", "insn", "and", "a", "memory", "operand", ",", "try", "to", "find", "an", "equivalent", "GBR", "based", "memory", "address", "and", "return", "the", "corresponding", "new", "memory", "address", ".", "Return", "NULL_RTX", "if", "not", "found", "." ]

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

[]

[ "<s>", "bool", "HexagonOptimizeSZextends", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "F", ".", "getAttributes", "(", ")", ".", "hasParamAttr", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", ".", "getType", "(", ")", ")", ")", "{", "for", "(", "Use", "&", "U", ":", "llvm", "::", "make_early_inc_range", "(", "Arg", ".", "uses", "(", ")", ")", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "U", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "U", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "&", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "&", "F", ".", "getEntryBlock", "(", ")", ".", "front", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "}", "++", "Idx", ";", "}", "for", "(", "auto", "&", "B", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "B", ")", "{", "BinaryOperator", "*", "Ashr", "=", "dyn_cast", "<", "BinaryOperator", ">", "(", "&", "I", ")", ";", "if", "(", "!", "(", "Ashr", "&&", "Ashr", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "AShr", ")", ")", "continue", ";", "Value", "*", "AshrOp1", "=", "Ashr", "->", "getOperand", "(", "1", ")", ";", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "AshrOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "Instruction", "*", "Shl", "=", "dyn_cast", "<", "Instruction", ">", "(", "Ashr", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "!", "(", "Shl", "&&", "Shl", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", ")", "continue", ";", "Value", "*", "Intr", "=", "Shl", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "ShlOp1", "=", "Shl", "->", "getOperand", "(", "1", ")", ";", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "ShlOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "if", "(", "IntrinsicInst", "*", "I", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "Intr", ")", ")", "{", "if", "(", "!", "intrinsicAlreadySextended", "(", "I", "->", "getIntrinsicID", "(", ")", ")", ")", "continue", ";", "for", "(", "auto", "UI", "=", "Ashr", "->", "user_begin", "(", ")", ",", "UE", "=", "Ashr", "->", "user_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "const", "Use", "&", "TheUse", "=", "UI", ".", "getUse", "(", ")", ";", "if", "(", "Instruction", "*", "J", "=", "dyn_cast", "<", "Instruction", ">", "(", "TheUse", ".", "getUser", "(", ")", ")", ")", "{", "J", "->", "replaceUsesOfWith", "(", "Ashr", ",", "I", ")", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "1", "16", "0", "0", "1", "16" ]

[]

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

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

[ "NVPTX", "NVPTX", "0" ]

[]

[ "<s>", "const", "char", "*", "R600ClauseMergePass", "::", "getPassName", "(", ")", "const", "{", "return", "\"R600 Merge Clause Markers Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"R600 Merge Clause Markers Pass\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "WebAssemblyRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "WebAssembly", "WebAssembly", "0" ]

[]

[ "<s>", "unsigned", "int", "rs6000_data_alignment", "(", "tree", "type", ",", "unsigned", "int", "align", ",", "enum", "data_align", "how", ")", "{", "if", "(", "how", "!=", "align_opt", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "align", "<", "128", ")", "align", "=", "128", ";", "}", "if", "(", "how", "!=", "align_abi", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", "&&", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "QImode", ")", "{", "if", "(", "align", "<", "BITS_PER_WORD", ")", "align", "=", "BITS_PER_WORD", ";", "}", "}", "return", "align", ";", "}", "</s>" ]

[ "Return", "alignment", "of", "TYPE", ".", "Existing", "alignment", "is", "ALIGN", ".", "HOW", "selects", "whether", "the", "alignment", "is", "abi", "mandated", ",", "optional", ",", "or", "both", "abi", "and", "optional", "alignment", "." ]

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

[]

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

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

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

[]

[ "<s>", "rtx", "ix86_build_signbit_mask", "(", "machine_mode", "mode", ",", "bool", "vect", ",", "bool", "invert", ")", "{", "machine_mode", "vec_mode", ",", "imode", ";", "wide_int", "w", ";", "rtx", "mask", ",", "v", ";", "switch", "(", "mode", ")", "{", "case", "E_V16SImode", ":", "case", "E_V16SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V4SImode", ":", "case", "E_V8SFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2SFmode", ":", "vec_mode", "=", "mode", ";", "imode", "=", "SImode", ";", "break", ";", "case", "E_V8DImode", ":", "case", "E_V4DImode", ":", "case", "E_V2DImode", ":", "case", "E_V8DFmode", ":", "case", "E_V4DFmode", ":", "case", "E_V2DFmode", ":", "vec_mode", "=", "mode", ";", "imode", "=", "DImode", ";", "break", ";", "case", "E_TImode", ":", "case", "E_TFmode", ":", "vec_mode", "=", "VOIDmode", ";", "imode", "=", "TImode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "w", "=", "wi", "::", "set_bit_in_zero", "(", "GET_MODE_BITSIZE", "(", "inner_mode", ")", "-", "1", ",", "GET_MODE_BITSIZE", "(", "inner_mode", ")", ")", ";", "if", "(", "invert", ")", "w", "=", "wi", "::", "bit_not", "(", "w", ")", ";", "mask", "=", "immed_wide_int_const", "(", "w", ",", "imode", ")", ";", "mask", "=", "gen_lowpart", "(", "inner_mode", ",", "mask", ")", ";", "if", "(", "vec_mode", "==", "VOIDmode", ")", "return", "force_reg", "(", "inner_mode", ",", "mask", ")", ";", "v", "=", "ix86_build_const_vector", "(", "vec_mode", ",", "vect", ",", "mask", ")", ";", "return", "force_reg", "(", "vec_mode", ",", "v", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_fp_absneg_operator", "and", "copysign", "expanders", ".", "Create", "a", "mask", "for", "the", "sign", "bit", "in", "MODE", "for", "an", "SSE", "register", ".", "If", "VECT", "is", "true", ",", "then", "replicate", "the", "mask", "for", "all", "elements", "of", "the", "vector", "register", ".", "If", "INVERT", "is", "true", ",", "then", "create", "a", "mask", "excluding", "the", "sign", "bit", "." ]

[ "i386", "1" ]

[]

[ "<s>", "static", "rtx", "mips_unspec_call", "(", "rtx", "reg", ",", "rtx", "symbol", ")", "{", "rtvec", "vec", ";", "vec", "=", "gen_rtvec", "(", "3", ",", "reg", ",", "symbol", ",", "gen_rtx_REG", "(", "SImode", ",", "GOT_VERSION_REGNUM", ")", ")", ";", "return", "gen_rtx_UNSPEC", "(", "Pmode", ",", "vec", ",", "UNSPEC_LOAD_CALL", ")", ";", "}", "</s>" ]

[ "Return", "the", "RHS", "of", "a", "load_call", "<", "mode", ">", "insn", "." ]

[ "mips", "3" ]

[]

[ "<s>", "static", "reg_class_t", "loongarch_spill_class", "(", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_SPILL_CLASS", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "sh_split_movrt_negc_to_movt_xor", "(", "rtx_insn", "*", "curr_insn", ",", "rtx", "operands", "[", "]", ")", "{", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "return", "false", ";", "set_of_reg", "t_before_negc", "=", "sh_find_set_of_reg", "(", "get_t_reg_rtx", "(", ")", ",", "curr_insn", ",", "prev_nonnote_insn_bb", ")", ";", "set_of_reg", "t_after_negc", "=", "sh_find_set_of_reg", "(", "get_t_reg_rtx", "(", ")", ",", "curr_insn", ",", "next_nonnote_insn_bb", ")", ";", "if", "(", "t_before_negc", ".", "set_rtx", "!=", "NULL_RTX", "&&", "t_after_negc", ".", "set_rtx", "!=", "NULL_RTX", "&&", "rtx_equal_p", "(", "t_before_negc", ".", "set_rtx", ",", "t_after_negc", ".", "set_rtx", ")", "&&", "!", "reg_used_between_p", "(", "get_t_reg_rtx", "(", ")", ",", "curr_insn", ",", "t_after_negc", ".", "insn", ")", "&&", "!", "sh_insn_operands_modified_between_p", "(", "t_before_negc", ".", "insn", ",", "t_before_negc", ".", "insn", ",", "t_after_negc", ".", "insn", ")", "&&", "!", "modified_between_p", "(", "get_t_reg_rtx", "(", ")", ",", "curr_insn", ",", "t_after_negc", ".", "insn", ")", "&&", "!", "sh_unspec_insn_p", "(", "t_after_negc", ".", "insn", ")", "&&", "!", "volatile_insn_p", "(", "PATTERN", "(", "t_after_negc", ".", "insn", ")", ")", "&&", "!", "side_effects_p", "(", "PATTERN", "(", "t_after_negc", ".", "insn", ")", ")", "&&", "!", "may_trap_or_fault_p", "(", "PATTERN", "(", "t_after_negc", ".", "insn", ")", ")", ")", "{", "emit_insn", "(", "gen_movrt_xor", "(", "operands", "[", "0", "]", ",", "get_t_reg_rtx", "(", ")", ")", ")", ";", "set_insn_deleted", "(", "t_after_negc", ".", "insn", ")", ";", "return", "true", ";", "}", "else", "return", "false", ";", "}", "</s>" ]

[ "Given", "the", "current", "insn", ",", "which", "is", "assumed", "to", "be", "a", "movrt_negc", "insn", ",", "try", "to", "figure", "out", "whether", "it", "should", "be", "converted", "into", "a", "movt-xor", "sequence", "in", "the", "movrt_negc", "splitter", ".", "Returns", "true", "if", "insns", "have", "been", "modified", "and", "the", "splitter", "has", "succeeded", "." ]

[ "sh", "0" ]

[]

[ "<s>", "static", "void", "vector_init_bshuffle", "(", "rtx", "target", ",", "rtx", "elt", ",", "machine_mode", "mode", ",", "machine_mode", "inner_mode", ")", "{", "rtx", "t1", ",", "final_insn", ",", "sel", ";", "int", "bmask", ";", "t1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "elt", "=", "convert_modes", "(", "SImode", ",", "inner_mode", ",", "elt", ",", "true", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "SImode", ",", "t1", ")", ",", "elt", ")", ";", "switch", "(", "mode", ")", "{", "case", "V2SImode", ":", "final_insn", "=", "gen_bshufflev2si_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x45674567", ";", "break", ";", "case", "V4HImode", ":", "final_insn", "=", "gen_bshufflev4hi_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x67676767", ";", "break", ";", "case", "V8QImode", ":", "final_insn", "=", "gen_bshufflev8qi_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x77777777", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sel", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "bmask", ")", ")", ";", "emit_insn", "(", "gen_bmasksi_vis", "(", "gen_reg_rtx", "(", "SImode", ")", ",", "sel", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "final_insn", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "sparc_expand_vector_init", ".", "Emit", "code", "to", "initialize", "all", "fields", "of", "TARGET", "to", "ELT", "by", "means", "of", "VIS2", "BSHUFFLE", "insn", ".", "MODE", "and", "INNER_MODE", "are", "the", "modes", "describing", "TARGET", "." ]

[ "sparc", "0x45674567", "0x67676767", "0x77777777" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DebugHandlerBase", "::", "beginInstruction", "(", "MI", ")", ";", "if", "(", "SkipInstruction", "||", "MI", "->", "isMetaInstruction", "(", ")", "||", "MI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "return", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "{", "unsigned", "NumDefs", "=", "0", ";", "for", "(", ";", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "isDef", "(", ")", ";", "++", "NumDefs", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "getSymbolName", "(", ")", ";", "if", "(", "AsmStr", "[", "0", "]", "==", "0", ")", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "{", "processGlobalValue", "(", "MI", "->", "getOperand", "(", "1", ")", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_ALU32_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_SHIFT", ")", "{", "processGlobalValue", "(", "MI", "->", "getOperand", "(", "3", ")", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "JAL", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "processFuncPrototypes", "(", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "}", "}", "if", "(", "!", "CurMI", ")", "return", ";", "const", "DebugLoc", "&", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DL", "||", "PrevInstLoc", "==", "DL", ")", "{", "if", "(", "LineInfoGenerated", "==", "false", ")", "{", "auto", "*", "S", "=", "MI", "->", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "constructLineInfo", "(", "S", ",", "FuncLabel", ",", "S", "->", "getLine", "(", ")", ",", "0", ")", ";", "LineInfoGenerated", "=", "true", ";", "}", "return", ";", "}", "MCSymbol", "*", "LineSym", "=", "OS", ".", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "OS", ".", "emitLabel", "(", "LineSym", ")", ";", "auto", "SP", "=", "DL", ".", "get", "(", ")", "->", "getScope", "(", ")", "->", "getSubprogram", "(", ")", ";", "constructLineInfo", "(", "SP", ",", "LineSym", ",", "DL", ".", "getLine", "(", ")", ",", "DL", ".", "getCol", "(", ")", ")", ";", "LineInfoGenerated", "=", "true", ";", "PrevInstLoc", "=", "DL", ";", "}", "</s>" ]

[ "Process", "beginning", "of", "an", "instruction", "." ]

[ "BPF", "0", "0", "0", "BPF::LD_imm64", "1", "BPF::CORE_MEM", "BPF::CORE_ALU32_MEM", "BPF::CORE_SHIFT", "3", "BPF::JAL", "0", "0" ]

[]

[ "<s>", "bool", "shouldBuildLookupTablesForConstant", "(", "Constant", "*", "C", ")", "const", "{", "if", "(", "ST", "->", "isROPI", "(", ")", "||", "ST", "->", "isRWPI", "(", ")", ")", "return", "!", "C", "->", "needsRelocation", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "switches", "should", "be", "turned", "into", "lookup", "tables", "containing", "this", "constant", "value", "for", "the", "target", "." ]

[ "ARM" ]

[]

[ "<s>", "TargetPassConfig", "*", "TLCS900TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "TLCS900PassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "TLCS900", "TLCS900", "TLCS900" ]

[]

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

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

[ "TLCS900", "TLCS900", "TLCS900", "TLCS900", "2", "0", "1", "TLCS900::PUSH16r" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "unsigned", "Size", "=", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", "!=", "128", ")", "return", "false", ";", "return", "!", "isOpSuitableForLDPSTP", "(", "SI", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "store", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "into", "." ]

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MOSTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MOS", "::", "Imag16RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MOS", "::", "Imag8RegClass", ")", ";", "case", "'R'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MOS", "::", "GPRRegClass", ")", ";", "case", "'a'", ":", "return", "std", "::", "make_pair", "(", "MOS", "::", "A", ",", "&", "MOS", "::", "GPRRegClass", ")", ";", "case", "'x'", ":", "return", "std", "::", "make_pair", "(", "MOS", "::", "X", ",", "&", "MOS", "::", "GPRRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "MOS", "::", "Y", ",", "&", "MOS", "::", "GPRRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MOS", "::", "XYRegClass", ")", ";", "}", "}", "if", "(", "Constraint", "==", "\"{cc}\"", ")", "return", "std", "::", "make_pair", "(", "MOS", "::", "P", ",", "&", "MOS", "::", "PcRegClass", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "1", "0", "MVT::i16", "0U", "MOS::Imag16RegClass", "0U", "MOS::Imag8RegClass", "0U", "MOS::GPRRegClass", "MOS::A", "MOS::GPRRegClass", "MOS::X", "MOS::GPRRegClass", "MOS::Y", "MOS::GPRRegClass", "0U", "MOS::XYRegClass", "\"{cc}\"", "MOS::P", "MOS::PcRegClass" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getByValTypeAlignment", "(", "const", "Type", "*", "Ty", ")", "const", "{", "TargetMachine", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isDarwin", "(", ")", ")", "return", "4", ";", "return", "4", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

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

[]

[ "<s>", "void", "dump", "(", ")", "{", "errs", "(", ")", "<<", "\"XNCMISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "0", ")", "{", "errs", "(", ")", "<<", "\"Base.Reg \"", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "}", "errs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "\"GV \"", ";", "GV", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "CP", ")", "{", "errs", "(", ")", "<<", "\" CP \"", ";", "CP", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "else", "if", "(", "ES", ")", "{", "errs", "(", ")", "<<", "\"ES \"", ";", "errs", "(", ")", "<<", "ES", "<<", "'\\n'", ";", "}", "else", "if", "(", "JT", "!=", "-", "1", ")", "errs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "XNCM", "\"XNCMISelAddressMode \"", "0", "\"Base.Reg \"", "\" Base.FrameIndex \"", "\" Disp \"", "\"GV \"", "\" CP \"", "\" Align\"", "\"ES \"", "1", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "void", "AMDGPUTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "Threshold", "=", "300", ";", "UP", ".", "MaxCount", "=", "UINT_MAX", ";", "UP", ".", "Partial", "=", "true", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "const", "DataLayout", "&", "DL", "=", "BB", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", "||", "GEP", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ",", "DL", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "800", ";", "}", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "300", "AMDGPU", "800" ]

[]

[ "<s>", "void", "s390_expand_atomic", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "target", ",", "rtx", "mem", ",", "rtx", "val", ",", "bool", "after", ")", "{", "struct", "alignment_context", "ac", ";", "rtx", "cmp", ";", "rtx", "new_rtx", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "orig", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "csloop", "=", "gen_label_rtx", "(", ")", ";", "gcc_assert", "(", "!", "target", "||", "register_operand", "(", "target", ",", "VOIDmode", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "init_alignment_context", "(", "&", "ac", ",", "mem", ",", "mode", ")", ";", "if", "(", "!", "(", "ac", ".", "aligned", "&&", "code", "==", "SET", "&&", "MEM_P", "(", "val", ")", ")", ")", "val", "=", "s390_expand_mask_and_shift", "(", "val", ",", "mode", ",", "ac", ".", "shift", ")", ";", "if", "(", "code", "==", "PLUS", "||", "code", "==", "MINUS", ")", "emit_move_insn", "(", "orig", ",", "val", ")", ";", "else", "if", "(", "code", "==", "MULT", "||", "code", "==", "AND", ")", "val", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "val", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "cmp", "=", "force_reg", "(", "SImode", ",", "ac", ".", "memsi", ")", ";", "emit_label", "(", "csloop", ")", ";", "emit_move_insn", "(", "new_rtx", ",", "cmp", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "val", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new_rtx", ",", "orig", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "val", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "case", "SET", ":", "if", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "val", ")", ")", "store_bit_field", "(", "new_rtx", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "0", ",", "0", ",", "SImode", ",", "val", ",", "false", ")", ";", "else", "{", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new_rtx", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "break", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "MULT", ":", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "new_rtx", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "s390_emit_jump", "(", "csloop", ",", "s390_emit_compare_and_swap", "(", "NE", ",", "cmp", ",", "ac", ".", "memsi", ",", "cmp", ",", "new_rtx", ")", ")", ";", "if", "(", "target", ")", "convert_move", "(", "target", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "after", "?", "new_rtx", ":", "cmp", ",", "ac", ".", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ",", "1", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "operation", "CODE", "of", "mode", "MODE", ".", "MEM", "is", "the", "memory", "location", "and", "VAL", "the", "value", "to", "play", "with", ".", "If", "AFTER", "is", "true", "then", "store", "the", "the", "value", "MEM", "holds", "after", "the", "operation", ",", "if", "AFTER", "is", "false", "then", "store", "the", "value", "MEM", "holds", "before", "the", "operation", ".", "If", "TARGET", "is", "zero", "then", "discard", "that", "value", ",", "else", "store", "it", "to", "TARGET", "." ]

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

[]

[ "<s>", "const", "ArrayRef", "<", "MCPhysReg", ">", "MipsABIInfo", "::", "GetByValArgRegs", "(", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsN32", "(", ")", "||", "IsN64", "(", ")", ")", "return", "makeArrayRef", "(", "Mips64IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "byval", "arguments", "." ]

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

[]

[ "<s>", "uint32_t", "getArrayIndexTypeId", "(", ")", "{", "assert", "(", "ArrayIndexTypeId", ")", ";", "return", "ArrayIndexTypeId", ";", "}", "</s>" ]

[ "Get", "the", "special", "array", "index", "type", "id", "." ]

[ "BPF" ]

[]

[ "<s>", "PreservedAnalyses", "BPFIRPeepholePass", "::", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", "{", "return", "BPFIRPeepholeImpl", "(", "F", ")", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "bool", "GenericToNVVM", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "for", "(", "GlobalVariable", "&", "GV", ":", "llvm", "::", "make_early_inc_range", "(", "M", ".", "globals", "(", ")", ")", ")", "{", "if", "(", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "==", "llvm", "::", "ADDRESS_SPACE_GENERIC", "&&", "!", "llvm", "::", "isTexture", "(", "GV", ")", "&&", "!", "llvm", "::", "isSurface", "(", "GV", ")", "&&", "!", "llvm", "::", "isSampler", "(", "GV", ")", "&&", "!", "GV", ".", "getName", "(", ")", ".", "startswith", "(", "\"llvm.\"", ")", ")", "{", "GlobalVariable", "*", "NewGV", "=", "new", "GlobalVariable", "(", "M", ",", "GV", ".", "getValueType", "(", ")", ",", "GV", ".", "isConstant", "(", ")", ",", "GV", ".", "getLinkage", "(", ")", ",", "GV", ".", "hasInitializer", "(", ")", "?", "GV", ".", "getInitializer", "(", ")", ":", "nullptr", ",", "\"\"", ",", "&", "GV", ",", "GV", ".", "getThreadLocalMode", "(", ")", ",", "llvm", "::", "ADDRESS_SPACE_GLOBAL", ")", ";", "NewGV", "->", "copyAttributesFrom", "(", "&", "GV", ")", ";", "GVMap", "[", "&", "GV", "]", "=", "NewGV", ";", "}", "}", "if", "(", "GVMap", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "isDeclaration", "(", ")", ")", "{", "continue", ";", "}", "IRBuilder", "<", ">", "Builder", "(", "F", ".", "getEntryBlock", "(", ")", ".", "getFirstNonPHIOrDbg", "(", ")", ")", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "II", ":", "BB", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "Value", "*", "Operand", "=", "II", ".", "getOperand", "(", "i", ")", ";", "if", "(", "isa", "<", "Constant", ">", "(", "Operand", ")", ")", "{", "II", ".", "setOperand", "(", "i", ",", "remapConstant", "(", "&", "M", ",", "&", "F", ",", "cast", "<", "Constant", ">", "(", "Operand", ")", ",", "Builder", ")", ")", ";", "}", "}", "}", "}", "ConstantToValueMap", ".", "clear", "(", ")", ";", "}", "ValueToValueMapTy", "VM", ";", "for", "(", "auto", "I", "=", "GVMap", ".", "begin", "(", ")", ",", "E", "=", "GVMap", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "VM", "[", "I", "->", "first", "]", "=", "I", "->", "second", ";", "for", "(", "GVMapTy", "::", "iterator", "I", "=", "GVMap", ".", "begin", "(", ")", ",", "E", "=", "GVMap", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "GlobalVariable", "*", "GV", "=", "I", "->", "first", ";", "GlobalVariable", "*", "NewGV", "=", "I", "->", "second", ";", "auto", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "GVMap", ".", "erase", "(", "I", ")", ";", "I", "=", "Next", ";", "Constant", "*", "BitCastNewGV", "=", "ConstantExpr", "::", "getPointerCast", "(", "NewGV", ",", "GV", "->", "getType", "(", ")", ")", ";", "GV", "->", "replaceAllUsesWith", "(", "BitCastNewGV", ")", ";", "std", "::", "string", "Name", "=", "std", "::", "string", "(", "GV", "->", "getName", "(", ")", ")", ";", "GV", "->", "eraseFromParent", "(", ")", ";", "NewGV", "->", "setName", "(", "Name", ")", ";", "}", "assert", "(", "GVMap", ".", "empty", "(", ")", "&&", "\"Expected it to be empty by now\"", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "NVPTX", "\"llvm.\"", "\"\"", "0", "\"Expected it to be empty by now\"" ]

[]

[ "<s>", "static", "rtx", "tilepro_got_rtx", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "got_rtx", ";", "}", "</s>" ]

[ "Return", "the", "register", "storing", "the", "value", "of", "the", "global", "offset", "table", "." ]

[ "tilepro" ]

[]

[ "<s>", "BT", "::", "RegisterCell", "BT", "::", "get", "(", "RegisterRef", "RR", ")", "const", "{", "return", "ME", ".", "getCell", "(", "RR", ",", "Map", ")", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "emitFunctionEntryLabel", "(", ")", "override", "{", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "SPIRV" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "ExpandRetRA", "(", "MBB", ",", "MI", ",", "Mips", "::", "RET", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "ExpandBuildPairF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "ExpandExtractElementF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "ExpandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips::RetRA", "Mips::RET", "Mips::BuildPairF64", "Mips::ExtractElementF64", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMI", "*", "DAG", "=", "createGenericSchedPostRA", "(", "C", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "ARM" ]

[]

[ "<s>", "PredicateOp", "getPredicate", "(", ")", "const", "{", "assert", "(", "isPredicate", "(", ")", ")", ";", "return", "Pred", ";", "}", "</s>" ]

[ "Returns", "the", "comparison", "predicate", "underlying", "the", "intrinsic", "." ]

[ "TPC" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "isFuncletReturnInstr", "(", "*", "MI", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "STI", ".", "is32Bit", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CATCHRET", ")", "{", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "bool", "IsSEH", "=", "isAsynchronousEHPersonality", "(", "classifyEHPersonality", "(", "Func", "->", "getPersonalityFn", "(", ")", ")", ")", ";", "if", "(", "IsSEH", ")", "return", "true", ";", "}", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::CATCHRET", "0", "X86::GR64RegClass", "X86::GR32RegClass", "X86::POP64r", "X86::POP32r", "0", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "bool", "aarch_rev16_p", "(", "rtx", "x", ")", "{", "rtx", "left_sub_rtx", ",", "right_sub_rtx", ";", "bool", "is_rev", "=", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "IOR", ")", "return", "false", ";", "left_sub_rtx", "=", "XEXP", "(", "x", ",", "0", ")", ";", "right_sub_rtx", "=", "XEXP", "(", "x", ",", "1", ")", ";", "is_rev", "=", "aarch_rev16_p_1", "(", "left_sub_rtx", ",", "right_sub_rtx", ",", "GET_MODE", "(", "x", ")", ")", ";", "if", "(", "!", "is_rev", ")", "is_rev", "=", "aarch_rev16_p_1", "(", "right_sub_rtx", ",", "left_sub_rtx", ",", "GET_MODE", "(", "x", ")", ")", ";", "return", "is_rev", ";", "}", "</s>" ]

[ "Recognise", "a", "sequence", "of", "bitwise", "operations", "corresponding", "to", "a", "rev16", "operation", ".", "These", "will", "be", "of", "the", "form", ":", "(", "(", "x", ">", ">", "8", ")", "&", "0x00ff00ff", ")", "|", "(", "(", "x", "<", "<", "8", ")", "&", "0xff00ff00", ")", "for", "SImode", "and", "with", "similar", "but", "wider", "bitmasks", "for", "DImode", ".", "The", "two", "sub-expressions", "of", "the", "IOR", "can", "appear", "on", "either", "side", "so", "check", "both", "permutations", "with", "the", "help", "of", "aarch_rev16_p_1", "above", "." ]

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

[]

[ "<s>", "unsigned", "WebAssemblyTTIImpl", "::", "getNumberOfRegisters", "(", "bool", "Vector", ")", "{", "unsigned", "Result", "=", "BaseT", "::", "getNumberOfRegisters", "(", "Vector", ")", ";", "if", "(", "Vector", ")", "Result", "=", "std", "::", "max", "(", "Result", ",", "16u", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "WebAssembly", "WebAssembly", "16u" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableRedundantCopyElimination", ")", "addPass", "(", "createRISCVRedundantCopyEliminationPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "isRegister", "(", ")", "const", "{", "return", "type", "==", "RAInfo", "::", "LocType", "::", "Register", ";", "}", "</s>" ]

[ "isRegister", "-", "Returns", "true", "if", "this", "is", "a", "normal", "register", "use/def", "slot", "." ]

[ "Patmos" ]

[]

[ "<s>", "BitVector", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "assert", "(", "!", "\"Unimplemented\"", ")", ";", "return", "BitVector", "(", ")", ";", "}", "</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", "." ]

[ "AMDGPU", "\"Unimplemented\"" ]

[]

[ "<s>", "void", "SIAnnotateControlFlow", "::", "initialize", "(", "Module", "&", "M", ",", "const", "GCNSubtarget", "&", "ST", ")", "{", "LLVMContext", "&", "Context", "=", "M", ".", "getContext", "(", ")", ";", "Void", "=", "Type", "::", "getVoidTy", "(", "Context", ")", ";", "Boolean", "=", "Type", "::", "getInt1Ty", "(", "Context", ")", ";", "IntMask", "=", "ST", ".", "isWave32", "(", ")", "?", "Type", "::", "getInt32Ty", "(", "Context", ")", ":", "Type", "::", "getInt64Ty", "(", "Context", ")", ";", "ReturnStruct", "=", "StructType", "::", "get", "(", "Boolean", ",", "IntMask", ")", ";", "BoolTrue", "=", "ConstantInt", "::", "getTrue", "(", "Context", ")", ";", "BoolFalse", "=", "ConstantInt", "::", "getFalse", "(", "Context", ")", ";", "BoolUndef", "=", "UndefValue", "::", "get", "(", "Boolean", ")", ";", "IntMaskZero", "=", "ConstantInt", "::", "get", "(", "IntMask", ",", "0", ")", ";", "If", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_if", ",", "{", "IntMask", "}", ")", ";", "Else", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_else", ",", "{", "IntMask", ",", "IntMask", "}", ")", ";", "IfBreak", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_if_break", ",", "{", "IntMask", ",", "IntMask", "}", ")", ";", "Loop", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_loop", ",", "{", "IntMask", "}", ")", ";", "EndCf", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_end_cf", ",", "{", "IntMask", "}", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

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

[]

[ "<s>", "static", "rtx", "aarch64_expand_builtin_data_intrinsic", "(", "unsigned", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "expand_operand", "ops", "[", "2", "]", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ",", "mode", ")", ";", "enum", "insn_code", "icode", ";", "switch", "(", "fcode", ")", "{", "case", "AARCH64_REV16", ":", "case", "AARCH64_REV16L", ":", "case", "AARCH64_REV16LL", ":", "icode", "=", "code_for_aarch64_rev16", "(", "mode", ")", ";", "break", ";", "case", "AARCH64_RBIT", ":", "case", "AARCH64_RBITL", ":", "case", "AARCH64_RBITLL", ":", "icode", "=", "code_for_aarch64_rbit", "(", "mode", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "expand_insn", "(", "icode", ",", "2", ",", "ops", ")", ";", "return", "ops", "[", "0", "]", ".", "value", ";", "}", "</s>" ]

[ "Function", "to", "expand", "an", "expression", "EXP", "which", "calls", "one", "of", "the", "ACLE", "Data", "Intrinsic", "builtins", "FCODE", "with", "the", "result", "going", "to", "TARGET", "." ]

[ "aarch64", "2", "0", "1", "0", "2", "0" ]

[]

[ "<s>", "const", "char", "*", "tilepro_output_cbranch", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "reversed", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "const", "char", "*", "opcode", ";", "const", "char", "*", "rev_opcode", ";", "if", "(", "reversed", ")", "code", "=", "reverse_condition", "(", "code", ")", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "opcode", "=", "\"bnz\"", ";", "rev_opcode", "=", "\"bz\"", ";", "break", ";", "case", "EQ", ":", "opcode", "=", "\"bz\"", ";", "rev_opcode", "=", "\"bnz\"", ";", "break", ";", "case", "GE", ":", "opcode", "=", "\"bgez\"", ";", "rev_opcode", "=", "\"blz\"", ";", "break", ";", "case", "GT", ":", "opcode", "=", "\"bgz\"", ";", "rev_opcode", "=", "\"blez\"", ";", "break", ";", "case", "LE", ":", "opcode", "=", "\"blez\"", ";", "rev_opcode", "=", "\"bgz\"", ";", "break", ";", "case", "LT", ":", "opcode", "=", "\"blz\"", ";", "rev_opcode", "=", "\"bgez\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "tilepro_output_cbranch_with_opcode", "(", "insn", ",", "operands", ",", "opcode", ",", "rev_opcode", ",", "2", ",", "false", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "code", "for", "a", "conditional", "branch", "instruction", "." ]

[ "tilepro", "1", "\"bnz\"", "\"bz\"", "\"bz\"", "\"bnz\"", "\"bgez\"", "\"blz\"", "\"bgz\"", "\"blez\"", "\"blez\"", "\"bgz\"", "\"blz\"", "\"bgez\"", "2" ]

[]

[ "<s>", "unsigned", "int", "rs6000_data_alignment", "(", "tree", "type", ",", "unsigned", "int", "align", ",", "enum", "data_align", "how", ")", "{", "if", "(", "how", "!=", "align_opt", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "(", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "||", "(", "TARGET_PAIRED_FLOAT", "&&", "PAIRED_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", ")", "{", "if", "(", "align", "<", "64", ")", "align", "=", "64", ";", "}", "else", "if", "(", "align", "<", "128", ")", "align", "=", "128", ";", "}", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "&&", "TYPE_MODE", "(", "type", ")", "==", "DFmode", ")", "{", "if", "(", "align", "<", "64", ")", "align", "=", "64", ";", "}", "}", "if", "(", "how", "!=", "align_abi", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", "&&", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "QImode", ")", "{", "if", "(", "align", "<", "BITS_PER_WORD", ")", "align", "=", "BITS_PER_WORD", ";", "}", "}", "return", "align", ";", "}", "</s>" ]

[ "Return", "alignment", "of", "TYPE", ".", "Existing", "alignment", "is", "ALIGN", ".", "HOW", "selects", "whether", "the", "alignment", "is", "abi", "mandated", ",", "optional", ",", "or", "both", "abi", "and", "optional", "alignment", "." ]

[ "rs6000", "64", "64", "128", "128", "64", "64" ]

[]

[ "<s>", "tree", "aarch64_general_builtin_decl", "(", "unsigned", "code", ",", "bool", ")", "{", "if", "(", "code", ">=", "AARCH64_BUILTIN_MAX", ")", "return", "error_mark_node", ";", "return", "aarch64_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "for", "the", "AARCH64_BUILTIN_GENERAL", "group", "." ]

[ "aarch64" ]

[]

[ "<s>", "InstructionCost", "RISCVTTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsUnsigned", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "!", "isa", "<", "FixedVectorType", ">", "(", "Ty", ")", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "if", "(", "!", "ST", "->", "useRVVForFixedLengthVectors", "(", ")", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "if", "(", "Ty", "->", "getScalarSizeInBits", "(", ")", ">", "ST", "->", "getELEN", "(", ")", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "InstructionCost", "BaseCost", "=", "2", ";", "unsigned", "VL", "=", "cast", "<", "FixedVectorType", ">", "(", "Ty", ")", "->", "getNumElements", "(", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "(", "LT", ".", "first", "-", "1", ")", "+", "BaseCost", "+", "Log2_32_Ceil", "(", "VL", ")", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

[ "RISCV", "RISCV", "2", "1" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", "&&", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_Custom32", ";", "return", "TargetLowering", "::", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "emitInst", "(", "uint32_t", "Inst", ")", "{", "char", "Buffer", "[", "4", "]", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "4", ";", "++", "I", ")", "{", "Buffer", "[", "I", "]", "=", "uint8_t", "(", "Inst", ")", ";", "Inst", ">>=", "8", ";", "}", "emitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "emitBytes", "(", "StringRef", "(", "Buffer", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "AArch64", "4", "0", "4", "8", "4" ]

[]

[ "<s>", "void", "SystemZTTIImpl", "::", "getPeelingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "PeelingPreferences", "&", "PP", ")", "{", "BaseT", "::", "getPeelingPreferences", "(", "L", ",", "SE", ",", "PP", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressEVXRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "N", "->", "use_begin", "(", ")", ",", "E", "=", "N", "->", "use_end", "(", ")", ";", "UI", "!=", "E", ";", "++", "UI", ")", "{", "if", "(", "MemSDNode", "*", "Memop", "=", "dyn_cast", "<", "MemSDNode", ">", "(", "*", "UI", ")", ")", "{", "if", "(", "Memop", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "f64", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressEVXRegReg", "-", "Given", "the", "specified", "addressed", ",", "check", "to", "see", "if", "it", "can", "be", "more", "efficiently", "represented", "as", "[", "r+imm", "]", "." ]

[ "PowerPC", "PPC", "MVT::f64", "0", "1" ]

[]

[ "<s>", "uint64_t", "R600MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixup", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "HAS_NATIVE_OPERANDS", "(", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ")", ")", "{", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "{", "return", "getHWReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "MO", ".", "getImm", "(", ")", ";", "}", "else", "{", "assert", "(", "0", ")", ";", "return", "0", ";", "}", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "R600", "0", "0" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "void", "MipsTargetMachine", "::", "resetSubtarget", "(", "MachineFunction", "*", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"resetSubtarget\\n\"", ")", ";", "Subtarget", "=", "&", "MF", "->", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "subtarget", "for", "the", "Mips", "target", "." ]

[ "Mips", "Mips", "\"resetSubtarget\\n\"", "Mips" ]

[]

[ "<s>", "static", "rtx_insn", "*", "avr_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ",", "location_t", ")", "{", "clobbers", ".", "safe_push", "(", "cc_reg_rtx", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "REG_CC", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Prepend", "to", "CLOBBERS", "hard", "registers", "that", "are", "automatically", "clobbered", "for", "an", "asm", ".", "We", "do", "this", "for", "CC_REGNUM", "to", "maintain", "source", "compatibility", "with", "the", "original", "cc0-based", "compiler", "." ]

[ "avr" ]

[]

[ "<s>", "inline", "machine_mode", "function_checker", "::", "arg_mode", "(", "unsigned", "int", "argno", ")", "const", "{", "return", "TYPE_MODE", "(", "TREE_TYPE", "(", "m_args", "[", "argno", "]", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "machine_mode", "of", "the", "corresponding", "arg", "type", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "SDValue", "getTargetNode", "(", "ConstantPoolSDNode", "*", "N", ",", "SDLoc", "DL", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "{", "return", "DAG", ".", "getTargetConstantPool", "(", "N", "->", "getConstVal", "(", ")", ",", "Ty", ",", "N", "->", "getAlignment", "(", ")", ",", "N", "->", "getOffset", "(", ")", ",", "Flags", ")", ";", "}", "</s>" ]

[ "Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "." ]

[ "RISCV" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "else", "if", "(", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "0" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "RISCVInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "RISCVInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "RISCVSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "unsigned", "SP", "=", "STI", ".", "isRV64", "(", ")", "?", "RISCV", "::", "sp_64", ":", "RISCV", "::", "sp", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "0", "RISCV::ADJCALLSTACKDOWN", "RISCV::sp_64", "RISCV::sp" ]

[]

[ "<s>", "unsigned", "RISCVRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "RISCV", "::", "X8", ":", "RISCV", "::", "X2", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "RISCV", "RISCV", "RISCV::X8", "RISCV::X2" ]

[]

[ "<s>", "void", "m32c_initialize_trampoline", "(", "rtx", "tramp", ",", "rtx", "function", ",", "rtx", "chainval", ")", "{", "if", "(", "TARGET_A16", ")", "{", "emit_move_insn", "(", "A0", "(", "HImode", ",", "0", ")", ",", "GEN_INT", "(", "0xc475", "-", "0x10000", ")", ")", ";", "emit_move_insn", "(", "A0", "(", "HImode", ",", "2", ")", ",", "chainval", ")", ";", "emit_move_insn", "(", "A0", "(", "QImode", ",", "4", ")", ",", "GEN_INT", "(", "0xfc", "-", "0x100", ")", ")", ";", "emit_move_insn", "(", "A0", "(", "HImode", ",", "5", ")", ",", "function", ")", ";", "emit_move_insn", "(", "A0", "(", "QImode", ",", "7", ")", ",", "GEN_INT", "(", "0x00", ")", ")", ";", "}", "else", "{", "emit_move_insn", "(", "A0", "(", "QImode", ",", "0", ")", ",", "GEN_INT", "(", "0xbc", "-", "0x100", ")", ")", ";", "emit_move_insn", "(", "A0", "(", "PSImode", ",", "1", ")", ",", "chainval", ")", ";", "emit_move_insn", "(", "A0", "(", "QImode", ",", "4", ")", ",", "GEN_INT", "(", "0xcc", "-", "0x100", ")", ")", ";", "emit_move_insn", "(", "A0", "(", "PSImode", ",", "5", ")", ",", "function", ")", ";", "}", "}", "</s>" ]

[ "Implements", "INITIALIZE_TRAMPOLINE", "." ]

[ "m32c", "0", "0xc475", "0x10000", "2", "4", "0xfc", "0x100", "5", "7", "0x00", "0", "0xbc", "0x100", "1", "4", "0xcc", "0x100", "5" ]

[]

[ "<s>", "bool", "MBlazePassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMBlazeISelDag", "(", "getMBlazeTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPUSH", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "true", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", "&&", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ")", "isKill", "=", "false", ";", "}", "if", "(", "isKill", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "MIB", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM::tPUSH", "0", "1", "ARM::LR" ]

[]

[ "<s>", "bool", "arc_legitimate_pc_offset_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "return", "(", "GET_CODE", "(", "addr", ")", "==", "UNSPEC", "&&", "XVECLEN", "(", "addr", ",", "0", ")", "==", "1", "&&", "XINT", "(", "addr", ",", "1", ")", "==", "ARC_UNSPEC_GOT", "&&", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "is", "an", "address", "that", "needs", "to", "be", "expressed", "as", "an", "explicit", "sum", "of", "pcl", "+", "offset", "." ]

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

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "MatchRegisterName", "(", "RegName", ")", ";", "if", "(", "AArch64", "::", "X1", "<=", "Reg", "&&", "Reg", "<=", "AArch64", "::", "X28", ")", "{", "const", "MCRegisterInfo", "*", "MRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "unsigned", "DwarfRegNum", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "false", ")", ";", "if", "(", "!", "Subtarget", "->", "isXRegisterReserved", "(", "DwarfRegNum", ")", ")", "Reg", "=", "0", ";", "}", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "AArch64", "AArch64", "AArch64::X1", "AArch64::X28", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "static", "bool", "arm_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "result", ";", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "gcc_assert", "(", "current_tune", "->", "insn_extra_cost", ")", ";", "result", "=", "arm_rtx_costs_internal", "(", "x", ",", "(", "enum", "rtx_code", ")", "code", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "current_tune", "->", "insn_extra_cost", ",", "total", ",", "speed", ")", ";", "if", "(", "dump_file", "&&", "arm_verbose_cost", ")", "{", "print_rtl_single", "(", "dump_file", ",", "x", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n%s cost: %d (%s)\\n\"", ",", "speed", "?", "\"Hot\"", ":", "\"Cold\"", ",", "*", "total", ",", "result", "?", "\"final\"", ":", "\"partial\"", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "RTX", "costs", "when", "optimizing", "for", "size", "." ]

[ "arm", "\"\\n%s cost: %d (%s)\\n\"", "\"Hot\"", "\"Cold\"", "\"final\"", "\"partial\"" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ")", "{", "static", "CUMULATIVE_ARGS", "zero_cum", ";", "tree", "param", ",", "next_param", ";", "*", "cum", "=", "zero_cum", ";", "for", "(", "param", "=", "fntype", "?", "TYPE_ARG_TYPES", "(", "fntype", ")", ":", "0", ";", "param", "!=", "0", ";", "param", "=", "next_param", ")", "{", "next_param", "=", "TREE_CHAIN", "(", "param", ")", ";", "if", "(", "next_param", "==", "0", "&&", "TREE_VALUE", "(", "param", ")", "!=", "void_type_node", ")", "cum", "->", "gp_reg_found", "=", "1", ";", "}", "}", "</s>" ]

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

[ "microblaze", "0", "0", "0", "1" ]

[]

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

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

[ "RISCV" ]

[]

[ "<s>", "virtual", "unsigned", "getISAEncoding", "(", ")", "{", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "0", ";", "return", "Subtarget", "->", "isThumb", "(", ")", "?", "ARM", "::", "DW_ISA_ARM_thumb", ":", "ARM", "::", "DW_ISA_ARM_arm", ";", "}", "</s>" ]

[ "Get", "the", "value", "for", "DW_AT_APPLE_isa", ".", "Zero", "if", "no", "isa", "encoding", "specified", "." ]

[ "ARM", "0", "ARM::DW_ISA_ARM_thumb", "ARM::DW_ISA_ARM_arm" ]

[]

[ "<s>", "static", "rtx", "rs6000_internal_arg_pointer", "(", "void", ")", "{", "if", "(", "flag_split_stack", "&&", "(", "lookup_attribute", "(", "\"no_split_stack\"", ",", "DECL_ATTRIBUTES", "(", "cfun", "->", "decl", ")", ")", "==", "NULL", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "==", "NULL_RTX", ")", "{", "rtx", "pat", ";", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "REG_POINTER", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "=", "1", ";", "pat", "=", "gen_rtx_SET", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "push_topmost_sequence", "(", ")", ";", "emit_insn_after", "(", "pat", ",", "get_insns", "(", ")", ")", ";", "pop_topmost_sequence", "(", ")", ";", "}", "rtx", "ret", "=", "plus_constant", "(", "Pmode", ",", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "FIRST_PARM_OFFSET", "(", "current_function_decl", ")", ")", ";", "return", "copy_to_reg", "(", "ret", ")", ";", "}", "return", "virtual_incoming_args_rtx", ";", "}", "</s>" ]

[ "Return", "the", "internal", "arg", "pointer", "used", "for", "function", "incoming", "arguments", ".", "When", "-fsplit-stack", ",", "the", "arg", "pointer", "is", "r12", "so", "we", "need", "to", "copy", "it", "to", "a", "pseudo", "in", "order", "for", "it", "to", "be", "preserved", "over", "calls", "and", "suchlike", ".", "We", "'d", "really", "like", "to", "use", "a", "pseudo", "here", "for", "the", "internal", "arg", "pointer", "but", "data-flow", "analysis", "is", "not", "prepared", "to", "accept", "pseudos", "as", "live", "at", "the", "beginning", "of", "a", "function", "." ]

[ "rs6000", "\"no_split_stack\"", "1", "12" ]

[]

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "BoolRC", "=", "TRI", "->", "getBoolRC", "(", ")", ";", "InsertKillCleanups", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", ";", "if", "(", "ST", ".", "isWave32", "(", ")", ")", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B32", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B32", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B32", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B32_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B32_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B32_term", ";", "OrTermrOpc", "=", "AMDGPU", "::", "S_OR_B32_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ";", "Exec", "=", "AMDGPU", "::", "EXEC_LO", ";", "}", "else", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B64", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B64", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B64", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B64_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B64_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B64_term", ";", "OrTermrOpc", "=", "AMDGPU", "::", "S_OR_B64_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "Exec", "=", "AMDGPU", "::", "EXEC", ";", "}", "SmallVector", "<", "MachineInstr", "*", ",", "32", ">", "Worklist", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ";", "BI", "!=", "MF", ".", "end", "(", ")", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "E", ",", "Next", ";", "E", "=", "MBB", "->", "end", "(", ")", ";", "for", "(", "I", "=", "MBB", "->", "begin", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "MachineBasicBlock", "*", "SplitMBB", "=", "MBB", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "SplitMBB", "=", "process", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "case", "AMDGPU", "::", "SI_LOOP", ":", "case", "AMDGPU", "::", "SI_END_CF", ":", "if", "(", "InsertKillCleanups", ")", "Worklist", ".", "push_back", "(", "&", "MI", ")", ";", "else", "SplitMBB", "=", "process", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INIT_EXEC", ":", "case", "AMDGPU", "::", "SI_INIT_EXEC_FROM_INPUT", ":", "lowerInitExec", "(", "MBB", ",", "MI", ")", ";", "if", "(", "LIS", ")", "LIS", "->", "removeAllRegUnitsForPhysReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "SplitMBB", "!=", "MBB", ")", "{", "MBB", "=", "Next", "->", "getParent", "(", ")", ";", "E", "=", "MBB", "->", "end", "(", ")", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "Worklist", ")", "process", "(", "*", "MI", ")", ";", "optimizeEndCf", "(", ")", ";", "LoweredEndCf", ".", "clear", "(", ")", ";", "LoweredIf", ".", "clear", "(", ")", ";", "NeedsKillCleanup", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32", "AMDGPU::S_XOR_B32", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_ANDN2_B32_term", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_B32_term", "AMDGPU::S_OR_SAVEEXEC_B32", "AMDGPU::EXEC_LO", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_XOR_B64", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_OR_B64_term", "AMDGPU::S_OR_SAVEEXEC_B64", "AMDGPU::EXEC", "32", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF", "AMDGPU::SI_INIT_EXEC", "AMDGPU::SI_INIT_EXEC_FROM_INPUT", "AMDGPU::EXEC" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be spilled\"", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillSaveOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be spilled\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "0" ]

[]

[ "<s>", "bool", "M88kPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "M88k", "M88k" ]

[]

[ "<s>", "static", "int", "s390_sched_score", "(", "rtx_insn", "*", "insn", ")", "{", "unsigned", "int", "mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "int", "score", "=", "0", ";", "switch", "(", "s390_sched_state", ")", "{", "case", "0", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "score", "+=", "5", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "score", "+=", "10", ";", "case", "1", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "0", ")", "score", "+=", "10", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "==", "0", ")", "score", "+=", "5", ";", "break", ";", "case", "2", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "0", ")", "score", "+=", "10", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "!=", "0", ")", "score", "+=", "10", ";", "break", ";", "case", "S390_SCHED_STATE_NORMAL", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", ")", "score", "+=", "5", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "score", "+=", "10", ";", "break", ";", "case", "S390_SCHED_STATE_CRACKED", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "score", "+=", "5", ";", "break", ";", "}", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "i", ";", "unsigned", "unit_mask", ",", "m", "=", "1", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "gcc_assert", "(", "units", "<=", "MAX_SCHED_UNITS", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "score", "+=", "(", "last_scheduled_unit_distance", "[", "i", "]", "*", "MAX_SCHED_MIX_SCORE", "/", "MAX_SCHED_MIX_DISTANCE", ")", ";", "unsigned", "latency", "=", "insn_default_latency", "(", "insn", ")", ";", "int", "other_side", "=", "1", "-", "current_side", ";", "if", "(", "latency", ">", "LONGRUNNING_THRESHOLD", ")", "{", "if", "(", "get_attr_z13_unit_fxu", "(", "insn", ")", "&&", "fxu_longrunning", "[", "current_side", "]", "&&", "fxu_longrunning", "[", "other_side", "]", "<=", "fxu_longrunning", "[", "current_side", "]", ")", "score", "=", "MAX", "(", "0", ",", "score", "-", "10", ")", ";", "if", "(", "get_attr_z13_unit_vfu", "(", "insn", ")", "&&", "vfu_longrunning", "[", "current_side", "]", "&&", "vfu_longrunning", "[", "other_side", "]", "<=", "vfu_longrunning", "[", "current_side", "]", ")", "score", "=", "MAX", "(", "0", ",", "score", "-", "10", ")", ";", "}", "}", "return", "score", ";", "}", "</s>" ]

[ "Return", "the", "scheduling", "score", "for", "INSN", ".", "The", "higher", "the", "score", "the", "better", ".", "The", "score", "is", "calculated", "from", "the", "OOO", "scheduling", "attributes", "of", "INSN", "and", "the", "scheduling", "state", "s390_sched_state", "." ]

[ "s390", "0", "0", "0", "0", "5", "0", "10", "1", "0", "0", "0", "10", "0", "5", "2", "0", "0", "0", "10", "0", "10", "0", "0", "5", "0", "10", "0", "0", "5", "1", "0", "1", "1", "0", "10", "0", "10" ]

[]

[ "<s>", "static", "void", "arm_option_check_internal", "(", "struct", "gcc_options", "*", "opts", ")", "{", "int", "flags", "=", "opts", "->", "x_target_flags", ";", "const", "struct", "arm_fpu_desc", "*", "fpu_desc", "=", "&", "all_fpus", "[", "opts", "->", "x_arm_fpu_index", "]", ";", "if", "(", "TARGET_IWMMXT", "&&", "TARGET_VFP", "&&", "ARM_FPU_FSET_HAS", "(", "fpu_desc", "->", "features", ",", "FPU_FL_NEON", ")", ")", "error", "(", "\"iWMMXt and NEON are incompatible\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "!", "ARM_FSET_HAS_CPU1", "(", "insn_flags", ",", "FL_NOTM", ")", ")", "error", "(", "\"target CPU does not support ARM mode\"", ")", ";", "if", "(", "(", "TARGET_TPCS_FRAME", "||", "TARGET_TPCS_LEAF_FRAME", ")", "&&", "TARGET_ARM_P", "(", "flags", ")", ")", "warning", "(", "0", ",", "\"enabling backtrace support is only meaningful when compiling for the Thumb\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "warning", "(", "0", ",", "\"enabling callee interworking support is only meaningful when compiling for the Thumb\"", ")", ";", "if", "(", "TARGET_ARM_P", "(", "flags", ")", "&&", "write_symbols", "!=", "NO_DEBUG", "&&", "!", "TARGET_APCS_FRAME", "&&", "(", "TARGET_DEFAULT", "&", "MASK_APCS_FRAME", ")", ")", "warning", "(", "0", ",", "\"-g with -mno-apcs-frame may not give sensible debugging\"", ")", ";", "if", "(", "TARGET_THUMB_P", "(", "flags", ")", "&&", "TARGET_IWMMXT", ")", "error", "(", "\"iWMMXt unsupported under Thumb mode\"", ")", ";", "if", "(", "TARGET_HARD_TP", "&&", "TARGET_THUMB1_P", "(", "flags", ")", ")", "error", "(", "\"can not use -mtp=cp15 with 16-bit Thumb\"", ")", ";", "if", "(", "TARGET_THUMB_P", "(", "flags", ")", "&&", "TARGET_VXWORKS_RTP", "&&", "flag_pic", ")", "{", "error", "(", "\"RTP PIC is incompatible with Thumb\"", ")", ";", "flag_pic", "=", "0", ";", "}", "if", "(", "target_slow_flash_data", "&&", "(", "(", "!", "(", "arm_arch7", "&&", "!", "arm_arch_notm", ")", "&&", "!", "arm_arch7em", ")", "||", "(", "TARGET_THUMB1_P", "(", "flags", ")", "||", "flag_pic", "||", "TARGET_NEON", ")", ")", ")", "error", "(", "\"-mslow-flash-data only supports non-pic code on armv7-m targets\"", ")", ";", "}", "</s>" ]

[ "Check", "any", "incompatible", "options", "that", "the", "user", "has", "specified", "." ]

[ "arm", "\"iWMMXt and NEON are incompatible\"", "\"target CPU does not support ARM mode\"", "0", "\"enabling backtrace support is only meaningful when compiling for the Thumb\"", "0", "\"enabling callee interworking support is only meaningful when compiling for the Thumb\"", "0", "\"-g with -mno-apcs-frame may not give sensible debugging\"", "\"iWMMXt unsupported under Thumb mode\"", "\"can not use -mtp=cp15 with 16-bit Thumb\"", "\"RTP PIC is incompatible with Thumb\"", "0", "\"-mslow-flash-data only supports non-pic code on armv7-m targets\"" ]

[]

[ "<s>", "bool", "AGCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAGCISelDag", "(", "getAGCTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "AGC", "AGC" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "getInsertSubregLikeInputs", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "DefIdx", ",", "RegSubRegPair", "&", "BaseReg", ",", "RegSubRegPairAndIdx", "&", "InsertedReg", ")", "const", "{", "assert", "(", "DefIdx", "<", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"Invalid definition index\"", ")", ";", "assert", "(", "MI", ".", "isInsertSubregLike", "(", ")", "&&", "\"Invalid kind of instruction\"", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VSETLNi32", ":", "case", "ARM", "::", "MVE_VMOV_to_lane_32", ":", "const", "MachineOperand", "&", "MOBaseReg", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "const", "MachineOperand", "&", "MOInsertedReg", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "MOInsertedReg", ".", "isUndef", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MOIndex", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "BaseReg", ".", "Reg", "=", "MOBaseReg", ".", "getReg", "(", ")", ";", "BaseReg", ".", "SubReg", "=", "MOBaseReg", ".", "getSubReg", "(", ")", ";", "InsertedReg", ".", "Reg", "=", "MOInsertedReg", ".", "getReg", "(", ")", ";", "InsertedReg", ".", "SubReg", "=", "MOInsertedReg", ".", "getSubReg", "(", ")", ";", "InsertedReg", ".", "SubIdx", "=", "ARM", "::", "ssub_0", "+", "MOIndex", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Target dependent opcode missing\"", ")", ";", "}", "</s>" ]

[ "Target-dependent", "implementation", "of", "getInsertSubregInputs", "." ]

[ "ARM", "ARM", "\"Invalid definition index\"", "\"Invalid kind of instruction\"", "ARM::VSETLNi32", "ARM::MVE_VMOV_to_lane_32", "1", "2", "3", "ARM::ssub_0", "\"Target dependent opcode missing\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Split basic blocks at barrier\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"Split basic blocks at barrier\"" ]

[]

[ "<s>", "static", "rtx", "rs6000_debug_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "rtx", "ret", ";", "rtx_insn", "*", "insns", ";", "start_sequence", "(", ")", ";", "ret", "=", "rs6000_legitimize_address", "(", "x", ",", "oldx", ",", "mode", ")", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "ret", "!=", "x", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_legitimize_address: mode %s, old code %s, \"", "\"new code %s, modified\\n\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "x", ")", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "ret", ")", ")", ")", ";", "fprintf", "(", "stderr", ",", "\"Original address:\\n\"", ")", ";", "debug_rtx", "(", "x", ")", ";", "fprintf", "(", "stderr", ",", "\"oldx:\\n\"", ")", ";", "debug_rtx", "(", "oldx", ")", ";", "fprintf", "(", "stderr", ",", "\"New address:\\n\"", ")", ";", "debug_rtx", "(", "ret", ")", ";", "if", "(", "insns", ")", "{", "fprintf", "(", "stderr", ",", "\"Insns added:\\n\"", ")", ";", "debug_rtx_list", "(", "insns", ",", "20", ")", ";", "}", "}", "else", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_legitimize_address: mode %s, code %s, no change:\\n\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "x", ")", ")", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "insns", ")", "emit_insn", "(", "insns", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_legitimize_address", "." ]

[ "powerpcspe", "\"\\nrs6000_legitimize_address: mode %s, old code %s, \"", "\"new code %s, modified\\n\"", "\"Original address:\\n\"", "\"oldx:\\n\"", "\"New address:\\n\"", "\"Insns added:\\n\"", "20", "\"\\nrs6000_legitimize_address: mode %s, code %s, no change:\\n\"" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "AGC" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDNode", "*", ">", "&", "Created", ")", "const", "{", "AttributeList", "Attr", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ";", "if", "(", "isIntDivCheap", "(", "N", "->", "getValueType", "(", "0", ")", ",", "Attr", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "Divisor", ".", "isNegatedPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "1ULL", "<<", "Lg2", ")", "-", "1", ",", "DL", ",", "VT", ")", ";", "SDValue", "CCVal", ";", "SDValue", "Cmp", "=", "getAArch64Cmp", "(", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ",", "CCVal", ",", "DAG", ",", "DL", ")", ";", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "CSel", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "CSEL", ",", "DL", ",", "VT", ",", "Add", ",", "N0", ",", "CCVal", ",", "Cmp", ")", ";", "Created", ".", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "Add", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "CSel", ".", "getNode", "(", ")", ")", ";", "SDValue", "SRA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "CSel", ",", "DAG", ".", "getConstant", "(", "Lg2", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "if", "(", "Divisor", ".", "isNonNegative", "(", ")", ")", "return", "SRA", ";", "Created", ".", "push_back", "(", "SRA", ".", "getNode", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ",", "SRA", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "AArch64", "AArch64", "0", "0", "0", "MVT::i32", "MVT::i64", "0", "0", "1ULL", "1", "AArch64", "ISD::SETLT", "ISD::ADD", "AArch64ISD::CSEL", "ISD::SRA", "MVT::i64", "ISD::SUB", "0" ]

[]

[ "<s>", "static", "void", "mark_swaps_for_removal", "(", "swap_web_entry", "*", "insn_entry", ",", "unsigned", "int", "i", ")", "{", "rtx", "insn", "=", "insn_entry", "[", "i", "]", ".", "insn", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_load", ")", "{", "df_ref", "def", ";", "FOR_EACH_INSN_INFO_DEF", "(", "def", ",", "insn_info", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "while", "(", "link", ")", "{", "rtx", "use_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "insn_entry", "[", "INSN_UID", "(", "use_insn", ")", "]", ".", "will_delete", "=", "1", ";", "link", "=", "link", "->", "next", ";", "}", "}", "}", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "is_store", ")", "{", "df_ref", "use", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "DF_REF_REG", "(", "use", ")", ")", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "continue", ";", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "while", "(", "link", ")", "{", "rtx", "def_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "insn_entry", "[", "INSN_UID", "(", "def_insn", ")", "]", ".", "will_delete", "=", "1", ";", "link", "=", "link", "->", "next", ";", "}", "}", "}", "}", "</s>" ]

[ "Mark", "the", "xxswapdi", "instructions", "associated", "with", "permuting", "loads", "and", "stores", "for", "removal", ".", "Note", "that", "we", "only", "flag", "them", "for", "deletion", "here", ",", "as", "there", "is", "a", "possibility", "of", "a", "swap", "being", "reached", "from", "multiple", "loads", ",", "etc", "." ]

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

[]

[ "<s>", "void", "crx_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libfunc", "ATTRIBUTE_UNUSED", ")", "{", "tree", "param", ",", "next_param", ";", "cum", "->", "ints", "=", "0", ";", "for", "(", "param", "=", "(", "fntype", ")", "?", "TYPE_ARG_TYPES", "(", "fntype", ")", ":", "0", ";", "param", "!=", "(", "tree", ")", "0", ";", "param", "=", "next_param", ")", "{", "next_param", "=", "TREE_CHAIN", "(", "param", ")", ";", "if", "(", "next_param", "==", "(", "tree", ")", "0", "&&", "TREE_VALUE", "(", "param", ")", "!=", "void_type_node", ")", "{", "cum", "->", "ints", "=", "-", "1", ";", "return", ";", "}", "}", "}", "</s>" ]

[ "Implements", "the", "macro", "INIT_CUMULATIVE_ARGS", "defined", "in", "crx.h", "." ]

[ "crx", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TII", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "llvm", "::", "make_early_inc_range", "(", "MF", ")", ")", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "int", "s390_memory_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "return", "2", ";", "}", "</s>" ]

[ "Implement", "TARGET_MEMORY_MOVE_COST", "." ]

[ "s390", "2" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "2", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "FixupExpression", "=", "MCBinaryExpr", "::", "createAdd", "(", "MO", ".", "getExpr", "(", ")", ",", "MCConstantExpr", "::", "create", "(", "-", "4", ",", "Ctx", ")", ",", "Ctx", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "FixupExpression", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_PC16", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "2", "\"getBranchTargetOpValue expects only expressions or immediates\"", "4", "0", "Mips::fixup_Mips_PC16", "0" ]

[]

[ "<s>", "static", "bool", "ix86_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "type", ",", "decl_or_type", ";", "rtx", "a", ",", "b", ";", "bool", "bind_global", "=", "decl", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ";", "if", "(", "ix86_function_naked", "(", "current_function_decl", ")", ")", "return", "false", ";", "if", "(", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "return", "false", ";", "if", "(", "!", "TARGET_MACHO", "&&", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "flag_plt", "&&", "bind_global", ")", "return", "false", ";", "if", "(", "ix86_minimum_incoming_stack_boundary", "(", "true", ")", "<", "PREFERRED_STACK_BOUNDARY", ")", "return", "false", ";", "if", "(", "decl", ")", "{", "decl_or_type", "=", "decl", ";", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "}", "else", "{", "type", "=", "CALL_EXPR_FN", "(", "exp", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "decl_or_type", "=", "type", ";", "}", "if", "(", "(", "OUTGOING_REG_PARM_STACK_SPACE", "(", "type", ")", "!=", "OUTGOING_REG_PARM_STACK_SPACE", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "||", "(", "REG_PARM_STACK_SPACE", "(", "decl_or_type", ")", "!=", "REG_PARM_STACK_SPACE", "(", "current_function_decl", ")", ")", ")", "{", "maybe_complain_about_tail_call", "(", "exp", ",", "\"inconsistent size of stack space\"", "\" allocated for arguments which are\"", "\" passed in registers\"", ")", ";", "return", "false", ";", "}", "a", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "exp", ")", ",", "decl_or_type", ",", "false", ")", ";", "b", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ",", "false", ")", ";", "if", "(", "STACK_REG_P", "(", "a", ")", "||", "STACK_REG_P", "(", "b", ")", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "}", "else", "if", "(", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ")", ")", ";", "else", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "cfun", "->", "machine", "->", "call_abi", "==", "MS_ABI", "&&", "ix86_function_type_abi", "(", "type", ")", "==", "SYSV_ABI", ")", "return", "false", ";", "}", "else", "{", "if", "(", "!", "decl", "||", "(", "bind_global", "&&", "flag_pic", "&&", "!", "flag_plt", ")", "||", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "DECL_DLLIMPORT_P", "(", "decl", ")", ")", "||", "flag_force_indirect_call", ")", "{", "if", "(", "ix86_function_regparm", "(", "type", ",", "decl", ")", ">=", "3", "&&", "!", "cfun", "->", "machine", "->", "arg_reg_available", ")", "return", "false", ";", "}", "}", "if", "(", "decl", "&&", "ix86_use_pseudo_pic_reg", "(", ")", ")", "{", "cgraph_node", "*", "node", "=", "cgraph_node", "::", "get", "(", "decl", ")", ";", "if", "(", "node", "&&", "node", "->", "ifunc_resolver", ")", "return", "false", ";", "}", "if", "(", "(", "(", "flag_cf_protection", "&", "(", "CF_RETURN", "|", "CF_BRANCH", ")", ")", "==", "(", "CF_RETURN", "|", "CF_BRANCH", ")", ")", "&&", "lookup_attribute", "(", "\"indirect_return\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", "&&", "!", "lookup_attribute", "(", "\"indirect_return\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "cfun", "->", "decl", ")", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "." ]

[ "i386", "\"inconsistent size of stack space\"", "\" allocated for arguments which are\"", "\" passed in registers\"", "3", "\"indirect_return\"", "\"indirect_return\"" ]

[]

[ "<s>", "rtx", "rs6000_address_for_altivec", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "if", "(", "!", "altivec_indexed_or_indirect_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "int", "strict_p", "=", "(", "reload_in_progress", "||", "reload_completed", ")", ";", "if", "(", "!", "legitimate_indexed_address_p", "(", "addr", ",", "strict_p", ")", "&&", "!", "legitimate_indirect_address_p", "(", "addr", ",", "strict_p", ")", ")", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "addr", ")", ";", "addr", "=", "gen_rtx_AND", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "-", "16", ")", ")", ";", "x", "=", "change_address", "(", "x", ",", "GET_MODE", "(", "x", ")", ",", "addr", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Given", "a", "memory", "reference", ",", "if", "it", "is", "not", "in", "the", "form", "for", "altivec", "memory", "reference", "instructions", "(", "i.e", ".", "reg", "or", "reg+reg", "addressing", "with", "AND", "of", "-16", ")", ",", "convert", "to", "the", "altivec", "format", "." ]

[ "powerpcspe", "0", "16" ]

[]

[ "<s>", "void", "F2003fMCAsmStreamer", "::", "emitExplicitComments", "(", ")", "{", "StringRef", "Comments", "=", "ExplicitCommentToEmit", ";", "if", "(", "!", "Comments", ".", "empty", "(", ")", ")", "OS", "<<", "Comments", ";", "ExplicitCommentToEmit", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Emit", "added", "explicit", "comments", "." ]

[ "F2003f", "F2003f" ]

[]

[ "<s>", "void", "final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n! at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "TARGET_RELAX", ")", "{", "rtx", "note", ";", "note", "=", "find_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "NULL_RTX", ")", ";", "if", "(", "note", ")", "{", "rtx", "pattern", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "pattern", ")", ")", "{", "case", "SET", ":", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "CALL", "&&", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SFUNC", ")", "{", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "note", ",", "0", ")", ")", ")", ";", "break", ";", "}", "case", "CALL", ":", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.uses %LL%d\\n\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "note", ",", "0", ")", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "sh", "\"\\n! at %04x\\n\"", "0", "0", "\"L\"", "0", "\"\\t.uses %LL%d\\n\"", "0" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isKnownNeverNaNForTargetNode", "(", "SDValue", "Op", ",", "const", "SelectionDAG", "&", "DAG", ",", "bool", "SNaN", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "Opcode", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FMIN_LEGACY", ":", "case", "AMDGPUISD", "::", "FMAX_LEGACY", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUISD", "::", "FMUL_LEGACY", ":", "case", "AMDGPUISD", "::", "CVT_PKRTZ_F16_F32", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", "&&", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "AMDGPUISD", "::", "FMED3", ":", "case", "AMDGPUISD", "::", "FMIN3", ":", "case", "AMDGPUISD", "::", "FMAX3", ":", "case", "AMDGPUISD", "::", "FMAD_FTZ", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", "&&", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", "&&", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "2", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE0", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE1", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE2", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE3", ":", "return", "true", ";", "case", "AMDGPUISD", "::", "RCP", ":", "case", "AMDGPUISD", "::", "RSQ", ":", "case", "AMDGPUISD", "::", "RCP_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_CLAMP", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUISD", "::", "LDEXP", ":", "case", "AMDGPUISD", "::", "FRACT", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "AMDGPUISD", "::", "DIV_SCALE", ":", "case", "AMDGPUISD", "::", "DIV_FMAS", ":", "case", "AMDGPUISD", "::", "DIV_FIXUP", ":", "case", "AMDGPUISD", "::", "TRIG_PREOP", ":", "return", "SNaN", ";", "case", "AMDGPUISD", "::", "SIN_HW", ":", "case", "AMDGPUISD", "::", "COS_HW", ":", "{", "return", "SNaN", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IntrinsicID", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntrinsicID", ")", "{", "case", "Intrinsic", "::", "amdgcn_cubeid", ":", "return", "true", ";", "case", "Intrinsic", "::", "amdgcn_frexp_mant", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_cvt_pkrtz", ":", "{", "if", "(", "SNaN", ")", "return", "true", ";", "return", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", "&&", "DAG", ".", "isKnownNeverNaN", "(", "Op", ".", "getOperand", "(", "2", ")", ",", "SNaN", ",", "Depth", "+", "1", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_fdot2", ":", "return", "SNaN", ";", "default", ":", "return", "false", ";", "}", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::FMIN_LEGACY", "AMDGPUISD::FMAX_LEGACY", "AMDGPUISD::FMUL_LEGACY", "AMDGPUISD::CVT_PKRTZ_F16_F32", "0", "1", "1", "1", "AMDGPUISD::FMED3", "AMDGPUISD::FMIN3", "AMDGPUISD::FMAX3", "AMDGPUISD::FMAD_FTZ", "0", "1", "1", "1", "2", "1", "AMDGPUISD::CVT_F32_UBYTE0", "AMDGPUISD::CVT_F32_UBYTE1", "AMDGPUISD::CVT_F32_UBYTE2", "AMDGPUISD::CVT_F32_UBYTE3", "AMDGPUISD::RCP", "AMDGPUISD::RSQ", "AMDGPUISD::RCP_LEGACY", "AMDGPUISD::RSQ_LEGACY", "AMDGPUISD::RSQ_CLAMP", "AMDGPUISD::LDEXP", "AMDGPUISD::FRACT", "0", "1", "AMDGPUISD::DIV_SCALE", "AMDGPUISD::DIV_FMAS", "AMDGPUISD::DIV_FIXUP", "AMDGPUISD::TRIG_PREOP", "AMDGPUISD::SIN_HW", "AMDGPUISD::COS_HW", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::amdgcn_cubeid", "Intrinsic::amdgcn_frexp_mant", "1", "1", "Intrinsic::amdgcn_cvt_pkrtz", "1", "1", "2", "1", "Intrinsic::amdgcn_fdot2" ]

[]

[ "<s>", "unsigned", "assignCustomValue", "(", "const", "ARMCallLowering", "::", "ArgInfo", "&", "Arg", ",", "ArrayRef", "<", "CCValAssign", ">", "VAs", ")", "override", "{", "CCValAssign", "VA", "=", "VAs", "[", "0", "]", ";", "assert", "(", "VA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "CCValAssign", "NextVA", "=", "VAs", "[", "1", "]", ";", "assert", "(", "NextVA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "NextVA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "assert", "(", "VA", ".", "getValNo", "(", ")", "==", "NextVA", ".", "getValNo", "(", ")", "&&", "\"Values belong to different arguments\"", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "assert", "(", "NextVA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "unsigned", "NewRegs", "[", "]", "=", "{", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", ",", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", "}", ";", "assignValueToReg", "(", "NewRegs", "[", "0", "]", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ")", ";", "assignValueToReg", "(", "NewRegs", "[", "1", "]", ",", "NextVA", ".", "getLocReg", "(", ")", ",", "NextVA", ")", ";", "bool", "IsLittle", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isLittle", "(", ")", ";", "if", "(", "!", "IsLittle", ")", "std", "::", "swap", "(", "NewRegs", "[", "0", "]", ",", "NewRegs", "[", "1", "]", ")", ";", "MIRBuilder", ".", "buildSequence", "(", "Arg", ".", "Reg", ",", "NewRegs", ",", "{", "0", ",", "32", "}", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Handle", "custom", "values", ",", "which", "may", "be", "passed", "into", "one", "or", "more", "of", "VAs", "." ]

[ "ARM", "ARM", "0", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "1", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "\"Values belong to different arguments\"", "\"Value should be in reg\"", "\"Value should be in reg\"", "32", "32", "0", "1", "ARM", "0", "1", "0", "32", "1" ]

[]

[ "<s>", "TargetPassConfig", "*", "mprocTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "mprocPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "mproc", "mproc", "mproc" ]

[]

[ "<s>", "bool", "TeakRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "Teak", "Teak" ]

[]