Datasets:

---

docz1105

/

ComBack

like 10

[ "<s>", "bool", "SITargetLowering", "::", "isNoopAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "{", "return", "isFlatGlobalAddrSpace", "(", "SrcAS", ",", "AMDGPUASI", ")", "&&", "isFlatGlobalAddrSpace", "(", "DestAS", ",", "AMDGPUASI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "between", "SrcAS", "and", "DestAS", "is", "a", "noop", "." ]

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

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VCFG", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::X0", "RISCV::X1", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8", "RISCV::VCFG" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "2", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpTargetOpValue expects only expressions or an immediate\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_26", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ "Mips", "Mips", "2", "\"getJumpTargetOpValue expects only expressions or an immediate\"", "0", "Mips::fixup_Mips_26", "0" ]

[]

[ "<s>", "virtual", "const", "MCSection", "*", "getExplicitSectionGlobal", "(", "const", "GlobalValue", "*", "GV", ",", "SectionKind", "Kind", ",", "Mangler", "*", "Mang", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "return", "DataSection", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "NVPTX" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Name", "=", "parseMnemonicSuffix", "(", "Name", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "this", ",", "Name", ",", "NameLoc", ")", ")", ";", "bool", "IsMIMG", "=", "Name", ".", "startswith", "(", "\"image_\"", ")", ";", "while", "(", "!", "trySkipToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "OperandMode", "Mode", "=", "OperandMode_Default", ";", "if", "(", "IsMIMG", "&&", "isGFX10Plus", "(", ")", "&&", "Operands", ".", "size", "(", ")", "==", "2", ")", "Mode", "=", "OperandMode_NSA", ";", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ",", "Mode", ")", ";", "trySkipToken", "(", "AsmToken", "::", "Comma", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "{", "checkUnsupportedInstruction", "(", "Name", ",", "NameLoc", ")", ";", "if", "(", "!", "Parser", ".", "hasPendingError", "(", ")", ")", "{", "StringRef", "Msg", "=", "(", "Res", "==", "MatchOperand_ParseFail", ")", "?", "\"failed parsing operand.\"", ":", "\"not a valid operand.\"", ";", "Error", "(", "getLoc", "(", ")", ",", "Msg", ")", ";", "}", "while", "(", "!", "trySkipToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "\"image_\"", "2", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFAbsFree", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", ";", "return", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fabs", "operation", "is", "free", "to", "the", "point", "where", "it", "is", "never", "worthwhile", "to", "replace", "it", "with", "a", "bitwise", "operation", "." ]

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

[]

[ "<s>", "static", "bool", "required_extensions_p", "(", "enum", "rvv_base_type", "type", ")", "{", "return", "type", "==", "RVV_BASE_eew8_index", "||", "type", "==", "RVV_BASE_eew16_index", "||", "type", "==", "RVV_BASE_eew32_index", "||", "type", "==", "RVV_BASE_eew64_index", "||", "type", "==", "RVV_BASE_float_vector", "||", "type", "==", "RVV_BASE_double_trunc_float_vector", "||", "type", "==", "RVV_BASE_double_trunc_vector", "||", "type", "==", "RVV_BASE_widen_lmul1_vector", "||", "type", "==", "RVV_BASE_eew8_interpret", "||", "type", "==", "RVV_BASE_eew16_interpret", "||", "type", "==", "RVV_BASE_eew32_interpret", "||", "type", "==", "RVV_BASE_eew64_interpret", "||", "type", "==", "RVV_BASE_vlmul_ext_x2", "||", "type", "==", "RVV_BASE_vlmul_ext_x4", "||", "type", "==", "RVV_BASE_vlmul_ext_x8", "||", "type", "==", "RVV_BASE_vlmul_ext_x16", "||", "type", "==", "RVV_BASE_vlmul_ext_x32", "||", "type", "==", "RVV_BASE_vlmul_ext_x64", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "type", "has", "required_extensions", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "P2FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"=== Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" ===\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Determining callee saves\\n\"", ")", ";", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

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

[ "P2", "P2", "\"=== Function: \"", "\" ===\\n\"", "\"Determining callee saves\\n\"" ]

[]

[ "<s>", "static", "void", "query", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "&", "AA", ",", "bool", "&", "Read", ",", "bool", "&", "Write", ",", "bool", "&", "Effects", ",", "bool", "&", "StackPointer", ")", "{", "assert", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", "&&", "!", "MI", ".", "isDereferenceableInvariantLoad", "(", "&", "AA", ")", ")", "Read", "=", "true", ";", "if", "(", "MI", ".", "mayStore", "(", ")", ")", "{", "Write", "=", "true", ";", "}", "else", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "{", "Write", "=", "true", ";", "Effects", "=", "true", ";", "}", "break", ";", "}", "}", "if", "(", "MI", ".", "hasUnmodeledSideEffects", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "Effects", "=", "true", ";", "break", ";", "}", "}", "if", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "GLOBAL_SET_I32", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "GLOBAL_SET_I64", ")", "&&", "strcmp", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "StackPointer", "=", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "{", "queryCallee", "(", "MI", ",", "Read", ",", "Write", ",", "Effects", ",", "StackPointer", ")", ";", "}", "}", "</s>" ]

[ "Query", "a", "line", "of", "the", "assigned", "virtual", "register", "matrix", "directly", "." ]

[ "WebAssembly", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::GLOBAL_SET_I32", "WebAssembly::GLOBAL_SET_I64", "0", "\"__stack_pointer\"", "0" ]

[]

[ "<s>", "static", "FRV_INLINE", "bool", "frv_small_data_reloc_p", "(", "rtx", "symbol", ",", "int", "reloc", ")", "{", "return", "(", "GET_CODE", "(", "symbol", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "symbol", ")", "&&", "(", "!", "TARGET_FDPIC", "||", "flag_pic", "==", "1", ")", "&&", "(", "reloc", "==", "R_FRV_GOTOFF12", "||", "reloc", "==", "R_FRV_GPREL12", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL", "is", "a", "small", "data", "symbol", "and", "relocation", "RELOC", "can", "be", "used", "to", "access", "it", "directly", "in", "a", "load", "or", "store", "." ]

[ "frv", "1" ]

[]

[ "<s>", "void", "Nios2TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "Nios2", "Nios2" ]

[]

[ "<s>", "bool", "SICTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "SIC", "SIC" ]

[]

[ "<s>", "int", "frv_emit_cond_move", "(", "rtx", "dest", ",", "rtx", "test_rtx", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "rtx", "set", ";", "rtx", "clobber_cc", ";", "rtx", "test2", ";", "rtx", "cr_reg", ";", "rtx", "if_rtx", ";", "enum", "rtx_code", "test", "=", "GET_CODE", "(", "test_rtx", ")", ";", "rtx", "cc_reg", "=", "frv_emit_comparison", "(", "test", ",", "frv_compare_op0", ",", "frv_compare_op1", ")", ";", "enum", "machine_mode", "cc_mode", "=", "GET_MODE", "(", "cc_reg", ")", ";", "if", "(", "GET_CODE", "(", "src1", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "src2", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "value1", "=", "INTVAL", "(", "src1", ")", ";", "HOST_WIDE_INT", "value2", "=", "INTVAL", "(", "src2", ")", ";", "if", "(", "value1", "==", "0", "||", "value2", "==", "0", ")", ";", "else", "if", "(", "IN_RANGE_P", "(", "value1", ",", "-", "2048", ",", "2047", ")", "&&", "IN_RANGE_P", "(", "value2", "-", "value1", ",", "-", "2048", ",", "2047", ")", ")", ";", "else", "{", "src1", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src1", ")", ";", "src2", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src2", ")", ";", "}", "}", "else", "{", "if", "(", "GET_CODE", "(", "src1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src1", ")", "!=", "0", ")", "src1", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src1", ")", ";", "if", "(", "GET_CODE", "(", "src2", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src2", ")", "!=", "0", ")", "src2", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src2", ")", ";", "}", "test2", "=", "gen_rtx_fmt_ee", "(", "test", ",", "cc_mode", ",", "cc_reg", ",", "const0_rtx", ")", ";", "if_rtx", "=", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dest", ")", ",", "test2", ",", "src1", ",", "src2", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "if_rtx", ")", ";", "cr_reg", "=", "(", "(", "TARGET_ALLOC_CC", ")", "?", "gen_reg_rtx", "(", "CC_CCRmode", ")", ":", "gen_rtx_REG", "(", "CC_CCRmode", ",", "(", "cc_mode", "==", "CC_FPmode", ")", "?", "FCR_FIRST", ":", "ICR_FIRST", ")", ")", ";", "clobber_cc", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "cr_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber_cc", ")", ")", ")", ";", "return", "TRUE", ";", "}", "</s>" ]

[ "Emit", "the", "code", "for", "a", "conditional", "move", ",", "return", "TRUE", "if", "we", "could", "do", "the", "move", "." ]

[ "frv", "0", "0", "2048", "2047", "2048", "2047", "0", "0", "2" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", "||", "VT", "==", "MVT", "::", "Other", ")", "return", "false", ";", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "bool", "AlignedBy4", "=", "(", "Align", "%", "4", "==", "0", ")", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "AlignedBy4", ";", "return", "AlignedBy4", ";", "}", "if", "(", "VT", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "return", "false", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "true", ";", "return", "VT", ".", "bitsGT", "(", "MVT", "::", "i32", ")", "&&", "Align", "%", "4", "==", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "AMDGPU", "SI", "MVT::Other", "AMDGPU", "4", "0", "MVT::i32", "MVT::i32", "4", "0" ]

[]

[ "<s>", "unsigned", "MINA32MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"did not expect relocated expression\"", ")", ";", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "\"did not expect relocated expression\"" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "AM", ".", "BaseOffs", "!=", "0", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseOffs", "<=", "-", "(", "1LL", "<<", "16", ")", "||", "AM", ".", "BaseOffs", ">=", "(", "1LL", "<<", "16", ")", "-", "1", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "case", "2", ":", "if", "(", "AM", ".", "HasBaseReg", "||", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "PowerPC", "PPC", "0", "1LL", "16", "1LL", "16", "1", "0", "1", "2" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "AArch64", "::", "SP", ")", ".", "Case", "(", "\"x1\"", ",", "AArch64", "::", "X1", ")", ".", "Case", "(", "\"w1\"", ",", "AArch64", "::", "W1", ")", ".", "Case", "(", "\"x2\"", ",", "AArch64", "::", "X2", ")", ".", "Case", "(", "\"w2\"", ",", "AArch64", "::", "W2", ")", ".", "Case", "(", "\"x3\"", ",", "AArch64", "::", "X3", ")", ".", "Case", "(", "\"w3\"", ",", "AArch64", "::", "W3", ")", ".", "Case", "(", "\"x4\"", ",", "AArch64", "::", "X4", ")", ".", "Case", "(", "\"w4\"", ",", "AArch64", "::", "W4", ")", ".", "Case", "(", "\"x5\"", ",", "AArch64", "::", "X5", ")", ".", "Case", "(", "\"w5\"", ",", "AArch64", "::", "W5", ")", ".", "Case", "(", "\"x6\"", ",", "AArch64", "::", "X6", ")", ".", "Case", "(", "\"w6\"", ",", "AArch64", "::", "W6", ")", ".", "Case", "(", "\"x7\"", ",", "AArch64", "::", "X7", ")", ".", "Case", "(", "\"w7\"", ",", "AArch64", "::", "W7", ")", ".", "Case", "(", "\"x18\"", ",", "AArch64", "::", "X18", ")", ".", "Case", "(", "\"w18\"", ",", "AArch64", "::", "W18", ")", ".", "Case", "(", "\"x20\"", ",", "AArch64", "::", "X20", ")", ".", "Case", "(", "\"w20\"", ",", "AArch64", "::", "W20", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "(", "(", "Reg", "==", "AArch64", "::", "X1", "||", "Reg", "==", "AArch64", "::", "W1", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "1", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X2", "||", "Reg", "==", "AArch64", "::", "W2", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "2", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X3", "||", "Reg", "==", "AArch64", "::", "W3", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "3", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X4", "||", "Reg", "==", "AArch64", "::", "W4", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "4", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X5", "||", "Reg", "==", "AArch64", "::", "W5", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "5", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X6", "||", "Reg", "==", "AArch64", "::", "W6", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "6", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X7", "||", "Reg", "==", "AArch64", "::", "W7", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "7", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X18", "||", "Reg", "==", "AArch64", "::", "W18", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "18", ")", ")", "||", "(", "(", "Reg", "==", "AArch64", "::", "X20", "||", "Reg", "==", "AArch64", "::", "W20", ")", "&&", "!", "Subtarget", "->", "isXRegisterReserved", "(", "20", ")", ")", ")", "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", "\"sp\"", "AArch64::SP", "\"x1\"", "AArch64::X1", "\"w1\"", "AArch64::W1", "\"x2\"", "AArch64::X2", "\"w2\"", "AArch64::W2", "\"x3\"", "AArch64::X3", "\"w3\"", "AArch64::W3", "\"x4\"", "AArch64::X4", "\"w4\"", "AArch64::W4", "\"x5\"", "AArch64::X5", "\"w5\"", "AArch64::W5", "\"x6\"", "AArch64::X6", "\"w6\"", "AArch64::W6", "\"x7\"", "AArch64::X7", "\"w7\"", "AArch64::W7", "\"x18\"", "AArch64::X18", "\"w18\"", "AArch64::W18", "\"x20\"", "AArch64::X20", "\"w20\"", "AArch64::W20", "0", "AArch64::X1", "AArch64::W1", "1", "AArch64::X2", "AArch64::W2", "2", "AArch64::X3", "AArch64::W3", "3", "AArch64::X4", "AArch64::W4", "4", "AArch64::X5", "AArch64::W5", "5", "AArch64::X6", "AArch64::W6", "6", "AArch64::X7", "AArch64::W7", "7", "AArch64::X18", "AArch64::W18", "18", "AArch64::X20", "AArch64::W20", "20", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"unexpected inline asm memory operand\"", "\"[\"", "\"]\"" ]

[]

[ "<s>", "const", "char", "*", "pa_output_parallel_movb", "(", "rtx", "*", "operands", ",", "rtx_insn", "*", "insn", ")", "{", "int", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", "==", "4", ")", "return", "\"mov%I1b,tr %1,%0,%2\"", ";", "if", "(", "length", "==", "8", ")", "{", "if", "(", "dbr_sequence_length", "(", ")", "==", "0", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "return", "\"b %2\\n\\tldi %1,%0\"", ";", "else", "return", "\"b %2\\n\\tcopy %1,%0\"", ";", "}", "else", "{", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "return", "\"ldi %1,%0\\n\\tb %2\"", ";", "else", "return", "\"copy %1,%0\\n\\tb %2\"", ";", "}", "}", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "output_asm_insn", "(", "\"ldi %1,%0\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"copy %1,%0\"", ",", "operands", ")", ";", "return", "pa_output_lbranch", "(", "operands", "[", "2", "]", ",", "insn", ",", "1", ")", ";", "}", "</s>" ]

[ "Output", "an", "unconditional", "move", "and", "branch", "insn", "." ]

[ "pa", "4", "\"mov%I1b,tr %1,%0,%2\"", "8", "0", "1", "\"b %2\\n\\tldi %1,%0\"", "\"b %2\\n\\tcopy %1,%0\"", "1", "\"ldi %1,%0\\n\\tb %2\"", "\"copy %1,%0\\n\\tb %2\"", "1", "\"ldi %1,%0\"", "\"copy %1,%0\"", "2", "1" ]

[]

[ "<s>", "static", "bool", "s390_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_VX", "&&", "VECTOR_NOFP_REGNO_P", "(", "regno", ")", ")", "return", "false", ";", "switch", "(", "REGNO_REG_CLASS", "(", "regno", ")", ")", "{", "case", "VEC_REGS", ":", "return", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "s390_class_max_nregs", "(", "VEC_REGS", ",", "mode", ")", "==", "1", ")", "||", "mode", "==", "DFmode", "||", "(", "TARGET_VXE", "&&", "mode", "==", "SFmode", ")", "||", "s390_vector_mode_supported_p", "(", "mode", ")", ")", ";", "break", ";", "case", "FP_REGS", ":", "if", "(", "TARGET_VX", "&&", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "s390_class_max_nregs", "(", "FP_REGS", ",", "mode", ")", "==", "1", ")", "||", "mode", "==", "DFmode", "||", "s390_vector_mode_supported_p", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", "return", "true", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_FLOAT", ")", "return", "true", ";", "}", "break", ";", "case", "ADDR_REGS", ":", "if", "(", "FRAME_REGNO_P", "(", "regno", ")", "&&", "mode", "==", "Pmode", ")", "return", "true", ";", "case", "GENERAL_REGS", ":", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "TARGET_ZARCH", "||", "(", "mode", "!=", "TFmode", "&&", "mode", "!=", "TCmode", "&&", "mode", "!=", "TDmode", ")", ")", "return", "true", ";", "}", "break", ";", "case", "CC_REGS", ":", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "true", ";", "break", ";", "case", "ACCESS_REGS", ":", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "Pmode", ")", "return", "true", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "legal", "to", "put", "a", "value", "with", "MODE", "into", "REGNO", "." ]

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

[]

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

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

[ "Lanai", "\"Lanai Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "ARCompactRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "ARC", "::", "FP", ";", "}", "</s>" ]

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

[ "ARCompact", "ARC", "ARC::FP" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isCandidateToMergeOrPair", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "assert", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "\"Expected a reg operand.\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "unsigned", "BaseReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "BaseReg", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "isLdStPairSuppressed", "(", "MI", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "avoidQuadLdStPairs", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "STRQui", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "load/store", "that", "can", "be", "potentially", "paired/merged", "." ]

[ "AArch64", "AArch64", "1", "\"Expected a reg operand.\"", "2", "1", "AArch64::LDURQi", "AArch64::STURQi", "AArch64::LDRQui", "AArch64::STRQui" ]

[]

[ "<s>", "MachineInstr", "*", "PPCInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "RLWIMI", ")", "return", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "unsigned", "Reg0", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Reg1", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "bool", "Reg1IsKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "bool", "Reg2IsKill", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "isKill", "(", ")", ";", "bool", "ChangeReg0", "=", "false", ";", "if", "(", "Reg0", "==", "Reg1", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getOperandConstraint", "(", "0", ",", "MCOI", "::", "TIED_TO", ")", "&&", "\"Expecting a two-address instruction!\"", ")", ";", "Reg2IsKill", "=", "false", ";", "ChangeReg0", "=", "true", ";", "}", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "unsigned", "ME", "=", "MI", "->", "getOperand", "(", "5", ")", ".", "getImm", "(", ")", ";", "if", "(", "NewMI", ")", "{", "unsigned", "Reg0", "=", "ChangeReg0", "?", "Reg2", ":", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "Reg0IsDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "return", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "MI", "->", "getDesc", "(", ")", ")", ".", "addReg", "(", "Reg0", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "Reg0IsDead", ")", ")", ".", "addReg", "(", "Reg2", ",", "getKillRegState", "(", "Reg2IsKill", ")", ")", ".", "addReg", "(", "Reg1", ",", "getKillRegState", "(", "Reg1IsKill", ")", ")", ".", "addImm", "(", "(", "ME", "+", "1", ")", "&", "31", ")", ".", "addImm", "(", "(", "MB", "-", "1", ")", "&", "31", ")", ";", "}", "if", "(", "ChangeReg0", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "Reg2", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setReg", "(", "Reg1", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "Reg2", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setIsKill", "(", "Reg1IsKill", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "Reg2IsKill", ")", ";", "MI", "->", "getOperand", "(", "4", ")", ".", "setImm", "(", "(", "ME", "+", "1", ")", "&", "31", ")", ";", "MI", "->", "getOperand", "(", "5", ")", ".", "setImm", "(", "(", "MB", "-", "1", ")", "&", "31", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "PowerPC", "PPC", "PPC::RLWIMI", "3", "0", "0", "0", "1", "2", "1", "2", "0", "\"Expecting a two-address instruction!\"", "4", "5", "0", "0", "1", "31", "1", "31", "0", "2", "1", "2", "1", "4", "1", "31", "5", "1", "31" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "unsigned", "SP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "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", ")", "." ]

[ "Mips", "Mips", "Mips", "Mips", "0", "Mips::ADJCALLSTACKDOWN", "Mips::SP_64", "Mips::SP" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBuildVectorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ",", "*", "this", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::VECTOR_SHUFFLE", "ISD::BUILD_VECTOR", "ISD::SELECT", "X86ISD::CMOV", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::STORE", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT" ]

[]

[ "<s>", "bool", "AMDGPUDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "pru_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "regi", "=", "pru_function_arg_regi", "(", "cum_v", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ")", ";", "if", "(", "regi", ">=", "0", ")", "pru_function_arg_regi_mark_slot", "(", "regi", ",", "cum_v", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "argument", "ARG", "." ]

[ "pru", "0" ]

[]

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

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

[ "AVR" ]

[]

[ "<s>", "rtx", "rs6000_emit_eqne", "(", "machine_mode", "mode", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "scratch", ")", "{", "if", "(", "op2", "==", "const0_rtx", ")", "return", "op1", ";", "if", "(", "GET_CODE", "(", "scratch", ")", "==", "SCRATCH", ")", "scratch", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "logical_operand", "(", "op2", ",", "mode", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "gen_rtx_XOR", "(", "mode", ",", "op1", ",", "op2", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "gen_rtx_PLUS", "(", "mode", ",", "op1", ",", "negate_rtx", "(", "mode", ",", "op2", ")", ")", ")", ")", ";", "return", "scratch", ";", "}", "</s>" ]

[ "Emit", "RTL", "that", "sets", "a", "register", "to", "zero", "if", "OP1", "and", "OP2", "are", "equal", ".", "SCRATCH", "can", "be", "used", "as", "that", "dest", "register", ".", "Return", "the", "dest", "register", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "csky_layout_stack_frame", "(", "void", ")", "{", "machine_function", "*", "infp", "=", "cfun", "->", "machine", ";", "int", "reg_count", ";", "if", "(", "infp", "->", "frame_init_p", ")", "return", ";", "infp", "->", "outbound_size", "=", "CSKY_STACK_ALIGN", "(", "crtl", "->", "outgoing_args_size", ")", ";", "infp", "->", "local_offset", "=", "infp", "->", "outbound_size", ";", "infp", "->", "local_size", "=", "CSKY_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "infp", "->", "reg_offset", "=", "infp", "->", "local_offset", "+", "infp", "->", "local_size", ";", "infp", "->", "reg_mask", "=", "get_csky_live_regs", "(", "&", "reg_count", ")", ";", "infp", "->", "reg_size", "=", "reg_count", "*", "UNITS_PER_WORD", ";", "infp", "->", "arg_offset", "=", "infp", "->", "reg_offset", "+", "infp", "->", "reg_size", ";", "infp", "->", "arg_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "infp", "->", "frame_size", "=", "infp", "->", "arg_offset", "+", "infp", "->", "arg_size", ";", "infp", "->", "frame_init_p", "=", "reload_completed", ";", "}", "</s>" ]

[ "Compute", "the", "stack", "frame", "layout", ",", "storing", "sizes", "of", "the", "various", "pieces", "in", "cfun-", ">", "machine", ".", "Stack", "frames", "constructed", "in", "the", "prologue", "look", "like", ":", "...", "caller", "'s", "frame", "...", "incoming", "SP", "-", ">", "caller", "'s", "outbound", "argument", "overflow", "argument", "spill", "optional", "FP", "-", ">", "register", "save", "local", "variables", "alloca", "(", ")", "space", "adjusted", "SP", "-", ">", "outbound", "argument", "overflow", "with", "SP/FP", "pointing", "at", "the", "base", "(", "low", "address", ")", "of", "the", "respective", "area", ",", "and", "each", "area", "aligned", "to", "a", "word", "boundary", "." ]

[ "csky" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

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

[]

[ "<s>", "rtx_insn", "*", "s390_emit_call", "(", "rtx", "addr_location", ",", "rtx", "tls_call", ",", "rtx", "result_reg", ",", "rtx", "retaddr_reg", ")", "{", "bool", "plt_call", "=", "false", ";", "rtx_insn", "*", "insn", ";", "rtx", "vec", "[", "4", "]", "=", "{", "NULL_RTX", "}", ";", "int", "elts", "=", "0", ";", "rtx", "*", "call", "=", "&", "vec", "[", "0", "]", ";", "rtx", "*", "clobber_ret_reg", "=", "&", "vec", "[", "1", "]", ";", "rtx", "*", "use", "=", "&", "vec", "[", "2", "]", ";", "rtx", "*", "clobber_thunk_reg", "=", "&", "vec", "[", "3", "]", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "addr_location", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "flag_pic", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "addr_location", ")", ")", "{", "if", "(", "TARGET_64BIT", "||", "retaddr_reg", "!=", "NULL_RTX", ")", "{", "addr_location", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "addr_location", ")", ",", "UNSPEC_PLT", ")", ";", "addr_location", "=", "gen_rtx_CONST", "(", "Pmode", ",", "addr_location", ")", ";", "plt_call", "=", "true", ";", "}", "else", "addr_location", "=", "force_reg", "(", "Pmode", ",", "addr_location", ")", ";", "}", "if", "(", "!", "TARGET_SMALL_EXEC", "&&", "!", "TARGET_CPU_ZARCH", ")", "{", "if", "(", "flag_pic", ")", "addr_location", "=", "legitimize_pic_address", "(", "addr_location", ",", "0", ")", ";", "else", "addr_location", "=", "force_reg", "(", "Pmode", ",", "addr_location", ")", ";", "}", "}", "if", "(", "retaddr_reg", "==", "NULL_RTX", "&&", "GET_CODE", "(", "addr_location", ")", "!=", "SYMBOL_REF", "&&", "!", "plt_call", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "SIBCALL_REGNUM", ")", ",", "addr_location", ")", ";", "addr_location", "=", "gen_rtx_REG", "(", "Pmode", ",", "SIBCALL_REGNUM", ")", ";", "}", "if", "(", "TARGET_INDIRECT_BRANCH_NOBP_CALL", "&&", "GET_CODE", "(", "addr_location", ")", "!=", "SYMBOL_REF", "&&", "!", "plt_call", ")", "{", "addr_location", "=", "force_reg", "(", "Pmode", ",", "addr_location", ")", ";", "if", "(", "!", "TARGET_CPU_Z10", ")", "{", "*", "clobber_thunk_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ")", ";", "*", "clobber_thunk_reg", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "*", "clobber_thunk_reg", ")", ";", "}", "}", "addr_location", "=", "gen_rtx_MEM", "(", "QImode", ",", "addr_location", ")", ";", "*", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "addr_location", ",", "const0_rtx", ")", ";", "if", "(", "result_reg", "!=", "NULL_RTX", ")", "*", "call", "=", "gen_rtx_SET", "(", "result_reg", ",", "*", "call", ")", ";", "if", "(", "retaddr_reg", "!=", "NULL_RTX", ")", "{", "*", "clobber_ret_reg", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "retaddr_reg", ")", ";", "if", "(", "tls_call", "!=", "NULL_RTX", ")", "*", "use", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "tls_call", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "if", "(", "vec", "[", "i", "]", "!=", "NULL_RTX", ")", "elts", "++", ";", "if", "(", "elts", ">", "1", ")", "{", "rtvec", "v", ";", "int", "e", "=", "0", ";", "v", "=", "rtvec_alloc", "(", "elts", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "if", "(", "vec", "[", "i", "]", "!=", "NULL_RTX", ")", "{", "RTVEC_ELT", "(", "v", ",", "e", ")", "=", "vec", "[", "i", "]", ";", "e", "++", ";", "}", "*", "call", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "v", ")", ";", "}", "insn", "=", "emit_call_insn", "(", "*", "call", ")", ";", "if", "(", "(", "!", "TARGET_64BIT", "&&", "plt_call", ")", "||", "tls_call", "!=", "NULL_RTX", ")", "{", "gcc_assert", "(", "retaddr_reg", "!=", "NULL_RTX", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "by", "the", "call", "expanders", "of", "the", "machine", "description", ".", "It", "emits", "the", "call", "insn", "itself", "together", "with", "the", "necessary", "operations", "to", "adjust", "the", "target", "address", "and", "returns", "the", "emitted", "insn", ".", "ADDR_LOCATION", "is", "the", "target", "address", "rtx", "TLS_CALL", "the", "location", "of", "the", "thread-local", "symbol", "RESULT_REG", "the", "register", "where", "the", "result", "of", "the", "call", "should", "be", "stored", "RETADDR_REG", "the", "register", "where", "the", "return", "address", "should", "be", "stored", "If", "this", "parameter", "is", "NULL_RTX", "the", "call", "is", "considered", "to", "be", "a", "sibling", "call", "." ]

[ "s390", "4", "0", "0", "1", "2", "3", "1", "0", "0", "4", "1", "0", "0", "4", "12" ]

[]

[ "<s>", "static", "int", "compare_lmul", "(", "vlmul_type", "vlmul1", ",", "vlmul_type", "vlmul2", ")", "{", "if", "(", "vlmul1", "==", "vlmul2", ")", "return", "0", ";", "switch", "(", "vlmul1", ")", "{", "case", "LMUL_1", ":", "if", "(", "vlmul2", "==", "LMUL_2", "||", "vlmul2", "==", "LMUL_4", "||", "vlmul2", "==", "LMUL_8", ")", "return", "1", ";", "else", "return", "-", "1", ";", "case", "LMUL_2", ":", "if", "(", "vlmul2", "==", "LMUL_4", "||", "vlmul2", "==", "LMUL_8", ")", "return", "1", ";", "else", "return", "-", "1", ";", "case", "LMUL_4", ":", "if", "(", "vlmul2", "==", "LMUL_8", ")", "return", "1", ";", "else", "return", "-", "1", ";", "case", "LMUL_8", ":", "return", "-", "1", ";", "case", "LMUL_F2", ":", "if", "(", "vlmul2", "==", "LMUL_1", "||", "vlmul2", "==", "LMUL_2", "||", "vlmul2", "==", "LMUL_4", "||", "vlmul2", "==", "LMUL_8", ")", "return", "1", ";", "else", "return", "-", "1", ";", "case", "LMUL_F4", ":", "if", "(", "vlmul2", "==", "LMUL_F2", "||", "vlmul2", "==", "LMUL_1", "||", "vlmul2", "==", "LMUL_2", "||", "vlmul2", "==", "LMUL_4", "||", "vlmul2", "==", "LMUL_8", ")", "return", "1", ";", "else", "return", "-", "1", ";", "case", "LMUL_F8", ":", "return", "0", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "return", "0", "if", "LMUL1", "==", "LMUL2", ".", "return", "-1", "if", "LMUL1", "<", "LMUL2", ".", "return", "1", "if", "LMUL1", ">", "LMUL2", "." ]

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

[]

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

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

[ "MSP430" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "AArch64A53Fix835769", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A53Fix835769 *****\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "F", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64A53Fix835769 *****\\n\"" ]

[]

[ "<s>", "SDValue", "TOYTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "TOY", "TOY", "ISD::BR_CC" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "2", "&&", "\"All AArch64 cmps should have 2 operands\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "SUBSWrr", ":", "case", "AArch64", "::", "SUBSWrs", ":", "case", "AArch64", "::", "SUBSWrx", ":", "case", "AArch64", "::", "SUBSXrr", ":", "case", "AArch64", "::", "SUBSXrs", ":", "case", "AArch64", "::", "SUBSXrx", ":", "case", "AArch64", "::", "ADDSWrr", ":", "case", "AArch64", "::", "ADDSWrs", ":", "case", "AArch64", "::", "ADDSWrx", ":", "case", "AArch64", "::", "ADDSXrr", ":", "case", "AArch64", "::", "ADDSXrs", ":", "case", "AArch64", "::", "ADDSXrx", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWri", ":", "case", "AArch64", "::", "ADDSWri", ":", "case", "AArch64", "::", "SUBSXri", ":", "case", "AArch64", "::", "ADDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "!=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "ANDSWri", ":", "case", "AArch64", "::", "ANDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "AArch64_AM", "::", "decodeLogicalImmediate", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ANDSWri", "?", "32", ":", "64", ")", "!=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "AArch64", "AArch64", "2", "\"All AArch64 cmps should have 2 operands\"", "1", "AArch64::SUBSWrr", "AArch64::SUBSWrs", "AArch64::SUBSWrx", "AArch64::SUBSXrr", "AArch64::SUBSXrs", "AArch64::SUBSXrx", "AArch64::ADDSWrr", "AArch64::ADDSWrs", "AArch64::ADDSWrx", "AArch64::ADDSXrr", "AArch64::ADDSXrs", "AArch64::ADDSXrx", "1", "2", "0", "0", "AArch64::SUBSWri", "AArch64::ADDSWri", "AArch64::SUBSXri", "AArch64::ADDSXri", "1", "0", "0", "2", "0", "AArch64::ANDSWri", "AArch64::ANDSXri", "1", "0", "0", "AArch64_AM::decodeLogicalImmediate", "2", "AArch64::ANDSWri", "32", "64", "0" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "XCore" ]

[]

[ "<s>", "ISD", "::", "NodeType", "getExtendForAtomicCmpSwapArg", "(", ")", "const", "override", "{", "return", "ISD", "::", "SIGN_EXTEND", ";", "}", "</s>" ]

[ "Returns", "how", "the", "platform", "'s", "atomic", "compare", "and", "swap", "expects", "its", "comparison", "value", "to", "be", "extended", "(", "ZERO_EXTEND", ",", "SIGN_EXTEND", ",", "or", "ANY_EXTEND", ")", "." ]

[ "RISCV", "ISD::NodeType", "ISD::SIGN_EXTEND" ]

[]

[ "<s>", "void", "generate_6432_conversion", "(", "rtx", "target", ",", "rtx", "sub_result", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "rtx", "tmp_reg_ca", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_subfdi3_carry_in_xx", "(", "tmp_reg_ca", ")", ")", ";", "rtx", "popcnt", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_popcntddi2", "(", "popcnt", ",", "sub_result", ")", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_iordi3", "(", "tmp2", ",", "popcnt", ",", "tmp_reg_ca", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "target", ",", "gen_lowpart", "(", "SImode", ",", "tmp2", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp_reg_ca", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_subfsi3_carry_in_xx", "(", "tmp_reg_ca", ")", ")", ";", "rtx", "popcnt", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_popcntdsi2", "(", "popcnt", ",", "sub_result", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "target", ",", "popcnt", ",", "tmp_reg_ca", ")", ")", ";", "}", "}", "</s>" ]

[ "Generate", "code", "to", "convert", "a", "DImode-plus-carry", "subtract", "result", "into", "a", "SImode", "result", "that", "has", "the", "same", "<", "0", "/", "==0", "/", ">", "0", "properties", "to", "produce", "the", "final", "result", "from", "memcmp", ".", "TARGET", "is", "the", "rtx", "for", "the", "register", "to", "receive", "the", "memcmp", "result", ".", "SUB_RESULT", "is", "the", "rtx", "for", "the", "register", "contining", "the", "subtract", "result", "." ]

[ "rs6000" ]

[]

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

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

[ "Hexagon", "\"Hexagon NewValueJump\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Ins", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "MSP430", "MSP430", "ISD::InputArg", "16", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "rtx", "avr_addr_space_convert", "(", "rtx", "src", ",", "tree", "type_from", ",", "tree", "type_to", ")", "{", "addr_space_t", "as_from", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_from", ")", ")", ";", "addr_space_t", "as_to", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_to", ")", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", ",", "src", ",", "type_from", ",", "type_to", ")", ";", "if", "(", "as_from", "!=", "ADDR_SPACE_MEMX", "&&", "as_to", "==", "ADDR_SPACE_MEMX", ")", "{", "int", "msb", ";", "rtx", "sym", "=", "src", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "PSImode", ")", ";", "while", "(", "CONST", "==", "GET_CODE", "(", "sym", ")", "||", "PLUS", "==", "GET_CODE", "(", "sym", ")", ")", "sym", "=", "XEXP", "(", "sym", ",", "0", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "sym", ")", "&&", "ADDR_SPACE_FLASH", "==", "AVR_SYMBOL_GET_ADDR_SPACE", "(", "sym", ")", ")", "{", "as_from", "=", "ADDR_SPACE_FLASH", ";", "}", "msb", "=", "ADDR_SPACE_GENERIC_P", "(", "as_from", ")", "?", "0x80", ":", "avr_addrspace", "[", "as_from", "]", ".", "segment", ";", "src", "=", "force_reg", "(", "Pmode", ",", "src", ")", ";", "emit_insn", "(", "msb", "==", "0", "?", "gen_zero_extendhipsi2", "(", "reg", ",", "src", ")", ":", "gen_n_extendhipsi2", "(", "reg", ",", "gen_int_mode", "(", "msb", ",", "QImode", ")", ",", "src", ")", ")", ";", "return", "reg", ";", "}", "if", "(", "as_from", "==", "ADDR_SPACE_MEMX", "&&", "as_to", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "new_src", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "src", "=", "force_reg", "(", "PSImode", ",", "src", ")", ";", "emit_move_insn", "(", "new_src", ",", "simplify_gen_subreg", "(", "Pmode", ",", "src", ",", "PSImode", ",", "0", ")", ")", ";", "return", "new_src", ";", "}", "return", "src", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_CONVERT", "'", "." ]

[ "avr", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", "0", "0x80", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUCallLowering", "::", "splitToValueTypes", "(", "MachineIRBuilder", "&", "B", ",", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "CallingConv", "::", "ID", "CallConv", ")", "const", "{", "const", "SITargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "SITargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ")", ";", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "0", ")", "return", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "0", "]", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", "[", "0", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "\"Regs / types mismatch\"", ")", ";", "bool", "NeedsRegBlock", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "OrigArg", ".", "Ty", ",", "CallConv", ",", "false", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "Type", "*", "SplitTy", "=", "SplitVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "i", "]", ",", "SplitTy", ",", "OrigArg", ".", "Flags", "[", "0", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "if", "(", "NeedsRegBlock", ")", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "0", "]", ".", "setInConsecutiveRegs", "(", ")", ";", "}", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "0", "]", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "4", "0", "1", "0", "0", "0", "\"Regs / types mismatch\"", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "rs6000_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "switch", "(", "size", ")", "{", "case", "4", ":", "fputs", "(", "\"\\t.long\\t\"", ",", "file", ")", ";", "break", ";", "case", "8", ":", "fputs", "(", "DOUBLE_INT_ASM_OP", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\"@dtprel+0x8000\"", ",", "file", ")", ";", "}", "</s>" ]

[ "This", "is", "called", "from", "dwarf2out.c", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

[ "rs6000", "4", "\"\\t.long\\t\"", "8", "\"@dtprel+0x8000\"" ]

[]

[ "<s>", "static", "unsigned", "getHashValue", "(", "const", "CvtDirection", "&", "Val", ")", "{", "return", "(", "Val", ".", "SourceType", "^", "Val", ".", "DestinationType", ")", "*", "37U", ";", "}", "</s>" ]

[ "Using", "name", "and", "line", "to", "get", "hash", "value", ".", "It", "should", "already", "be", "mostly", "unique", "." ]

[ "TPC", "37U" ]

[]

[ "<s>", "static", "bool", "arc_use_anchors_for_symbol_p", "(", "const_rtx", "symbol", ")", "{", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", ")", "return", "false", ";", "if", "(", "flag_pic", ")", "return", "false", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "symbol", ")", ")", "return", "false", ";", "return", "default_use_anchors_for_symbol_p", "(", "symbol", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_USE_ANCHORS_FOR_SYMBOL_P", ".", "We", "do", "n't", "want", "to", "use", "anchors", "for", "small", "data", ":", "the", "GP", "register", "acts", "as", "an", "anchor", "in", "that", "case", ".", "We", "also", "do", "n't", "want", "to", "use", "them", "for", "PC-relative", "accesses", ",", "where", "the", "PC", "acts", "as", "an", "anchor", ".", "Prohibit", "also", "TLS", "symbols", "to", "use", "anchors", "." ]

[ "arc" ]

[]

[ "<s>", "inline", "machine_mode", "function_expander", "::", "vector_mode", "(", "void", ")", "const", "{", "return", "TYPE_MODE", "(", "builtin_types", "[", "type", ".", "index", "]", ".", "vector", ")", ";", "}", "</s>" ]

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

[ "riscv" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpTargetOpValue expects only expressions\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_26", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ "Mips", "Mips", "\"getJumpTargetOpValue expects only expressions\"", "0", "Mips::fixup_Mips_26", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "AVRTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "AVR", "::", "Lsl8", ":", "case", "AVR", "::", "Lsl16", ":", "case", "AVR", "::", "Lsr8", ":", "case", "AVR", "::", "Lsr16", ":", "case", "AVR", "::", "Asr8", ":", "case", "AVR", "::", "Asr16", ":", "return", "insertShift", "(", "MI", ",", "MBB", ")", ";", "case", "AVR", "::", "MULRdRr", ":", "case", "AVR", "::", "MULSRdRr", ":", "return", "insertMul", "(", "MI", ",", "MBB", ")", ";", "}", "assert", "(", "(", "Opc", "==", "AVR", "::", "Select16", "||", "Opc", "==", "AVR", "::", "Select8", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "(", "const", "AVRInstrInfo", "&", ")", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "MBB", "->", "getBasicBlock", "(", ")", ";", "MachineBasicBlock", "*", "trueMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "falseMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "MBB", "->", "getParent", "(", ")", "->", "begin", "(", ")", ";", "++", "I", ";", "MF", "->", "insert", "(", "I", ",", "trueMBB", ")", ";", "MF", "->", "insert", "(", "I", ",", "falseMBB", ")", ";", "trueMBB", "->", "splice", "(", "trueMBB", "->", "begin", "(", ")", ",", "MBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "MBB", "->", "end", "(", ")", ")", ";", "trueMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "MBB", ")", ";", "AVRCC", "::", "CondCodes", "CC", "=", "(", "AVRCC", "::", "CondCodes", ")", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "BuildMI", "(", "MBB", ",", "dl", ",", "TII", ".", "getBrCond", "(", "CC", ")", ")", ".", "addMBB", "(", "trueMBB", ")", ";", "BuildMI", "(", "MBB", ",", "dl", ",", "TII", ".", "get", "(", "AVR", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "falseMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "falseMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "trueMBB", ")", ";", "BuildMI", "(", "falseMBB", ",", "dl", ",", "TII", ".", "get", "(", "AVR", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "trueMBB", ")", ";", "falseMBB", "->", "addSuccessor", "(", "trueMBB", ")", ";", "BuildMI", "(", "*", "trueMBB", ",", "trueMBB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "AVR", "::", "PHI", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "MBB", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "falseMBB", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "trueMBB", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::Lsl8", "AVR::Lsl16", "AVR::Lsr8", "AVR::Lsr16", "AVR::Asr8", "AVR::Asr16", "AVR::MULRdRr", "AVR::MULSRdRr", "AVR::Select16", "AVR::Select8", "\"Unexpected instr type to insert\"", "AVR", "AVR", "AVRCC::CondCodes", "AVRCC::CondCodes", "3", "AVR::RJMPk", "AVR::RJMPk", "AVR::PHI", "0", "1", "2" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AVRFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "TFI", ".", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "false", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "TFI", ".", "getStackAlignment", "(", ")", "==", "1", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "true", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "AVR", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "0", "1", "\"Unsupported stack alignment\"", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30" ]

[]

[ "<s>", "bool", "AVRTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCFunction", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "TOY" ]

[]

[ "<s>", "void", "Thumb2RegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "t2LDRpci", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "(", "int64_t", ")", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "4", "ARM::t2LDRpci", "ARMCC::AL", "0" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "int", "PIdx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "R600", "::", "CF_ALU", ")", "{", "MI", ".", "getOperand", "(", "8", ")", ".", "setImm", "(", "0", ")", ";", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "R600", "::", "DOT_4", ")", "{", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "R600", "::", "OpName", "::", "pred_sel_X", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "R600", "::", "OpName", "::", "pred_sel_Y", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "R600", "::", "OpName", "::", "pred_sel_Z", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "getOperandIdx", "(", "MI", ",", "R600", "::", "OpName", "::", "pred_sel_W", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "R600", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "PIdx", "!=", "-", "1", ")", "{", "MachineOperand", "&", "PMO", "=", "MI", ".", "getOperand", "(", "PIdx", ")", ";", "PMO", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "R600", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "AMDGPU", "R600", "R600::CF_ALU", "8", "0", "R600::DOT_4", "R600::OpName", "2", "R600::OpName", "2", "R600::OpName", "2", "R600::OpName", "2", "R600::PREDICATE_BIT", "1", "2", "R600::PREDICATE_BIT" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "LowerToCopyInstrs", ".", "clear", "(", ")", ";", "CallingConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "unsigned", "LiveMaskReg", "=", "0", ";", "unsigned", "Exec", "=", "ST", "->", "isWave32", "(", ")", "?", "AMDGPU", "::", "EXEC_LO", ":", "AMDGPU", "::", "EXEC", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "Exec", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWWM", ")", ")", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "TRI", "->", "getBoolRC", "(", ")", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "Exec", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ST", "->", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_WQM_B32", ":", "AMDGPU", "::", "S_WQM_B64", ")", ",", "Exec", ")", ".", "addReg", "(", "Exec", ")", ";", "lowerCopyInstrs", "(", ")", ";", "return", "true", ";", "}", "}", "LLVM_DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerCopyInstrs", "(", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "AMDGPU::EXEC_LO", "AMDGPU::EXEC", "AMDGPU::COPY", "AMDGPU::S_WQM_B32", "AMDGPU::S_WQM_B64", "AMDGPU::SCC" ]

[]

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

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "SystemZ", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "mep_repeat_loop_p", "(", "struct", "mep_doloop", "*", "loop", ")", "{", "struct", "mep_doloop_end", "*", "end", ";", "rtx", "fallthrough", ";", "if", "(", "loop", "->", "begin", "==", "0", "||", "loop", "->", "end", "==", "0", "||", "loop", "->", "begin", "->", "next", "!=", "0", ")", "return", "false", ";", "if", "(", "prev_real_insn", "(", "loop", "->", "end", "->", "label", ")", "!=", "loop", "->", "begin", "->", "insn", ")", "return", "false", ";", "fallthrough", "=", "loop", "->", "end", "->", "fallthrough", ";", "for", "(", "end", "=", "loop", "->", "end", "->", "next", ";", "end", "!=", "0", ";", "end", "=", "end", "->", "next", ")", "if", "(", "end", "->", "label", "!=", "loop", "->", "end", "->", "label", "||", "!", "simplejump_p", "(", "end", "->", "fallthrough", ")", "||", "next_real_insn", "(", "JUMP_LABEL", "(", "end", "->", "fallthrough", ")", ")", "!=", "fallthrough", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "LOOP", "can", "be", "converted", "into", "repeat/repeat_end", "form", "(", "that", "is", ",", "if", "it", "matches", "cases", "(", "1", ")", "or", "(", "2", ")", "above", ")", "." ]

[ "mep", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "SystemZMCAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "BitSize", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ";", "unsigned", "Size", "=", "(", "BitSize", "+", "7", ")", "/", "8", ";", "assert", "(", "Offset", "+", "Size", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "Value", "=", "extractBitsForFixup", "(", "Kind", ",", "Value", ")", ";", "if", "(", "BitSize", "<", "64", ")", "Value", "&=", "(", "(", "uint64_t", ")", "1", "<<", "BitSize", ")", "-", "1", ";", "unsigned", "ShiftValue", "=", "(", "Size", "*", "8", ")", "-", "8", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "Size", ";", "++", "I", ")", "{", "Data", "[", "Offset", "+", "I", "]", "|=", "uint8_t", "(", "Value", ">>", "ShiftValue", ")", ";", "ShiftValue", "-=", "8", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "7", "8", "\"Invalid fixup offset!\"", "64", "1", "1", "8", "8", "0", "8" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "aarch64_simd_vector_alignment", "(", "const_tree", "type", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "TYPE_MODE", "(", "type", ")", ")", "==", "MODE_VECTOR_BOOL", ")", "return", "16", ";", "widest_int", "min_size", "=", "constant_lower_bound", "(", "wi", "::", "to_poly_widest", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", ";", "return", "wi", "::", "umin", "(", "min_size", ",", "128", ")", ".", "to_uhwi", "(", ")", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "TARGET_VECTOR_ALIGNMENT", ".", "The", "AAPCS64", "sets", "the", "maximum", "alignment", "of", "a", "vector", "to", "128", "bits", "." ]

[ "aarch64", "16", "128" ]

[]

[ "<s>", "static", "void", "*", "cygwin_gt_pch_get_address", "(", "size_t", "sz", ",", "int", "fd", ")", "{", "void", "*", "base", ";", "off_t", "p", "=", "lseek", "(", "fd", ",", "0", ",", "SEEK_CUR", ")", ";", "if", "(", "p", "==", "(", "off_t", ")", "-", "1", ")", "fatal_error", "(", "\"can't get position in PCH file: %m\"", ")", ";", "if", "(", "(", "size_t", ")", "p", "<", "sz", ")", "{", "if", "(", "ftruncate", "(", "fd", ",", "sz", ")", "==", "-", "1", ")", "fatal_error", "(", "\"can't extend PCH file: %m\"", ")", ";", "}", "base", "=", "mmap", "(", "NULL", ",", "sz", ",", "PROT_READ", "|", "PROT_WRITE", ",", "MAP_PRIVATE", ",", "fd", ",", "0", ")", ";", "if", "(", "base", "==", "MAP_FAILED", ")", "base", "=", "NULL", ";", "else", "munmap", "(", "base", ",", "sz", ")", ";", "if", "(", "lseek", "(", "fd", ",", "p", ",", "SEEK_SET", ")", "==", "(", "off_t", ")", "-", "1", ")", "fatal_error", "(", "\"can't set position in PCH file: %m\"", ")", ";", "return", "base", ";", "}", "</s>" ]

[ "Identify", "an", "address", "that", "'s", "likely", "to", "be", "free", "in", "a", "subsequent", "invocation", "of", "the", "compiler", ".", "The", "area", "should", "be", "able", "to", "hold", "SIZE", "bytes", ".", "FD", "is", "an", "open", "file", "descriptor", "if", "the", "host", "would", "like", "to", "probe", "with", "mmap", "." ]

[ "i386", "0", "1", "\"can't get position in PCH file: %m\"", "1", "\"can't extend PCH file: %m\"", "0", "1", "\"can't set position in PCH file: %m\"" ]

[]

[ "<s>", "static", "Mnode", "*", "add_minipool_forward_ref", "(", "Mfix", "*", "fix", ")", "{", "Mnode", "*", "max_mp", "=", "NULL", ";", "HOST_WIDE_INT", "max_address", "=", "fix", "->", "address", "+", "fix", "->", "forwards", ";", "Mnode", "*", "mp", ";", "if", "(", "minipool_vector_head", "&&", "fix", "->", "address", ">=", "minipool_vector_head", "->", "max_address", "-", "fix", "->", "fix_size", ")", "return", "NULL", ";", "for", "(", "mp", "=", "minipool_vector_head", ";", "mp", "!=", "NULL", ";", "mp", "=", "mp", "->", "next", ")", "{", "if", "(", "GET_CODE", "(", "fix", "->", "value", ")", "==", "GET_CODE", "(", "mp", "->", "value", ")", "&&", "fix", "->", "mode", "==", "mp", "->", "mode", "&&", "(", "GET_CODE", "(", "fix", "->", "value", ")", "!=", "CODE_LABEL", "||", "(", "CODE_LABEL_NUMBER", "(", "fix", "->", "value", ")", "==", "CODE_LABEL_NUMBER", "(", "mp", "->", "value", ")", ")", ")", "&&", "rtx_equal_p", "(", "fix", "->", "value", ",", "mp", "->", "value", ")", ")", "{", "mp", "->", "refcount", "++", ";", "return", "move_minipool_fix_forward_ref", "(", "mp", ",", "max_mp", ",", "max_address", ")", ";", "}", "if", "(", "max_mp", "==", "NULL", "&&", "mp", "->", "max_address", ">", "max_address", ")", "max_mp", "=", "mp", ";", "if", "(", "ARM_DOUBLEWORD_ALIGN", "&&", "max_mp", "==", "NULL", "&&", "fix", "->", "fix_size", "==", "8", "&&", "mp", "->", "fix_size", "!=", "8", ")", "{", "max_mp", "=", "mp", ";", "max_address", "=", "mp", "->", "max_address", ";", "}", "}", "mp", "=", "xmalloc", "(", "sizeof", "(", "*", "mp", ")", ")", ";", "mp", "->", "fix_size", "=", "fix", "->", "fix_size", ";", "mp", "->", "mode", "=", "fix", "->", "mode", ";", "mp", "->", "value", "=", "fix", "->", "value", ";", "mp", "->", "refcount", "=", "1", ";", "mp", "->", "min_address", "=", "-", "65536", ";", "if", "(", "max_mp", "==", "NULL", ")", "{", "mp", "->", "max_address", "=", "max_address", ";", "mp", "->", "next", "=", "NULL", ";", "mp", "->", "prev", "=", "minipool_vector_tail", ";", "if", "(", "mp", "->", "prev", "==", "NULL", ")", "{", "minipool_vector_head", "=", "mp", ";", "minipool_vector_label", "=", "gen_label_rtx", "(", ")", ";", "}", "else", "mp", "->", "prev", "->", "next", "=", "mp", ";", "minipool_vector_tail", "=", "mp", ";", "}", "else", "{", "if", "(", "max_address", ">", "max_mp", "->", "max_address", "-", "mp", "->", "fix_size", ")", "mp", "->", "max_address", "=", "max_mp", "->", "max_address", "-", "mp", "->", "fix_size", ";", "else", "mp", "->", "max_address", "=", "max_address", ";", "mp", "->", "next", "=", "max_mp", ";", "mp", "->", "prev", "=", "max_mp", "->", "prev", ";", "max_mp", "->", "prev", "=", "mp", ";", "if", "(", "mp", "->", "prev", "!=", "NULL", ")", "mp", "->", "prev", "->", "next", "=", "mp", ";", "else", "minipool_vector_head", "=", "mp", ";", "}", "max_mp", "=", "mp", ";", "while", "(", "mp", "->", "prev", "!=", "NULL", "&&", "mp", "->", "prev", "->", "max_address", ">", "mp", "->", "max_address", "-", "mp", "->", "prev", "->", "fix_size", ")", "{", "mp", "->", "prev", "->", "max_address", "=", "mp", "->", "max_address", "-", "mp", "->", "prev", "->", "fix_size", ";", "mp", "=", "mp", "->", "prev", ";", "}", "return", "max_mp", ";", "}", "</s>" ]

[ "Add", "a", "constant", "to", "the", "minipool", "for", "a", "forward", "reference", ".", "Returns", "the", "node", "added", "or", "NULL", "if", "the", "constant", "will", "not", "fit", "in", "this", "pool", "." ]

[ "arm", "8", "8", "1", "65536" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* Hexagon Hardware Loops *********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "TM", "=", "static_cast", "<", "const", "HexagonTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "HexagonRegisterInfo", "*", ">", "(", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ")", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "I", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineLoop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "Changed", "|=", "convertToHardwareLoop", "(", "L", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"********* Hexagon Hardware Loops *********\\n\"", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "rtx", "mips_subword", "(", "rtx", "op", ",", "bool", "high_p", ")", "{", "unsigned", "int", "byte", ",", "offset", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "TARGET_64BIT", "?", "TImode", ":", "DImode", ";", "if", "(", "TARGET_BIG_ENDIAN", "?", "!", "high_p", ":", "high_p", ")", "byte", "=", "UNITS_PER_WORD", ";", "else", "byte", "=", "0", ";", "if", "(", "FP_REG_RTX_P", "(", "op", ")", ")", "{", "offset", "=", "(", "UNITS_PER_WORD", "<", "UNITS_PER_HWFPVALUE", "?", "high_p", ":", "byte", "!=", "0", ")", ";", "return", "gen_rtx_REG", "(", "word_mode", ",", "REGNO", "(", "op", ")", "+", "offset", ")", ";", "}", "if", "(", "MEM_P", "(", "op", ")", ")", "return", "mips_rewrite_small_data", "(", "adjust_address", "(", "op", ",", "word_mode", ",", "byte", ")", ")", ";", "return", "simplify_gen_subreg", "(", "word_mode", ",", "op", ",", "mode", ",", "byte", ")", ";", "}", "</s>" ]

[ "Return", "one", "word", "of", "double-word", "value", "OP", ",", "taking", "into", "account", "the", "fixed", "endianness", "of", "certain", "registers", ".", "HIGH_P", "is", "true", "to", "select", "the", "high", "part", ",", "false", "to", "select", "the", "low", "part", "." ]

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

[]

[ "<s>", "static", "rtx", "mips_return_fpr_single", "(", "machine_mode", "type_mode", ",", "machine_mode", "value_mode", ")", "{", "rtx", "x", ";", "x", "=", "gen_rtx_REG", "(", "value_mode", ",", "FP_RETURN", ")", ";", "if", "(", "type_mode", "!=", "value_mode", ")", "{", "x", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "x", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_PARALLEL", "(", "type_mode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Return", "the", "representation", "of", "an", "FPR", "return", "register", "when", "the", "value", "being", "returned", "in", "FP_RETURN", "has", "mode", "VALUE_MODE", "and", "the", "return", "type", "itself", "has", "mode", "TYPE_MODE", ".", "On", "NewABI", "targets", ",", "the", "two", "modes", "may", "be", "different", "for", "structures", "like", ":", "struct", "__attribute__", "(", "(", "packed", ")", ")", "foo", "{", "float", "f", ";", "}", "where", "we", "return", "the", "SFmode", "value", "of", "``", "f", "''", "in", "FP_RETURN", ",", "but", "where", "the", "structure", "itself", "has", "mode", "BLKmode", "." ]

[ "mips", "1" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolution", ">", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "hasFP", "(", "MF", ")", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ";", "else", "return", "hasFP", "(", "MF", ")", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::R31", "PPC::R1", "PPC::X31", "PPC::X1" ]

[]

[ "<s>", "int", "AMDGPUFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "OffsetBytes", "=", "2", "*", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "int", "UpperBound", "=", "FI", "==", "-", "1", "?", "MFI", "->", "getNumObjects", "(", ")", ":", "FI", ";", "for", "(", "int", "i", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "i", "<", "UpperBound", ";", "++", "i", ")", "{", "OffsetBytes", "=", "RoundUpToAlignment", "(", "OffsetBytes", ",", "MFI", "->", "getObjectAlignment", "(", "i", ")", ")", ";", "OffsetBytes", "+=", "MFI", "->", "getObjectSize", "(", "i", ")", ";", "OffsetBytes", "=", "RoundUpToAlignment", "(", "OffsetBytes", ",", "4", ")", ";", "}", "if", "(", "FI", "!=", "-", "1", ")", "OffsetBytes", "=", "RoundUpToAlignment", "(", "OffsetBytes", ",", "MFI", "->", "getObjectAlignment", "(", "FI", ")", ")", ";", "return", "OffsetBytes", "/", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "2", "4", "1", "4", "1", "4" ]

[]

[ "<s>", "MachineInstr", "*", "LanaiInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", ")", "const", "{", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "Lanai", "::", "SELECT", "&&", "\"unknown select instruction\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "1", ":", "2", ")", ";", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "PreviousClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "PreviousClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "addOperand", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "getOppositeCondition", "(", "LPCC", "::", "CondCode", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "copyImplicitOps", "(", "MI", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "addOperand", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "0", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "if", "(", "DefMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", ")", "NewMI", "->", "clearKillInfo", "(", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}", "</s>" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ "Lanai", "Lanai", "Lanai::SELECT", "\"unknown select instruction\"", "1", "2", "1", "2", "0", "1", "3", "0", "1" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getAddrModeArguments", "(", "IntrinsicInst", "*", "II", ",", "SmallVectorImpl", "<", "Value", "*", ">", "&", "Ops", ",", "Type", "*", "&", "AccessTy", ")", "const", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "{", "Value", "*", "Ptr", "=", "II", "->", "getArgOperand", "(", "0", ")", ";", "AccessTy", "=", "II", "->", "getType", "(", ")", ";", "Ops", ".", "push_back", "(", "Ptr", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "CodeGenPrepare", "sinks", "address", "calculations", "into", "the", "same", "BB", "as", "Load/Store", "instructions", "reading", "the", "address", "." ]

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "0" ]

[]

[ "<s>", "unsigned", "getMappedIdxOpcForImmOpc", "(", "unsigned", "ImmOpcode", ")", "const", "{", "if", "(", "!", "ImmToIdxMap", ".", "count", "(", "ImmOpcode", ")", ")", "return", "PPC", "::", "INSTRUCTION_LIST_END", ";", "return", "ImmToIdxMap", ".", "find", "(", "ImmOpcode", ")", "->", "second", ";", "}", "</s>" ]

[ "getMappedIdxOpcForImmOpc", "-", "Return", "the", "mapped", "index", "form", "load/store", "opcode", "for", "a", "given", "imm", "form", "load/store", "opcode", "ImmFormOpcode", "." ]

[ "PowerPC", "PPC::INSTRUCTION_LIST_END" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "SubTarget", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "if", "(", "NumBytes", ">=", "-", "4096", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SAVEri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "NumBytes", ">>", "10U", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ORri", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addImm", "(", "NumBytes", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SAVErr", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "4096", "SP::O6", "SP::O6", "10U", "SP::SETHIi", "SP::G1", "SP::ORri", "SP::G1", "SP::G1", "1", "10", "1", "SP::O6", "SP::O6", "SP::G1" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createMachObjectWriter", "(", "new", "ARMMachObjectWriter", "(", "false", ",", "object", "::", "mach", "::", "CTM_ARM", ",", "object", "::", "mach", "::", "CSARM_V7", ")", ",", "OS", ",", "true", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "int", "ix86_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", ")", "{", "unsigned", "elements", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "ix86_cost", "->", "scalar_stmt_cost", ";", "case", "scalar_load", ":", "return", "ix86_cost", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "ix86_cost", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "ix86_cost", "->", "vec_stmt_cost", ";", "case", "vector_load", ":", "return", "ix86_cost", "->", "vec_align_load_cost", ";", "case", "vector_store", ":", "return", "ix86_cost", "->", "vec_store_cost", ";", "case", "vec_to_scalar", ":", "return", "ix86_cost", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "ix86_cost", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "case", "unaligned_store", ":", "return", "ix86_cost", "->", "vec_unalign_load_cost", ";", "case", "cond_branch_taken", ":", "return", "ix86_cost", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "ix86_cost", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "return", "ix86_cost", "->", "vec_stmt_cost", ";", "case", "vec_construct", ":", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "return", "ix86_cost", "->", "vec_stmt_cost", "*", "(", "elements", "/", "2", "+", "1", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

[ "i386", "2", "1" ]

[]

[ "<s>", "void", "lm32_expand_epilogue", "(", "void", ")", "{", "rtx", "ra_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "RA_REGNUM", ")", ";", "lm32_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "current_frame_info", ".", "total_size", ">", "0", ")", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "current_frame_info", ".", "reg_save_mask", "!=", "0", ")", "expand_save_restore", "(", "&", "current_frame_info", ",", "1", ")", ";", "stack_adjust", "(", "current_frame_info", ".", "total_size", ")", ";", "emit_jump_insn", "(", "gen_return_internal", "(", "ra_rtx", ")", ")", ";", "}", "else", "{", "emit_jump_insn", "(", "gen_return_internal", "(", "ra_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Create", "an", "emit", "instructions", "for", "a", "functions", "epilogue", "." ]

[ "lm32", "0", "0", "1" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "return", "isPredicateSetter", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "void", "OR1KAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "(", "unsigned", ")", "Kind", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "OR1K", "OR1K", "7", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "nvptxSubtarget", "=", "&", "F", ".", "getSubtarget", "<", "NVPTXSubtarget", ">", "(", ")", ";", "bool", "Result", "=", "AsmPrinter", "::", "runOnMachineFunction", "(", "F", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "StringRef", "(", "\"}\\n\"", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "\"}\\n\"" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ReserveX18", "(", "TT", ".", "isOSDarwin", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ",", "CPU", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "GISel", "(", ")", "{", "GISelAccessor", "*", "AArch64GISel", "=", "new", "GISelAccessor", "(", ")", ";", "AArch64GISelActualAccessor", "*", "AArch64GISel", "=", "new", "AArch64GISelActualAccessor", "(", ")", ";", "AArch64GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "AArch64GISel", "->", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "AArch64GISel", "->", "InstSelector", ".", "reset", "(", "createAArch64InstructionSelector", "(", "*", "static_cast", "<", "const", "AArch64TargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "AArch64GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "setGISelAccessor", "(", "*", "AArch64GISel", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "BEQC", ":", "case", "Mips", "::", "BNEC", ":", "case", "Mips", "::", "BEQC64", ":", "case", "Mips", "::", "BNEC64", ":", "case", "Mips", "::", "BOVC", ":", "case", "Mips", "::", "BOVC_MMR6", ":", "case", "Mips", "::", "BNVC", ":", "case", "Mips", "::", "BNVC_MMR6", ":", "LowerCompactBranch", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MMR6", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Dsp2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_mmdsp", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "if", "(", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "MOVEP_MM", ")", "||", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "MOVEP_MMR6", ")", ")", ")", "{", "unsigned", "RegPair", "=", "getMovePRegPairOpValue", "(", "MI", ",", "0", ",", "Fixups", ",", "STI", ")", ";", "Binary", "=", "(", "Binary", "&", "0xFFFFFC7F", ")", "|", "(", "RegPair", "<<", "7", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::BEQC", "Mips::BNEC", "Mips::BEQC64", "Mips::BNEC64", "Mips::BOVC", "Mips::BOVC_MMR6", "Mips::BNVC", "Mips::BNVC_MMR6", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "Mips::SLL_MMR6", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "Mips::Dsp2MicroMips", "Mips::Arch_mmdsp", "1", "Mips::MOVEP_MM", "Mips::MOVEP_MMR6", "0", "0xFFFFFC7F", "7", "\"Desc.getSize() returns 0\"" ]

[]

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

[ "addFastRegAlloc", "-", "Add", "the", "minimum", "set", "of", "target-independent", "passes", "that", "are", "required", "for", "fast", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "legitimate_reload_constant_p", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "DISP_IN_RANGE", "(", "INTVAL", "(", "op", ")", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "CONST_OK_FOR_K", "(", "INTVAL", "(", "op", ")", ")", "||", "CONST_OK_FOR_Os", "(", "INTVAL", "(", "op", ")", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_ZARCH", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "==", "INTVAL", "(", "op", ")", "&&", "s390_single_part", "(", "op", ",", "word_mode", ",", "HImode", ",", "0", ")", ">=", "0", ")", "return", "true", ";", "if", "(", "TARGET_EXTIMM", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "==", "INTVAL", "(", "op", ")", "&&", "s390_single_part", "(", "op", ",", "word_mode", ",", "SImode", ",", "0", ")", ">=", "0", ")", "return", "true", ";", "if", "(", "TARGET_CPU_ZARCH", "&&", "larl_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "CONST_DOUBLE_OK_FOR_CONSTRAINT_P", "(", "op", ",", "'G'", ",", "\"G\"", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "!=", "INTVAL", "(", "op", ")", ")", "{", "enum", "machine_mode", "dword_mode", "=", "word_mode", "==", "SImode", "?", "DImode", ":", "TImode", ";", "rtx", "hi", "=", "operand_subword", "(", "op", ",", "0", ",", "0", ",", "dword_mode", ")", ";", "rtx", "lo", "=", "operand_subword", "(", "op", ",", "1", ",", "0", ",", "dword_mode", ")", ";", "return", "legitimate_reload_constant_p", "(", "hi", ")", "&&", "legitimate_reload_constant_p", "(", "lo", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "constant", "value", "OP", "is", "a", "legitimate", "general", "operand", "during", "and", "after", "reload", ".", "The", "difference", "to", "legitimate_constant_p", "is", "that", "this", "function", "will", "not", "accept", "a", "constant", "that", "would", "need", "to", "be", "forced", "to", "the", "literal", "pool", "before", "it", "can", "be", "used", "as", "operand", "." ]

[ "s390", "0", "0", "0", "0", "\"G\"", "0", "0", "1", "0" ]

[]

[ "<s>", "SDValue", "CAHPTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "IsVarArg", ")", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_CAHP", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "SDValue", "ArgVal", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "RegVT", "!=", "MVT", "::", "i16", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ")", ";", "report_fatal_error", "(", "\"unhandled argument type\"", ")", ";", "}", "const", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "CAHP", "::", "GPRRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "ArgVal", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i16", ")", ";", "assert", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i16", ")", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "2", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i16", ")", ";", "ArgVal", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getLocVT", "(", ")", ",", "DL", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ";", "}", "InVals", ".", "push_back", "(", "ArgVal", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "ISD::InputArg", "\"Unsupported calling convention\"", "\"VarArg not supported\"", "16", "CAHP", "MVT::i16", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "\"unhandled argument type\"", "CAHP::GPRRegClass", "MVT::i16", "MVT::i16", "2", "MVT::i16" ]

[]

[ "<s>", "int", "first_fp_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "14", "+", "32", ";", "first_reg", "<=", "63", ";", "first_reg", "++", ")", "if", "(", "save_reg_p", "(", "first_reg", ")", ")", "break", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Similar", ",", "for", "FP", "regs", "." ]

[ "powerpcspe", "14", "32", "63" ]

[]

[ "<s>", "static", "void", "arm_option_override_internal", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "arm_override_options_after_change_1", "(", "opts", ")", ";", "if", "(", "TARGET_INTERWORK", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_INTERWORK", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support THUMB instructions\"", ")", ";", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "}", "if", "(", "TARGET_APCS_FRAME", "&&", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_APCS_FRAME", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "opts", "->", "x_target_flags", "|=", "MASK_INTERWORK", ";", "cl_optimization", "*", "to", "=", "TREE_OPTIMIZATION", "(", "init_optimize", ")", ";", "if", "(", "!", "opts_set", "->", "x_arm_restrict_it", ")", "opts", "->", "x_arm_restrict_it", "=", "arm_arch8", ";", "if", "(", "!", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", "||", "!", "arm_arch_notm", ")", "opts", "->", "x_arm_restrict_it", "=", "0", ";", "if", "(", "!", "opts_set", "->", "x_unaligned_access", ")", "{", "opts", "->", "x_unaligned_access", "=", "(", "TARGET_32BIT_P", "(", "opts", "->", "x_target_flags", ")", "&&", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ";", "}", "else", "if", "(", "opts", "->", "x_unaligned_access", "==", "1", "&&", "!", "(", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support unaligned accesses\"", ")", ";", "opts", "->", "x_unaligned_access", "=", "0", ";", "}", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_schedule_insns", "=", "0", ";", "else", "opts", "->", "x_flag_schedule_insns", "=", "to", "->", "x_flag_schedule_insns", ";", "if", "(", "optimize_function_for_size_p", "(", "cfun", ")", "&&", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_shrink_wrap", "=", "false", ";", "else", "opts", "->", "x_flag_shrink_wrap", "=", "to", "->", "x_flag_shrink_wrap", ";", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_ipa_ra", "=", "0", ";", "else", "opts", "->", "x_flag_ipa_ra", "=", "to", "->", "x_flag_ipa_ra", ";", "if", "(", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_inline_asm_unified", "=", "true", ";", "SUBTARGET_OVERRIDE_INTERNAL_OPTIONS", ";", "}", "</s>" ]

[ "Reset", "options", "between", "modes", "that", "the", "user", "has", "specified", "." ]

[ "arm", "0", "\"target CPU does not support THUMB instructions\"", "0", "1", "0", "\"target CPU does not support unaligned accesses\"", "0", "0", "0" ]

[]

[ "<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", "}", ")", ";", "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", "bool", "rs6000_builtin_valid_without_lhs", "(", "enum", "rs6000_builtins", "fn_code", ")", "{", "if", "(", "rs6000_builtin_info", "[", "fn_code", "]", ".", "attr", "&", "RS6000_BTC_VOID", ")", "return", "true", ";", "switch", "(", "fn_code", ")", "{", "case", "ALTIVEC_BUILTIN_STVX_V16QI", ":", "case", "ALTIVEC_BUILTIN_STVX_V8HI", ":", "case", "ALTIVEC_BUILTIN_STVX_V4SI", ":", "case", "ALTIVEC_BUILTIN_STVX_V4SF", ":", "case", "ALTIVEC_BUILTIN_STVX_V2DI", ":", "case", "ALTIVEC_BUILTIN_STVX_V2DF", ":", "case", "VSX_BUILTIN_STXVW4X_V16QI", ":", "case", "VSX_BUILTIN_STXVW4X_V8HI", ":", "case", "VSX_BUILTIN_STXVW4X_V4SF", ":", "case", "VSX_BUILTIN_STXVW4X_V4SI", ":", "case", "VSX_BUILTIN_STXVD2X_V2DF", ":", "case", "VSX_BUILTIN_STXVD2X_V2DI", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Helper", "function", "to", "sort", "out", "which", "built-ins", "may", "be", "valid", "without", "having", "a", "LHS", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "TOYRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "llvm_unreachable", "(", "\"getFrameRegister not implemented yet\"", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "\"getFrameRegister not implemented yet\"" ]

[]

[ "<s>", "void", "MipsSETargetLowering", "::", "addMSAIntType", "(", "MVT", "::", "SimpleValueType", "Ty", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "addRegisterClass", "(", "Ty", ",", "RC", ")", ";", "for", "(", "unsigned", "Opc", "=", "0", ";", "Opc", "<", "ISD", "::", "BUILTIN_OP_END", ";", "++", "Opc", ")", "setOperationAction", "(", "Opc", ",", "Ty", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BITCAST", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "LOAD", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "Ty", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "Ty", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "UNDEF", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "ADD", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "AND", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "MUL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "OR", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SUB", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SMAX", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SMIN", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMAX", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMIN", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "Ty", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VSELECT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "XOR", ",", "Ty", ",", "Legal", ")", ";", "if", "(", "Ty", "==", "MVT", "::", "v4i32", "||", "Ty", "==", "MVT", "::", "v2i64", ")", "{", "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SINT_TO_FP", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "Ty", ",", "Legal", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "Ty", ",", "Legal", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETNE", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETGE", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETGT", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGE", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGT", ",", "Ty", ",", "Expand", ")", ";", "}", "</s>" ]

[ "Enable", "MSA", "support", "for", "the", "given", "integer", "type", "and", "Register", "class", "." ]

[ "Mips", "Mips", "MVT::SimpleValueType", "0", "ISD::BUILTIN_OP_END", "ISD::BITCAST", "ISD::LOAD", "ISD::STORE", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::UNDEF", "ISD::ADD", "ISD::AND", "ISD::CTLZ", "ISD::CTPOP", "ISD::MUL", "ISD::OR", "ISD::SDIV", "ISD::SREM", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::SUB", "ISD::SMAX", "ISD::SMIN", "ISD::UDIV", "ISD::UREM", "ISD::UMAX", "ISD::UMIN", "ISD::VECTOR_SHUFFLE", "ISD::VSELECT", "ISD::XOR", "MVT::v4i32", "MVT::v2i64", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::SETCC", "ISD::SETNE", "ISD::SETGE", "ISD::SETGT", "ISD::SETUGE", "ISD::SETUGT" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"NVPTX Replace Image Handles\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"NVPTX Replace Image Handles\"" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "MipsTargetMachine", "&", "TM", "=", "getMipsTargetMachine", "(", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", "TM", ")", ")", ";", "addPass", "(", "createMipsHazardSchedule", "(", ")", ")", ";", "addPass", "(", "createMipsLongBranchPass", "(", "TM", ")", ")", ";", "addPass", "(", "createMipsConstantIslandPass", "(", "TM", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

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

[]

[ "<s>", "static", "rtx", "adjacent_mem_locations", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "reg1", ",", "reg2", ";", "HOST_WIDE_INT", "off1", ",", "size1", ",", "off2", ",", "size2", ";", "if", "(", "MEM_P", "(", "mem1", ")", "&&", "MEM_P", "(", "mem2", ")", "&&", "get_memref_parts", "(", "mem1", ",", "&", "reg1", ",", "&", "off1", ",", "&", "size1", ")", "&&", "get_memref_parts", "(", "mem2", ",", "&", "reg2", ",", "&", "off2", ",", "&", "size2", ")", "&&", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", ")", "{", "if", "(", "off1", "+", "size1", "==", "off2", ")", "return", "mem1", ";", "else", "if", "(", "off2", "+", "size2", "==", "off1", ")", "return", "mem2", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "If", "the", "target", "storage", "locations", "of", "arguments", "MEM1", "and", "MEM2", "are", "adjacent", ",", "then", "return", "the", "argument", "that", "has", "the", "lower", "address", ".", "Otherwise", ",", "return", "NULL_RTX", "." ]

[ "rs6000" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "BuildSREMPow2", "(", "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", ".", "isScalableVector", "(", ")", "||", "Subtarget", "->", "useSVEForFixedLengthVectors", "(", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "Divisor", ".", "isNegatedPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "if", "(", "Lg2", "==", "0", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "1ULL", "<<", "Lg2", ")", "-", "1", ",", "DL", ",", "VT", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ";", "SDValue", "CCVal", ",", "CSNeg", ";", "if", "(", "Lg2", "==", "1", ")", "{", "SDValue", "Cmp", "=", "getAArch64Cmp", "(", "N0", ",", "Zero", ",", "ISD", "::", "SETGE", ",", "CCVal", ",", "DAG", ",", "DL", ")", ";", "SDValue", "And", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "CSNeg", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "CSNEG", ",", "DL", ",", "VT", ",", "And", ",", "And", ",", "CCVal", ",", "Cmp", ")", ";", "Created", ".", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "And", ".", "getNode", "(", ")", ")", ";", "}", "else", "{", "SDValue", "CCVal", "=", "DAG", ".", "getConstant", "(", "AArch64CC", "::", "MI", ",", "DL", ",", "MVT_CC", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "VT", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Negs", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "SUBS", ",", "DL", ",", "VTs", ",", "Zero", ",", "N0", ")", ";", "SDValue", "AndPos", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "AndNeg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "Negs", ",", "Pow2MinusOne", ")", ";", "CSNeg", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "CSNEG", ",", "DL", ",", "VT", ",", "AndPos", ",", "AndNeg", ",", "CCVal", ",", "Negs", ".", "getValue", "(", "1", ")", ")", ";", "Created", ".", "push_back", "(", "Negs", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "AndPos", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "AndNeg", ".", "getNode", "(", ")", ")", ";", "}", "return", "CSNeg", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "0", "0", "0", "MVT::i32", "MVT::i64", "0", "0", "1ULL", "1", "0", "1", "AArch64", "ISD::SETGE", "ISD::AND", "AArch64ISD::CSNEG", "AArch64CC::MI", "MVT::i32", "AArch64ISD::SUBS", "ISD::AND", "ISD::AND", "AArch64ISD::CSNEG", "1" ]

[]

[ "<s>", "void", "SystemZHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "const", "MCSchedClassDesc", "*", "SC", "=", "DAG", "->", "getSchedClass", "(", "SU", ")", ";", "DEBUG", "(", "dumpCurrGroup", "(", "\"Decode group before emission\"", ")", ";", ")", ";", "if", "(", "!", "fitsIntoCurrentGroup", "(", "SU", ")", ")", "nextGroup", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ HazardRecognizer emitting \"", ";", "dumpSU", "(", "SU", ",", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "raw_string_ostream", "cgd", "(", "CurGroupDbg", ")", ";", "if", "(", "CurGroupDbg", ".", "length", "(", ")", ")", "cgd", "<<", "\", \"", ";", "dumpSU", "(", "SU", ",", "cgd", ")", ";", ")", ";", "if", "(", "SU", "->", "getInstr", "(", ")", "->", "isCall", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Clearing state after call.\\n\"", ";", ")", ";", "clearProcResCounters", "(", ")", ";", "LastFPdOpCycleIdx", "=", "UINT_MAX", ";", "CurrGroupSize", "+=", "getNumDecoderSlots", "(", "SU", ")", ";", "assert", "(", "CurrGroupSize", "<=", "3", ")", ";", "nextGroup", "(", ")", ";", "return", ";", "}", "for", "(", "TargetSchedModel", "::", "ProcResIter", "PI", "=", "SchedModel", "->", "getWriteProcResBegin", "(", "SC", ")", ",", "PE", "=", "SchedModel", "->", "getWriteProcResEnd", "(", "SC", ")", ";", "PI", "!=", "PE", ";", "++", "PI", ")", "{", "if", "(", "SchedModel", "->", "getProcResource", "(", "PI", "->", "ProcResourceIdx", ")", "->", "BufferSize", "==", "1", ")", "continue", ";", "int", "&", "CurrCounter", "=", "ProcResourceCounters", "[", "PI", "->", "ProcResourceIdx", "]", ";", "CurrCounter", "+=", "PI", "->", "Cycles", ";", "if", "(", "(", "CurrCounter", ">", "ProcResCostLim", ")", "&&", "(", "CriticalResourceIdx", "==", "UINT_MAX", "||", "(", "PI", "->", "ProcResourceIdx", "!=", "CriticalResourceIdx", "&&", "CurrCounter", ">", "ProcResourceCounters", "[", "CriticalResourceIdx", "]", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ New critical resource: \"", "<<", "SchedModel", "->", "getProcResource", "(", "PI", "->", "ProcResourceIdx", ")", "->", "Name", "<<", "\"\\n\"", ";", ")", ";", "CriticalResourceIdx", "=", "PI", "->", "ProcResourceIdx", ";", "}", "}", "if", "(", "SU", "->", "isUnbuffered", ")", "{", "LastFPdOpCycleIdx", "=", "getCurrCycleIdx", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Last FPd cycle index: \"", "<<", "LastFPdOpCycleIdx", "<<", "\"\\n\"", ";", ")", ";", "}", "CurrGroupSize", "+=", "getNumDecoderSlots", "(", "SU", ")", ";", "assert", "(", "CurrGroupSize", "<=", "3", ")", ";", "if", "(", "CurrGroupSize", "==", "3", "||", "SC", "->", "EndGroup", ")", "nextGroup", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Decode group before emission\"", "\"+++ HazardRecognizer emitting \"", "\"\\n\"", "\", \"", "\"+++ Clearing state after call.\\n\"", "3", "1", "\"+++ New critical resource: \"", "\"\\n\"", "\"+++ Last FPd cycle index: \"", "\"\\n\"", "3", "3" ]

[]

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

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

[ "BPF", "BPF", "BPF", "1", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDE", ":", "return", "performADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUBE", ":", "return", "performSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "performDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "performADDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::ADDE", "ISD::SUBE", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::SELECT", "ISD::AND", "ISD::OR", "ISD::ADD" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "X86SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "X86SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "X86SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "X86SelectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "return", "X86SelectZExt", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "X86SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "case", "Instruction", "::", "Shl", ":", "return", "X86SelectShift", "(", "I", ")", ";", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "URem", ":", "return", "X86SelectDivRem", "(", "I", ")", ";", "case", "Instruction", "::", "Select", ":", "return", "X86SelectSelect", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "X86SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "X86SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "X86SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "X86SelectSIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "{", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "I", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "TLI", ".", "getValueType", "(", "I", "->", "getType", "(", ")", ")", ";", "if", "(", "DstVT", ".", "bitsGT", "(", "SrcVT", ")", ")", "return", "X86SelectZExt", "(", "I", ")", ";", "if", "(", "DstVT", ".", "bitsLT", "(", "SrcVT", ")", ")", "return", "X86SelectTrunc", "(", "I", ")", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "Reg", "==", "0", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

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

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "BEQC", ":", "case", "Mips", "::", "BNEC", ":", "case", "Mips", "::", "BEQC64", ":", "case", "Mips", "::", "BNEC64", ":", "case", "Mips", "::", "BOVC", ":", "case", "Mips", "::", "BOVC_MMR6", ":", "case", "Mips", "::", "BNVC", ":", "case", "Mips", "::", "BNVC_MMR6", ":", "LowerCompactBranch", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MMR6", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Dsp2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_mmdsp", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::BEQC", "Mips::BNEC", "Mips::BEQC64", "Mips::BNEC64", "Mips::BOVC", "Mips::BOVC_MMR6", "Mips::BNVC", "Mips::BNVC_MMR6", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "Mips::SLL_MMR6", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "Mips::Dsp2MicroMips", "Mips::Arch_mmdsp", "1", "\"Desc.getSize() returns 0\"" ]

[]