Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Global Variable Resolver\"", ";", "}", "</s>" ]

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

[ "TPC", "\"Global Variable Resolver\"" ]

[]

[ "<s>", "bool", "SIDebuggerInsertNops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "debuggerInsertNops", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", ")", "return", "false", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DenseSet", "<", "unsigned", ">", "NopInserted", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "MI", "->", "isDebugInstr", "(", ")", "||", "!", "MI", "->", "getDebugLoc", "(", ")", ")", "continue", ";", "auto", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NopInserted", ".", "find", "(", "DL", ".", "getLine", "(", ")", ")", "==", "NopInserted", ".", "end", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "*", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_NOP", ")", ")", ".", "addImm", "(", "0", ")", ";", "NopInserted", ".", "insert", "(", "DL", ".", "getLine", "(", ")", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "AMDGPU::S_NOP", "0" ]

[]

[ "<s>", "void", "BPFAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "if", "(", "!", "BTF", "||", "!", "BTF", "->", "InstLower", "(", "MI", ",", "TmpInst", ")", ")", "{", "BPFMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "}", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "RISCV", "RISCV", "0", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_pcrel_hi20" ]

[]

[ "<s>", "int", "short_memory_operand", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "memory_operand", "(", "x", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "!=", "PLUS", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "valid", "operand", "for", "a", "`", "short", "'", "memory", "reference", "insn", "." ]

[ "stormy16", "0", "0" ]

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "if", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_KERNEL", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "{", "RegisterVT", "=", "VT", ".", "isInteger", "(", ")", "?", "MVT", "::", "v2i16", ":", "MVT", "::", "v2f16", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "(", "NumElts", "+", "1", ")", "/", "2", ";", "return", "NumIntermediates", ";", "}", "if", "(", "Size", "==", "32", ")", "{", "RegisterVT", "=", "ScalarVT", ".", "getSimpleVT", "(", ")", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "NumElts", ";", "return", "NumIntermediates", ";", "}", "if", "(", "Size", "<", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "{", "RegisterVT", "=", "MVT", "::", "i16", ";", "IntermediateVT", "=", "ScalarVT", ";", "NumIntermediates", "=", "NumElts", ";", "return", "NumIntermediates", ";", "}", "if", "(", "Size", "!=", "16", "&&", "Size", "<=", "32", ")", "{", "RegisterVT", "=", "MVT", "::", "i32", ";", "IntermediateVT", "=", "ScalarVT", ";", "NumIntermediates", "=", "NumElts", ";", "return", "NumIntermediates", ";", "}", "if", "(", "Size", ">", "32", ")", "{", "RegisterVT", "=", "MVT", "::", "i32", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "NumElts", "*", "(", "(", "Size", "+", "31", ")", "/", "32", ")", ";", "return", "NumIntermediates", ";", "}", "}", "return", "TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "Context", ",", "CC", ",", "VT", ",", "IntermediateVT", ",", "NumIntermediates", ",", "RegisterVT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]

[ "AMDGPU", "SI", "AMDGPU", "16", "MVT::v2i16", "MVT::v2f16", "1", "2", "32", "16", "MVT::i16", "16", "32", "MVT::i32", "32", "MVT::i32", "31", "32" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "getTargetNode", "(", "ConstantPoolSDNode", "*", "N", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flag", ")", "const", "{", "return", "DAG", ".", "getTargetConstantPool", "(", "N", "->", "getConstVal", "(", ")", ",", "Ty", ",", "N", "->", "getAlign", "(", ")", ",", "N", "->", "getOffset", "(", ")", ",", "Flag", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "cirrus_reorg", "(", "rtx", "first", ")", "{", "enum", "attr_cirrus", "attr", ";", "rtx", "body", "=", "PATTERN", "(", "first", ")", ";", "rtx", "t", ";", "int", "nops", ";", "if", "(", "GET_CODE", "(", "first", ")", "==", "JUMP_INSN", "&&", "GET_CODE", "(", "body", ")", "!=", "RETURN", ")", "{", "nops", "=", "0", ";", "t", "=", "next_nonnote_insn", "(", "first", ")", ";", "if", "(", "arm_cirrus_insn_p", "(", "t", ")", ")", "++", "nops", ";", "if", "(", "arm_cirrus_insn_p", "(", "next_nonnote_insn", "(", "t", ")", ")", ")", "++", "nops", ";", "while", "(", "nops", "--", ")", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "first", ")", ";", "return", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "==", "PARALLEL", "&&", "XVECLEN", "(", "body", ",", "0", ")", ">", "0", ")", "body", "=", "XVECEXP", "(", "body", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "rtx", "lhs", "=", "XEXP", "(", "body", ",", "0", ")", ",", "rhs", "=", "XEXP", "(", "body", ",", "1", ")", ";", "if", "(", "get_attr_cirrus", "(", "first", ")", "==", "CIRRUS_DOUBLE", ")", "{", "if", "(", "arm_cirrus_insn_p", "(", "next_nonnote_insn", "(", "first", ")", ")", ")", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "first", ")", ";", "return", ";", "}", "else", "if", "(", "arm_memory_load_p", "(", "first", ")", ")", "{", "unsigned", "int", "arm_regno", ";", "if", "(", "GET_CODE", "(", "lhs", ")", "==", "REG", ")", "arm_regno", "=", "REGNO", "(", "lhs", ")", ";", "else", "{", "gcc_assert", "(", "GET_CODE", "(", "rhs", ")", "==", "REG", ")", ";", "arm_regno", "=", "REGNO", "(", "rhs", ")", ";", "}", "first", "=", "next_nonnote_insn", "(", "first", ")", ";", "if", "(", "!", "arm_cirrus_insn_p", "(", "first", ")", ")", "return", ";", "body", "=", "PATTERN", "(", "first", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "PARALLEL", "&&", "XVECLEN", "(", "body", ",", "0", ")", ")", "body", "=", "XVECEXP", "(", "body", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "FLOAT", ")", "body", "=", "XEXP", "(", "body", ",", "0", ")", ";", "if", "(", "get_attr_cirrus", "(", "first", ")", "==", "CIRRUS_MOVE", "&&", "GET_CODE", "(", "XEXP", "(", "body", ",", "1", ")", ")", "==", "REG", "&&", "arm_regno", "==", "REGNO", "(", "XEXP", "(", "body", ",", "1", ")", ")", ")", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "first", ")", ";", "return", ";", "}", "}", "if", "(", "!", "first", "||", "GET_CODE", "(", "first", ")", "!=", "INSN", "||", "GET_CODE", "(", "PATTERN", "(", "first", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "first", ")", ")", "==", "CLOBBER", ")", "return", ";", "attr", "=", "get_attr_cirrus", "(", "first", ")", ";", "if", "(", "attr", "==", "CIRRUS_COMPARE", ")", "{", "nops", "=", "0", ";", "t", "=", "next_nonnote_insn", "(", "first", ")", ";", "if", "(", "arm_cirrus_insn_p", "(", "t", ")", ")", "++", "nops", ";", "if", "(", "arm_cirrus_insn_p", "(", "next_nonnote_insn", "(", "t", ")", ")", ")", "++", "nops", ";", "while", "(", "nops", "--", ")", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "first", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Cirrus", "reorg", "for", "invalid", "instruction", "combinations", "." ]

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

[]

[ "<s>", "bool", "pdp11_secondary_memory_needed", "(", "reg_class_t", "c1", ",", "reg_class_t", "c2", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "int", "fromfloat", "=", "(", "c1", "==", "LOAD_FPU_REGS", "||", "c1", "==", "NO_LOAD_FPU_REGS", "||", "c1", "==", "FPU_REGS", ")", ";", "int", "tofloat", "=", "(", "c2", "==", "LOAD_FPU_REGS", "||", "c2", "==", "NO_LOAD_FPU_REGS", "||", "c2", "==", "FPU_REGS", ")", ";", "return", "(", "fromfloat", "!=", "tofloat", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_MEMORY_NEEDED", ".", "The", "answer", "is", "yes", "if", "we", "'re", "going", "between", "general", "register", "and", "FPU", "registers", ".", "The", "mode", "does", "n't", "matter", "in", "making", "this", "check", "." ]

[ "pdp11" ]

[]

[ "<s>", "MCSection", "*", "LanaiTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "unsigned", "&", "Align", ",", "const", "GlobalObject", "*", "GO", ")", "const", "{", "if", "(", "isConstantInSmallSection", "(", "DL", ",", "C", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ",", "Align", ",", "GO", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "Lanai", "Lanai" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "void", "BPFMIPreEmitChecking", "::", "initialize", "(", "MachineFunction", "&", "MFParm", ")", "{", "MF", "=", "&", "MFParm", ";", "TRI", "=", "MF", "->", "getSubtarget", "<", "BPFSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** BPF PreEmit checking pass ***\\n\\n\"", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF", "\"*** BPF PreEmit checking pass ***\\n\\n\"" ]

[]

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

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

[ "F2003f", "\"2003f Assembly Printer\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseOffs", "<=", "-", "(", "1LL", "<<", "13", ")", "||", "AM", ".", "BaseOffs", ">=", "(", "1LL", "<<", "13", ")", "-", "1", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "if", "(", "Scale", "<", "0", ")", "Scale", "=", "-", "Scale", ";", "switch", "(", "Scale", ")", "{", "case", "0", ":", "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", "." ]

[ "Hexagon", "Hexagon", "1LL", "13", "1LL", "13", "1", "0", "0" ]

[]

[ "<s>", "bool", "shouldInsertFencesForAtomic", "(", "const", "Instruction", "*", "I", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Helper", "functions", "for", "atomic", "operations", "." ]

[ "Sparc" ]

[]

[ "<s>", "static", "unsigned", "nvptx_process_pars", "(", "parallel", "*", "par", ")", "{", "if", "(", "nvptx_optimize", ")", "nvptx_optimize_inner", "(", "par", ")", ";", "unsigned", "inner_mask", "=", "par", "->", "mask", ";", "if", "(", "par", "->", "inner", ")", "{", "par", "->", "inner_mask", "=", "nvptx_process_pars", "(", "par", "->", "inner", ")", ";", "inner_mask", "|=", "par", "->", "inner_mask", ";", "}", "bool", "is_call", "=", "(", "par", "->", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_MAX", ")", ")", "!=", "0", ";", "bool", "worker", "=", "(", "par", "->", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", ")", ";", "bool", "large_vector", "=", "(", "(", "par", "->", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_VECTOR", ")", ")", "&&", "nvptx_mach_vector_length", "(", ")", ">", "PTX_WARP_SIZE", ")", ";", "if", "(", "worker", "||", "large_vector", ")", "{", "nvptx_shared_propagate", "(", "false", ",", "is_call", ",", "par", "->", "forked_block", ",", "par", "->", "forked_insn", ",", "!", "worker", ")", ";", "bool", "no_prop_p", "=", "nvptx_shared_propagate", "(", "true", ",", "is_call", ",", "par", "->", "forked_block", ",", "par", "->", "fork_insn", ",", "!", "worker", ")", ";", "bool", "empty_loop_p", "=", "!", "is_call", "&&", "(", "NEXT_INSN", "(", "par", "->", "forked_insn", ")", "&&", "NEXT_INSN", "(", "par", "->", "forked_insn", ")", "==", "par", "->", "joining_insn", ")", ";", "rtx", "barrier", "=", "GEN_INT", "(", "0", ")", ";", "int", "threads", "=", "0", ";", "if", "(", "!", "worker", "&&", "cfun", "->", "machine", "->", "sync_bar", ")", "{", "barrier", "=", "cfun", "->", "machine", "->", "sync_bar", ";", "threads", "=", "nvptx_mach_vector_length", "(", ")", ";", "}", "if", "(", "no_prop_p", "&&", "empty_loop_p", ")", ";", "else", "if", "(", "no_prop_p", "&&", "is_call", ")", ";", "else", "{", "emit_insn_before", "(", "nvptx_cta_sync", "(", "barrier", ",", "threads", ")", ",", "par", "->", "forked_insn", ")", ";", "emit_insn_before", "(", "nvptx_cta_sync", "(", "barrier", ",", "threads", ")", ",", "par", "->", "join_insn", ")", ";", "}", "}", "else", "if", "(", "par", "->", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_VECTOR", ")", ")", "nvptx_warp_propagate", "(", "is_call", ",", "par", "->", "forked_block", ",", "par", "->", "forked_insn", ")", ";", "if", "(", "par", "->", "next", ")", "inner_mask", "|=", "nvptx_process_pars", "(", "par", "->", "next", ")", ";", "return", "inner_mask", ";", "}", "</s>" ]

[ "Process", "the", "parallel", "PAR", "and", "all", "its", "contained", "parallels", ".", "We", "do", "everything", "but", "the", "neutering", ".", "Return", "mask", "of", "partitioned", "modes", "used", "within", "this", "parallel", "." ]

[ "nvptx", "0", "0", "0" ]

[]

[ "<s>", "static", "int", "s390_issue_rate", "(", "void", ")", "{", "if", "(", "s390_tune", "==", "PROCESSOR_2084_Z990", "||", "s390_tune", "==", "PROCESSOR_2094_Z9_109", ")", "return", "3", ";", "return", "1", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "AAPTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "AAPISD", "::", "RET_FLAG", ":", "return", "\"AAPISD::RET_FLAG\"", ";", "case", "AAPISD", "::", "CALL", ":", "return", "\"AAPISD::CALL\"", ";", "case", "AAPISD", "::", "Wrapper", ":", "return", "\"AAPISD::Wrapper\"", ";", "case", "AAPISD", "::", "SELECT_CC", ":", "return", "\"AAPISD::SELECT_CC\"", ";", "}", "}", "</s>" ]

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

[ "AAP", "AAP", "AAPISD::RET_FLAG", "\"AAPISD::RET_FLAG\"", "AAPISD::CALL", "\"AAPISD::CALL\"", "AAPISD::Wrapper", "\"AAPISD::Wrapper\"", "AAPISD::SELECT_CC", "\"AAPISD::SELECT_CC\"" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "dumpSchedule", "(", ")", "const", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "begin", "(", ")", ",", "ME", "=", "end", "(", ")", ";", "MI", "!=", "ME", ";", "++", "MI", ")", "{", "if", "(", "SUnit", "*", "SU", "=", "getSUnit", "(", "&", "(", "*", "MI", ")", ")", ")", "SU", "->", "dumpAttributes", "(", ")", ";", "else", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Debug Value\\n\"", ";", "else", "dbgs", "(", ")", "<<", "\"Missing SUnit\\n\"", ";", "}", "}", "</s>" ]

[ "dump", "the", "scheduled", "Sequence", "." ]

[ "Patmos", "\"Debug Value\\n\"", "\"Missing SUnit\\n\"" ]

[]

[ "<s>", "static", "rtx", "nds32_gen_dup_4_byte_to_word_value_aux", "(", "rtx", "value", ",", "rtx", "value4word", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "value", ")", "==", "QImode", "||", "CONST_INT_P", "(", "value", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "value", ")", ")", "{", "unsigned", "HOST_WIDE_INT", "val", "=", "UINTVAL", "(", "value", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "rtx", "new_val", "=", "gen_int_mode", "(", "val", "|", "(", "val", "<<", "8", ")", "|", "(", "val", "<<", "16", ")", "|", "(", "val", "<<", "24", ")", ",", "SImode", ")", ";", "emit_move_insn", "(", "value4word", ",", "new_val", ")", ";", "}", "else", "{", "if", "(", "NDS32_EXT_DSP_P", "(", ")", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "convert_move", "(", "tmp", ",", "value", ",", "true", ")", ";", "emit_insn", "(", "gen_insvsi_internal", "(", "tmp", ",", "gen_int_mode", "(", "0x8", ",", "SImode", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_pkbbsi_1", "(", "value4word", ",", "tmp", ",", "tmp", ")", ")", ";", "}", "else", "{", "rtx", "tmp1", ",", "tmp2", ",", "tmp3", ",", "tmp4", ";", "tmp1", "=", "expand_binop", "(", "SImode", ",", "and_optab", ",", "value", ",", "gen_int_mode", "(", "0xff", ",", "SImode", ")", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "tmp2", "=", "expand_binop", "(", "SImode", ",", "ashl_optab", ",", "tmp1", ",", "gen_int_mode", "(", "8", ",", "SImode", ")", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "tmp3", "=", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "tmp1", ",", "tmp2", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "tmp4", "=", "expand_binop", "(", "SImode", ",", "ashl_optab", ",", "tmp3", ",", "gen_int_mode", "(", "16", ",", "SImode", ")", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "value4word", ",", "tmp3", ",", "tmp4", ")", ")", ";", "}", "}", "return", "value4word", ";", "}", "</s>" ]

[ "Auxiliary", "function", "for", "expand", "setmem", "pattern", "." ]

[ "nds32", "8", "16", "24", "0x8", "0xff", "0", "8", "0", "0", "16", "0" ]

[]

[ "<s>", "static", "void", "arc_initialize_trampoline", "(", "rtx", "tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "emit_block_move", "(", "tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tramp", ",", "SImode", ",", "8", ")", ",", "fnaddr", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tramp", ",", "SImode", ",", "12", ")", ",", "cxt", ")", ";", "maybe_emit_call_builtin___clear_cache", "(", "XEXP", "(", "tramp", ",", "0", ")", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "tramp", ",", "0", ")", ",", "TRAMPOLINE_SIZE", ")", ")", ";", "}", "</s>" ]

[ "With", "potentially", "multiple", "shared", "objects", "loaded", ",", "and", "multiple", "stacks", "present", "for", "multiple", "thereds", "where", "trampolines", "might", "reside", ",", "a", "simple", "range", "check", "will", "likely", "not", "suffice", "for", "the", "profiler", "to", "tell", "if", "a", "callee", "is", "a", "trampoline", ".", "We", "a", "speedier", "check", "by", "making", "the", "trampoline", "start", "at", "an", "address", "that", "is", "not", "4-byte", "aligned", ".", "A", "trampoline", "looks", "like", "this", ":", "nop_s", "0x78e0entry", ":", "ld_s", "r12", ",", "[", "pcl,12", "]", "0xd403", "ld", "r11", ",", "[", "pcl,12", "]", "0x170c", "700b", "j_s", "[", "r12", "]", "0x7c00", "nop_s", "0x78e0", "The", "fastest", "trampoline", "to", "execute", "for", "trampolines", "within", "+-8KB", "of", "CTX", "would", "be", ":", "add2", "r11", ",", "pcl", ",", "s12", "j", "[", "limm", "]", "0x20200f80", "limm", "and", "that", "would", "also", "be", "faster", "to", "write", "to", "the", "stack", "by", "computing", "the", "offset", "from", "CTX", "to", "TRAMP", "at", "compile", "time", ".", "However", ",", "it", "would", "really", "be", "better", "to", "get", "rid", "of", "the", "high", "cost", "of", "cache", "invalidation", "when", "generating", "trampolines", ",", "which", "requires", "that", "the", "code", "part", "of", "trampolines", "stays", "constant", ",", "and", "additionally", "either", "-", "making", "sure", "that", "no", "executable", "code", "but", "trampolines", "is", "on", "the", "stack", ",", "no", "icache", "entries", "linger", "for", "the", "area", "of", "the", "stack", "from", "when", "before", "the", "stack", "was", "allocated", ",", "and", "allocating", "trampolines", "in", "trampoline-only", "cache", "lines", "or", "-", "allocate", "trampolines", "fram", "a", "special", "pool", "of", "pre-allocated", "trampolines", "." ]

[ "arc", "0", "8", "12", "0", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "getBlock", "(", ")", "const", "{", "return", "Block", ";", "}", "</s>" ]

[ "getBlock", "-", "Return", "the", "current", "basic", "block", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "unsigned", "MaxWorkGroupSGPRCount", "=", "getMaxWorkGroupSGPRCount", "(", "MF", ")", ";", "unsigned", "MaxWorkGroupVGPRCount", "=", "getMaxWorkGroupVGPRCount", "(", "MF", ")", ";", "unsigned", "NumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "unsigned", "NumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxWorkGroupSGPRCount", ";", "i", "<", "NumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "for", "(", "unsigned", "i", "=", "MaxWorkGroupVGPRCount", ";", "i", "<", "NumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "debuggerReserveRegs", "(", ")", ")", "{", "unsigned", "ReservedVGPRFirst", "=", "MaxWorkGroupVGPRCount", "-", "MFI", "->", "getDebuggerReservedVGPRCount", "(", ")", ";", "for", "(", "unsigned", "i", "=", "ReservedVGPRFirst", ";", "i", "<", "MaxWorkGroupVGPRCount", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU", "AMDGPU", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "const", "PPCSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "usePPCPreRASchedStrategy", "(", ")", ")", "return", "createPPCMachineScheduler", "(", "C", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

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

[]

[ "<s>", "bool", "ARMExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "ExpandMBB", "(", "*", "MFI", ")", ";", "if", "(", "VerifyARMPseudo", ")", "MF", ".", "verify", "(", "this", ",", "\"After expanding ARM pseudo instructions.\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "\"After expanding ARM pseudo instructions.\"" ]

[]

[ "<s>", "static", "void", "rl78_reorg", "(", "void", ")", "{", "if", "(", "optimize", "<=", "0", ")", "split_all_insns", "(", ")", ";", "rl78_alloc_physical_registers", "(", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"\\n================DEVIRT:=AFTER=ALLOC=PHYSICAL=REGISTERS================\\n\"", ")", ";", "print_rtl_with_bb", "(", "dump_file", ",", "get_insns", "(", ")", ",", "TDF_NONE", ")", ";", "}", "rl78_propogate_register_origins", "(", ")", ";", "rl78_calculate_death_notes", "(", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"\\n================DEVIRT:=AFTER=PROPOGATION=============================\\n\"", ")", ";", "print_rtl_with_bb", "(", "dump_file", ",", "get_insns", "(", ")", ",", "TDF_NONE", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n======================================================================\\n\"", ")", ";", "}", "rl78_remove_unused_sets", "(", ")", ";", "df_finish_pass", "(", "true", ")", ";", "if", "(", "optimize", ">", "1", ")", "df_live_add_problem", "(", ")", ";", "df_scan_alloc", "(", "NULL", ")", ";", "df_scan_blocks", "(", ")", ";", "if", "(", "optimize", ")", "df_analyze", "(", ")", ";", "}", "</s>" ]

[ "This", "is", "the", "top", "of", "the", "devritualization", "pass", "." ]

[ "rl78", "0", "\"\\n================DEVIRT:=AFTER=ALLOC=PHYSICAL=REGISTERS================\\n\"", "\"\\n================DEVIRT:=AFTER=PROPOGATION=============================\\n\"", "\"\\n======================================================================\\n\"", "1" ]

[]

[ "<s>", "static", "int", "gen_v9_scc", "(", "rtx", "dest", ",", "enum", "rtx_code", "compare_code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "if", "(", "!", "TARGET_ARCH64", "&&", "(", "GET_MODE", "(", "x", ")", "==", "DImode", "||", "GET_MODE", "(", "dest", ")", "==", "DImode", ")", ")", "return", "0", ";", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_INT", "&&", "y", "==", "const0_rtx", "&&", "v9_regcmp_p", "(", "compare_code", ")", ")", "{", "rtx", "op0", "=", "x", ";", "rtx", "temp", ";", "if", "(", "compare_code", "==", "NE", "&&", "GET_MODE", "(", "dest", ")", "==", "DImode", "&&", "rtx_equal_p", "(", "op0", ",", "dest", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "DImode", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "DImode", ",", "op0", ",", "const0_rtx", ")", ",", "const1_rtx", ",", "dest", ")", ")", ")", ";", "return", "1", ";", "}", "if", "(", "reg_overlap_mentioned_p", "(", "dest", ",", "op0", ")", ")", "{", "op0", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "x", ")", ")", ";", "emit_move_insn", "(", "op0", ",", "x", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "const0_rtx", ")", ")", ";", "if", "(", "GET_MODE", "(", "op0", ")", "!=", "DImode", ")", "{", "temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "convert_move", "(", "temp", ",", "op0", ",", "0", ")", ";", "}", "else", "temp", "=", "op0", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dest", ")", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "DImode", ",", "temp", ",", "const0_rtx", ")", ",", "const1_rtx", ",", "dest", ")", ")", ")", ";", "return", "1", ";", "}", "else", "{", "x", "=", "gen_compare_reg_1", "(", "compare_code", ",", "x", ",", "y", ")", ";", "y", "=", "const0_rtx", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dest", ")", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "GET_MODE", "(", "x", ")", ",", "x", ",", "y", ")", ",", "const1_rtx", ",", "dest", ")", ")", ")", ";", "return", "1", ";", "}", "}", "</s>" ]

[ "This", "function", "is", "used", "for", "v9", "only", ".", "CODE", "is", "the", "code", "for", "an", "Scc", "'s", "comparison", ".", "OPERANDS", "[", "0", "]", "is", "the", "target", "of", "the", "Scc", "insn", ".", "OPERANDS", "[", "1", "]", "is", "the", "value", "we", "compare", "against", "const0_rtx", "(", "which", "has", "n't", "been", "generated", "yet", ")", ".", "This", "function", "is", "needed", "to", "turn", "(", "set", "(", "reg", ":", "SI", "110", ")", "(", "gt", "(", "reg", ":", "CCX", "100", "%", "icc", ")", "(", "const_int", "0", ")", ")", ")", "into", "(", "set", "(", "reg", ":", "SI", "110", ")", "(", "gt", ":", "DI", "(", "reg", ":", "CCX", "100", "%", "icc", ")", "(", "const_int", "0", ")", ")", ")", "IE", ":", "The", "instruction", "recognizer", "needs", "to", "see", "the", "mode", "of", "the", "comparison", "to", "find", "the", "right", "instruction", ".", "We", "could", "use", "``", "gt", ":", "DI", "''", "right", "in", "the", "define_expand", ",", "but", "leaving", "it", "out", "allows", "us", "to", "handle", "DI", ",", "SI", ",", "etc", ".", "We", "refer", "to", "the", "global", "sparc", "compare", "operands", "sparc_compare_op0", "and", "sparc_compare_op1", "." ]

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

[]

[ "<s>", "FunctionType", "*", "getFunctionType", "(", "Module", "&", "M", ")", "const", "override", "{", "return", "FuncTy", ";", "}", "</s>" ]

[ "getFunctionType", "-", "InlineAsm", "'s", "are", "always", "pointers", "to", "functions", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MRI", ".", "getTargetRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "*", "MRI", ".", "getRegClass", "(", "DstReg", ")", ";", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "\"Invalid Cond array\"", ")", ";", "unsigned", "Opc", "=", "getCMovFromCond", "(", "(", "X86", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ",", "TRI", ".", "getRegSizeInBits", "(", "RC", ")", "/", "8", ",", "false", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "X86", "X86", "1", "\"Invalid Cond array\"", "X86::CondCode", "0", "8" ]

[]

[ "<s>", "static", "void", "addarg", "(", "const", "char", "*", "str", ")", "{", "int", "i", ";", "if", "(", "++", "comp_arg_index", ">=", "comp_arg_max", ")", "{", "const", "char", "*", "*", "new_comp_args", "=", "(", "const", "char", "*", "*", ")", "xcalloc", "(", "comp_arg_max", "+", "1000", ",", "sizeof", "(", "char", "*", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "comp_arg_max", ";", "i", "++", ")", "new_comp_args", "[", "i", "]", "=", "comp_args", "[", "i", "]", ";", "if", "(", "comp_args", ")", "free", "(", "comp_args", ")", ";", "comp_arg_max", "+=", "1000", ";", "comp_args", "=", "new_comp_args", ";", "}", "comp_args", "[", "comp_arg_index", "]", "=", "str", ";", "}", "</s>" ]

[ "Append", "STR", "to", "the", "command", "line", "to", "invoke", "the", "linker", ".", "Expand", "the", "line", "as", "necessary", "to", "accommodate", "." ]

[ "alpha", "1000", "0", "1000" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "print", "(", "dbgs", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "printCustom", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "OS", "<<", "\"MisalignedCrash\"", ";", "}", "</s>" ]

[ "Implement", "printing", "for", "PseudoSourceValue", "." ]

[ "Hexagon", "\"MisalignedCrash\"" ]

[]

[ "<s>", "void", "Z80AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "Z80MCInstLower", "MCInstLowering", "(", "*", "MF", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "getRegBankInfo", "(", ")", "const", "override", "{", "return", "RegBankInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "X86" ]

[]

[ "<s>", "static", "int", "tilegx_mode_rep_extended", "(", "scalar_int_mode", "mode", ",", "scalar_int_mode", "mode_rep", ")", "{", "if", "(", "mode", "==", "SImode", "&&", "mode_rep", "==", "DImode", ")", "return", "SIGN_EXTEND", ";", "return", "UNKNOWN", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODE_REP_EXTENDED", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "arc_lra_p", "(", "void", ")", "{", "return", "arc_lra_flag", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "." ]

[ "arc" ]

[]

[ "<s>", "static", "int", "compute_clrmem_length", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "unsigned", "int", "align", "=", "INTVAL", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "4", ")", ",", "0", ")", ")", ";", "unsigned", "long", "n_bytes", "=", "INTVAL", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "3", ")", ",", "0", ")", ")", ";", "unsigned", "int", "n_insns", "=", "0", ";", "if", "(", "align", ">", "(", "TARGET_64BIT", "?", "8", ":", "4", ")", ")", "align", "=", "(", "TARGET_64BIT", "?", "8", ":", "4", ")", ";", "n_insns", "=", "4", ";", "if", "(", "n_bytes", "%", "(", "2", "*", "align", ")", "!=", "0", ")", "{", "if", "(", "(", "n_bytes", "%", "(", "2", "*", "align", ")", ")", ">=", "align", ")", "n_insns", "++", ";", "if", "(", "(", "n_bytes", "%", "align", ")", "!=", "0", ")", "n_insns", "++", ";", "}", "return", "n_insns", "*", "4", ";", "}", "</s>" ]

[ "Count", "the", "number", "of", "insns", "necessary", "to", "handle", "this", "block", "move", ".", "Basic", "structure", "is", "the", "same", "as", "emit_block_move", ",", "except", "that", "we", "count", "insns", "rather", "than", "emit", "them", "." ]

[ "pa", "0", "4", "0", "0", "3", "0", "0", "8", "4", "8", "4", "4", "2", "0", "2", "0", "4" ]

[]

[ "<s>", "void", "sh_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "\"__sh__\"", ")", ";", "builtin_assert", "(", "\"cpu=sh\"", ")", ";", "builtin_assert", "(", "\"machine=sh\"", ")", ";", "switch", "(", "(", "int", ")", "sh_cpu", ")", "{", "case", "PROCESSOR_SH1", ":", "builtin_define", "(", "\"__sh1__\"", ")", ";", "builtin_define", "(", "\"__SH1__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH2", ":", "builtin_define", "(", "\"__sh2__\"", ")", ";", "builtin_define", "(", "\"__SH2__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH2E", ":", "builtin_define", "(", "\"__SH2E__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH2A", ":", "builtin_define", "(", "\"__SH2A__\"", ")", ";", "if", "(", "TARGET_SH2A_DOUBLE", ")", "builtin_define", "(", "TARGET_FPU_SINGLE", "?", "\"__SH2A_SINGLE__\"", ":", "\"__SH2A_DOUBLE__\"", ")", ";", "else", "builtin_define", "(", "TARGET_FPU_ANY", "?", "\"__SH2A_SINGLE_ONLY__\"", ":", "\"__SH2A_NOFPU__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH3", ":", "builtin_define", "(", "\"__sh3__\"", ")", ";", "builtin_define", "(", "\"__SH3__\"", ")", ";", "if", "(", "TARGET_HARD_SH4", ")", "builtin_define", "(", "\"__SH4_NOFPU__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH3E", ":", "builtin_define", "(", "TARGET_HARD_SH4", "?", "\"__SH4_SINGLE_ONLY__\"", ":", "\"__SH3E__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH4", ":", "builtin_define", "(", "TARGET_FPU_SINGLE", "?", "\"__SH4_SINGLE__\"", ":", "\"__SH4__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH4A", ":", "\\", "builtin_define", "(", "\"__SH4A__\"", ")", ";", "builtin_define", "(", "TARGET_SH4", "?", "(", "TARGET_FPU_SINGLE", "?", "\"__SH4_SINGLE__\"", ":", "\"__SH4__\"", ")", ":", "TARGET_FPU_ANY", "?", "\"__SH4_SINGLE_ONLY__\"", ":", "\"__SH4_NOFPU__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH5", ":", "{", "builtin_define_with_value", "(", "\"__SH5__\"", ",", "TARGET_SHMEDIA64", "?", "\"64\"", ":", "\"32\"", ",", "0", ")", ";", "builtin_define_with_value", "(", "\"__SHMEDIA__\"", ",", "TARGET_SHMEDIA", "?", "\"1\"", ":", "\"0\"", ",", "0", ")", ";", "if", "(", "!", "TARGET_FPU_DOUBLE", ")", "builtin_define", "(", "\"__SH4_NOFPU__\"", ")", ";", "}", "}", "if", "(", "TARGET_FPU_ANY", ")", "builtin_define", "(", "\"__SH_FPU_ANY__\"", ")", ";", "if", "(", "TARGET_FPU_DOUBLE", ")", "builtin_define", "(", "\"__SH_FPU_DOUBLE__\"", ")", ";", "if", "(", "TARGET_HITACHI", ")", "builtin_define", "(", "\"__HITACHI__\"", ")", ";", "if", "(", "TARGET_FMOVD", ")", "builtin_define", "(", "\"__FMOVD_ENABLED__\"", ")", ";", "if", "(", "TARGET_FDPIC", ")", "{", "builtin_define", "(", "\"__SH_FDPIC__\"", ")", ";", "builtin_define", "(", "\"__FDPIC__\"", ")", ";", "}", "builtin_define", "(", "TARGET_LITTLE_ENDIAN", "?", "\"__LITTLE_ENDIAN__\"", ":", "\"__BIG_ENDIAN__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__SH_ATOMIC_MODEL_%s__\"", ",", "selected_atomic_model", "(", ")", ".", "cdef_name", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_CPU_CPP_BUILTINS", "macro" ]

[ "sh", "\"__sh__\"", "\"cpu=sh\"", "\"machine=sh\"", "\"__sh1__\"", "\"__SH1__\"", "\"__sh2__\"", "\"__SH2__\"", "\"__SH2E__\"", "\"__SH2A__\"", "\"__SH2A_SINGLE__\"", "\"__SH2A_DOUBLE__\"", "\"__SH2A_SINGLE_ONLY__\"", "\"__SH2A_NOFPU__\"", "\"__sh3__\"", "\"__SH3__\"", "\"__SH4_NOFPU__\"", "\"__SH4_SINGLE_ONLY__\"", "\"__SH3E__\"", "\"__SH4_SINGLE__\"", "\"__SH4__\"", "\"__SH4A__\"", "\"__SH4_SINGLE__\"", "\"__SH4__\"", "\"__SH4_SINGLE_ONLY__\"", "\"__SH4_NOFPU__\"", "\"__SH5__\"", "\"64\"", "\"32\"", "0", "\"__SHMEDIA__\"", "\"1\"", "\"0\"", "0", "\"__SH4_NOFPU__\"", "\"__SH_FPU_ANY__\"", "\"__SH_FPU_DOUBLE__\"", "\"__HITACHI__\"", "\"__FMOVD_ENABLED__\"", "\"__SH_FDPIC__\"", "\"__FDPIC__\"", "\"__LITTLE_ENDIAN__\"", "\"__BIG_ENDIAN__\"", "\"__SH_ATOMIC_MODEL_%s__\"" ]

[]

[ "<s>", "StringRef", "RISCVMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_RISCV_LO", ":", "return", "\"lo\"", ";", "case", "VK_RISCV_HI", ":", "return", "\"hi\"", ";", "case", "VK_RISCV_PCREL_LO", ":", "return", "\"pcrel_lo\"", ";", "case", "VK_RISCV_PCREL_HI", ":", "return", "\"pcrel_hi\"", ";", "case", "VK_RISCV_GOT_HI", ":", "return", "\"got_pcrel_hi\"", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "RISCV", "RISCV", "\"Invalid ELF symbol kind\"", "RISCV", "\"lo\"", "RISCV", "\"hi\"", "RISCV", "\"pcrel_lo\"", "RISCV", "\"pcrel_hi\"", "RISCV", "\"got_pcrel_hi\"" ]

[]

[ "<s>", "void", "LEGAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "isPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "4", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "{", "return", ";", "}", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "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", "." ]

[ "LEG", "LEG", "4", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "areLoadsFromSameBasePtr", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "&", "Offset1", ",", "int64_t", "&", "Offset2", ")", "const", "{", "if", "(", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Load1", "->", "isMachineOpcode", "(", ")", "||", "!", "Load2", "->", "isMachineOpcode", "(", ")", ")", "return", "false", ";", "switch", "(", "Load1", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "LDRD", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRSB", ":", "case", "ARM", "::", "LDRSH", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2LDRDi8", ":", "case", "ARM", "::", "t2LDRSHi8", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRSHi12", ":", "break", ";", "}", "switch", "(", "Load2", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "LDRD", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRSB", ":", "case", "ARM", "::", "LDRSH", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2LDRSHi8", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRSHi12", ":", "break", ";", "}", "if", "(", "Load1", "->", "getOperand", "(", "0", ")", "!=", "Load2", "->", "getOperand", "(", "0", ")", "||", "Load1", "->", "getOperand", "(", "4", ")", "!=", "Load2", "->", "getOperand", "(", "4", ")", ")", "return", "false", ";", "if", "(", "Load1", "->", "getOperand", "(", "3", ")", "!=", "Load2", "->", "getOperand", "(", "3", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "1", ")", ")", ")", "{", "Offset1", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "->", "getSExtValue", "(", ")", ";", "Offset2", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "1", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "areLoadsFromSameBasePtr", "-", "This", "is", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "if", "two", "loads", "are", "loading", "from", "the", "same", "base", "address", "." ]

[ "ARM", "ARM", "ARM::LDRi12", "ARM::LDRBi12", "ARM::LDRD", "ARM::LDRH", "ARM::LDRSB", "ARM::LDRSH", "ARM::VLDRD", "ARM::VLDRS", "ARM::t2LDRi8", "ARM::t2LDRDi8", "ARM::t2LDRSHi8", "ARM::t2LDRi12", "ARM::t2LDRSHi12", "ARM::LDRi12", "ARM::LDRBi12", "ARM::LDRD", "ARM::LDRH", "ARM::LDRSB", "ARM::LDRSH", "ARM::VLDRD", "ARM::VLDRS", "ARM::t2LDRi8", "ARM::t2LDRSHi8", "ARM::t2LDRi12", "ARM::t2LDRSHi12", "0", "0", "4", "4", "3", "3", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", "->", "getTargetLowering", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "erase", "(", "SDNode", "*", "N", ")", "{", "auto", "F", "=", "Refs", ".", "find", "(", "N", ")", ";", "if", "(", "F", "!=", "Refs", ".", "end", "(", ")", ")", "*", "F", "->", "second", "=", "nullptr", ";", "}", "</s>" ]

[ "erase", "-", "Erases", "an", "element", "identified", "by", "Key", ",", "if", "it", "exists", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "isSafeToMoveRegClassDefs", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "isSafeToMoveRegClassDefs", "-", "Return", "true", "if", "it", "'s", "safe", "to", "move", "a", "machine", "instruction", "that", "defines", "the", "specified", "register", "class", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "const_load_sequence_p", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid", "]", ".", "is_swap", "||", "insn_entry", "[", "uid", "]", ".", "is_load", ")", "return", "false", ";", "const_rtx", "tocrel_base", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "use", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "def_link", "||", "!", "def_link", "->", "ref", "||", "DF_REF_IS_ARTIFICIAL", "(", "def_link", "->", "ref", ")", "||", "def_link", "->", "next", ")", "return", "false", ";", "rtx", "def_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "unsigned", "uid2", "=", "INSN_UID", "(", "def_insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid2", "]", ".", "is_load", "||", "!", "insn_entry", "[", "uid2", "]", ".", "is_swap", ")", "return", "false", ";", "rtx", "body", "=", "PATTERN", "(", "def_insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "!=", "VEC_SELECT", "||", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "!=", "MEM", ")", "return", "false", ";", "rtx", "mem", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "base_reg", ")", ")", "return", "false", ";", "df_ref", "base_use", ";", "insn_info", "=", "DF_INSN_INFO_GET", "(", "def_insn", ")", ";", "FOR_EACH_INSN_INFO_USE", "(", "base_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "base_use", ")", ",", "base_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "base_def_link", "=", "DF_REF_CHAIN", "(", "base_use", ")", ";", "if", "(", "!", "base_def_link", "||", "base_def_link", "->", "next", ")", "return", "false", ";", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "base_def_link", "->", "ref", ")", ")", "return", "false", ";", "rtx", "tocrel_insn", "=", "DF_REF_INSN", "(", "base_def_link", "->", "ref", ")", ";", "rtx", "tocrel_body", "=", "PATTERN", "(", "tocrel_insn", ")", ";", "rtx", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "tocrel_body", ")", "!=", "SET", ")", "return", "false", ";", "rtx", "tocrel_expr", "=", "SET_SRC", "(", "tocrel_body", ")", ";", "if", "(", "GET_CODE", "(", "tocrel_expr", ")", "==", "MEM", ")", "tocrel_expr", "=", "XEXP", "(", "tocrel_expr", ",", "0", ")", ";", "if", "(", "!", "toc_relative_expr_p", "(", "tocrel_expr", ",", "false", ",", "&", "tocrel_base", ",", "NULL", ")", ")", "return", "false", ";", "split_const", "(", "XVECEXP", "(", "tocrel_base", ",", "0", ",", "0", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "!=", "SYMBOL_REF", "||", "!", "CONSTANT_POOL_ADDRESS_P", "(", "base", ")", ")", "return", "false", ";", "else", "{", "rtx", "const_vector", "=", "get_pool_constant", "(", "base", ")", ";", "if", "(", "GET_CODE", "(", "const_vector", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "const_vector", ")", ")", "const_vector", "=", "get_pool_constant", "(", "const_vector", ")", ";", "if", "(", "GET_CODE", "(", "const_vector", ")", "!=", "CONST_VECTOR", ")", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "insn", "is", "a", "swap", "fed", "by", "a", "load", "from", "the", "constant", "pool", "." ]

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

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Lanai", "::", "SW_RI", ")", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::SW_RI", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "bool", "TVMContinuationsHoist", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "TVMSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "collect", "(", "MF", ")", ";", "bool", "Changed", "=", "optimize", "(", ")", ";", "LLVM_DEBUG", "(", "{", "if", "(", "Changed", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ";", "else", "dbgs", "(", ")", "<<", "\"No changes\\n\"", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "\"Before \"", "TVM", "\"After \"", "\"No changes\\n\"" ]

[]

[ "<s>", "bool", "AArch64LegalizerInfo", "::", "legalizeCustom", "(", "LegalizerHelper", "&", "Helper", ",", "MachineInstr", "&", "MI", ")", "const", "{", "MachineIRBuilder", "&", "MIRBuilder", "=", "Helper", ".", "MIRBuilder", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "MIRBuilder", ".", "getMRI", "(", ")", ";", "GISelChangeObserver", "&", "Observer", "=", "Helper", ".", "Observer", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_VAARG", ":", "return", "legalizeVaArg", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "legalizeLoadStore", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_BSWAP", ":", "return", "legalizeBSwap", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "legalizeShlAshrLshr", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeSmallCMGlobalValue", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_TRUNC", ":", "return", "legalizeVectorTrunc", "(", "MI", ",", "Helper", ")", ";", "case", "TargetOpcode", "::", "G_SBFX", ":", "case", "TargetOpcode", "::", "G_UBFX", ":", "return", "legalizeBitfieldExtract", "(", "MI", ",", "MRI", ",", "Helper", ")", ";", "case", "TargetOpcode", "::", "G_ROTR", ":", "return", "legalizeRotate", "(", "MI", ",", "MRI", ",", "Helper", ")", ";", "case", "TargetOpcode", "::", "G_CTPOP", ":", "return", "legalizeCTPOP", "(", "MI", ",", "MRI", ",", "Helper", ")", ";", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "return", "legalizeAtomicCmpxchg128", "(", "MI", ",", "MRI", ",", "Helper", ")", ";", "case", "TargetOpcode", "::", "G_CTTZ", ":", "return", "legalizeCTTZ", "(", "MI", ",", "Helper", ")", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AArch64", "AArch64", "\"expected switch to return\"" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "MipsRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_ADD", ":", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "Mips", "Mips", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "1" ]

[]

[ "<s>", "bool", "NVPTXImageOptimizer", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "InstrToDelete", ".", "clear", "(", ")", ";", "for", "(", "Function", "::", "iterator", "BI", "=", "F", ".", "begin", "(", ")", ",", "BE", "=", "F", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "(", "*", "BI", ")", ".", "begin", "(", ")", ",", "E", "=", "(", "*", "BI", ")", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Instruction", "&", "Instr", "=", "*", "I", ";", "if", "(", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ")", "{", "Function", "*", "CalledF", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "CalledF", "&&", "CalledF", "->", "isIntrinsic", "(", ")", ")", "{", "switch", "(", "CalledF", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_sampler", ":", "Changed", "|=", "replaceIsTypePSampler", "(", "Instr", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_surface", ":", "Changed", "|=", "replaceIsTypePSurface", "(", "Instr", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_texture", ":", "Changed", "|=", "replaceIsTypePTexture", "(", "Instr", ")", ";", "break", ";", "}", "}", "}", "}", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "InstrToDelete", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "InstrToDelete", "[", "i", "]", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "Intrinsic::nvvm_istypep_sampler", "Intrinsic::nvvm_istypep_surface", "Intrinsic::nvvm_istypep_texture", "0" ]

[]

[ "<s>", "void", "TeakAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "Teak", "Teak" ]

[]

[ "<s>", "StringRef", "RISCVMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_RISCV_LO", ":", "return", "\"lo\"", ";", "case", "VK_RISCV_HI", ":", "return", "\"hi\"", ";", "case", "VK_RISCV_PCREL_LO", ":", "return", "\"pcrel_lo\"", ";", "case", "VK_RISCV_PCREL_HI", ":", "return", "\"pcrel_hi\"", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "RISCV", "RISCV", "\"Invalid ELF symbol kind\"", "RISCV", "\"lo\"", "RISCV", "\"hi\"", "RISCV", "\"pcrel_lo\"", "RISCV", "\"pcrel_hi\"" ]

[]

[ "<s>", "void", "addIRPasses", "(", ")", "override", "{", "addPass", "(", "createTGSIAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "TGSI", "TGSI" ]

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "Teak" ]

[]

[ "<s>", "tree", "function_resolver", "::", "finish_opt_n_resolution", "(", "unsigned", "int", "argno", ",", "unsigned", "int", "first_argno", ",", "type_suffix_index", "first_type", ",", "type_class_index", "expected_tclass", ",", "unsigned", "int", "expected_bits", ",", "type_suffix_index", "inferred_type", ")", "{", "if", "(", "inferred_type", "==", "NUM_TYPE_SUFFIXES", ")", "inferred_type", "=", "first_type", ";", "tree", "scalar_form", "=", "lookup_form", "(", "MODE_n", ",", "inferred_type", ")", ";", "if", "(", "scalar_argument_p", "(", "argno", ")", ")", "{", "if", "(", "scalar_form", ")", "return", "scalar_form", ";", "tree", "res", "=", "resolve_to", "(", "mode_suffix_id", ",", "inferred_type", ")", ";", "if", "(", "res", "!=", "error_mark_node", ")", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, but its\"", "\" %qT form does not accept scalars\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ",", "get_vector_type", "(", "first_type", ")", ")", ";", "return", "error_mark_node", ";", "}", "if", "(", "scalar_form", "&&", "!", "require_vector_or_scalar_type", "(", "argno", ")", ")", "return", "error_mark_node", ";", "if", "(", "!", "require_derived_vector_type", "(", "argno", ",", "first_argno", ",", "first_type", ",", "expected_tclass", ",", "expected_bits", ")", ")", "return", "error_mark_node", ";", "return", "resolve_to", "(", "mode_suffix_id", ",", "inferred_type", ")", ";", "}", "</s>" ]

[ "Finish", "resolving", "a", "function", "whose", "final", "argument", "can", "be", "a", "vector", "or", "a", "scalar", ",", "with", "the", "function", "having", "an", "implicit", "``", "_n", "''", "suffix", "in", "the", "latter", "case", ".", "This", "``", "_n", "''", "form", "might", "only", "exist", "for", "certain", "type", "suffixes", ".", "ARGNO", "is", "the", "index", "of", "the", "final", "argument", ".", "The", "inferred", "type", "suffix", "was", "obtained", "from", "argument", "FIRST_ARGNO", ",", "which", "has", "type", "FIRST_TYPE", ".", "EXPECTED_TCLASS", "and", "EXPECTED_BITS", "describe", "the", "expected", "properties", "of", "the", "final", "vector", "or", "scalar", "argument", ",", "in", "the", "same", "way", "as", "for", "require_derived_vector_type", ".", "INFERRED_TYPE", "is", "the", "inferred", "type", "suffix", "itself", ",", "or", "NUM_TYPE_SUFFIXES", "if", "it", "'s", "the", "same", "as", "FIRST_TYPE", ".", "Return", "the", "function", "decl", "of", "the", "resolved", "function", "on", "success", ",", "otherwise", "report", "a", "suitable", "error", "and", "return", "error_mark_node", "." ]

[ "aarch64", "\"passing %qT to argument %d of %qE, but its\"", "\" %qT form does not accept scalars\"", "1" ]

[]

[ "<s>", "static", "void", "aarch64_init_bf16_types", "(", "void", ")", "{", "aarch64_bf16_type_node", "=", "make_node", "(", "REAL_TYPE", ")", ";", "TYPE_PRECISION", "(", "aarch64_bf16_type_node", ")", "=", "16", ";", "SET_TYPE_MODE", "(", "aarch64_bf16_type_node", ",", "BFmode", ")", ";", "layout_type", "(", "aarch64_bf16_type_node", ")", ";", "lang_hooks", ".", "types", ".", "register_builtin_type", "(", "aarch64_bf16_type_node", ",", "\"__bf16\"", ")", ";", "aarch64_bf16_ptr_type_node", "=", "build_pointer_type", "(", "aarch64_bf16_type_node", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "backend", "REAL_TYPE", "type", "supporting", "bfloat", "types", "." ]

[ "aarch64", "16", "\"__bf16\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Always Inline Pass\"", ";", "}", "</s>" ]

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

[ "R600", "\"AMDGPU Always Inline Pass\"" ]

[]

[ "<s>", "void", "cris_expand_return", "(", "bool", "on_stack", ")", "{", "emit_jump_insn", "(", "ret_rtx", ")", ";", "CRIS_ASSERT", "(", "cfun", "->", "machine", "->", "return_type", "!=", "CRIS_RETINSN_RET", "||", "!", "on_stack", ")", ";", "CRIS_ASSERT", "(", "cfun", "->", "machine", "->", "return_type", "!=", "CRIS_RETINSN_JUMP", "||", "on_stack", ")", ";", "cfun", "->", "machine", "->", "return_type", "=", "on_stack", "?", "CRIS_RETINSN_JUMP", ":", "CRIS_RETINSN_RET", ";", "}", "</s>" ]

[ "Expand", "a", "return", "insn", "(", "just", "one", "insn", ")", "marked", "as", "using", "SRP", "or", "stack", "slot", "depending", "on", "parameter", "ON_STACK", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "ix86_memtag_can_tag_addresses", "(", ")", "{", "return", "ix86_lam_type", "!=", "lam_none", "&&", "TARGET_LP64", ";", "}", "</s>" ]

[ "Implement", "TARGET_MEMTAG_CAN_TAG_ADDRESSES", "." ]

[ "i386" ]

[]

[ "<s>", "void", "aarch64_asm_output_alias", "(", "FILE", "*", "stream", ",", "const", "tree", "decl", ",", "const", "tree", "target", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ",", "0", ")", ";", "const", "char", "*", "value", "=", "IDENTIFIER_POINTER", "(", "target", ")", ";", "aarch64_asm_output_variant_pcs", "(", "stream", ",", "decl", ",", "name", ")", ";", "ASM_OUTPUT_DEF", "(", "stream", ",", "name", ",", "value", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_DEF_FROM_DECLS", ".", "Output", ".variant_pcs", "for", "aliases", "." ]

[ "aarch64", "0", "0" ]

[]

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

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

[ "Cpu0" ]

[]

[ "<s>", "bool", "c6x_valid_mask_p", "(", "HOST_WIDE_INT", "val", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "!", "(", "val", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "i", ")", ")", ")", "break", ";", "for", "(", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "val", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "i", ")", ")", "break", ";", "for", "(", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "!", "(", "val", "&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "i", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "VAL", "is", "a", "mask", "valid", "for", "a", "clr", "instruction", "." ]

[ "c6x", "0", "32", "1", "32", "1", "32", "1" ]

[]

[ "<s>", "static", "int", "sparc_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "int", "slotno", ",", "regno", ",", "padding", ";", "slotno", "=", "function_arg_slotno", "(", "get_cumulative_args", "(", "cum", ")", ",", "mode", ",", "type", ",", "named", ",", "false", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "TARGET_ARCH32", ")", "{", "const", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "{", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "(", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", "||", "slotno", "==", "SPARC_FP_ARG_MAX", "-", "1", ")", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "||", "(", "type", "&&", "VECTOR_TYPE_P", "(", "type", ")", ")", ")", "&&", "!", "(", "TARGET_FPU", "&&", "named", ")", ")", ")", "{", "const", "int", "size", "=", "(", "type", "&&", "VECTOR_FLOAT_TYPE_P", "(", "type", ")", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "||", "(", "type", "&&", "VECTOR_TYPE_P", "(", "type", ")", ")", ")", "{", "const", "int", "size", "=", "(", "type", "&&", "VECTOR_FLOAT_TYPE_P", "(", "type", ")", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_FP_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "of", "registers", "used", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "Any", "arg", "that", "starts", "in", "the", "first", "6", "regs", "but", "wo", "n't", "entirely", "fit", "in", "them", "needs", "partial", "registers", "on", "v8", ".", "On", "v9", ",", "structures", "with", "integer", "values", "in", "arg", "slots", "5,6", "will", "be", "passed", "in", "%", "o5", "and", "SP+176", ",", "and", "complex", "fp", "values", "that", "begin", "in", "the", "last", "fp", "reg", "[", "where", "``", "last", "fp", "reg", "''", "varies", "with", "the", "mode", "]", "will", "be", "split", "between", "that", "reg", "and", "memory", "." ]

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

[]

[ "<s>", "rtx", "legitimize_tls_address", "(", "rtx", "x", ",", "rtx", "reg", ")", "{", "rtx", "dest", ",", "tp", ",", "label", ",", "labelno", ",", "sum", ",", "ret", ",", "eqv", ",", "addend", ";", "rtx_insn", "*", "insns", ";", "unsigned", "int", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "if", "(", "TARGET_GNU2_TLS", ")", "{", "reg", "=", "arm_tls_descseq_addr", "(", "x", ",", "reg", ")", ";", "tp", "=", "arm_load_tp", "(", "NULL_RTX", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "}", "else", "{", "insns", "=", "arm_call_tls_get_addr", "(", "x", ",", "reg", ",", "&", "ret", ",", "TLS_GD32", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "ret", ",", "x", ")", ";", "}", "return", "dest", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "if", "(", "TARGET_GNU2_TLS", ")", "{", "reg", "=", "arm_tls_descseq_addr", "(", "x", ",", "reg", ")", ";", "tp", "=", "arm_load_tp", "(", "NULL_RTX", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "}", "else", "{", "insns", "=", "arm_call_tls_get_addr", "(", "x", ",", "reg", ",", "&", "ret", ",", "TLS_LDM32", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const1_rtx", ")", ",", "UNSPEC_TLS", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "ret", ",", "eqv", ")", ";", "addend", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "TLS_LDO32", ")", ")", ",", "UNSPEC_TLS", ")", ";", "addend", "=", "force_reg", "(", "SImode", ",", "gen_rtx_CONST", "(", "SImode", ",", "addend", ")", ")", ";", "dest", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "dest", ",", "addend", ")", ";", "}", "return", "dest", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "labelno", "=", "GEN_INT", "(", "pic_labelno", "++", ")", ";", "label", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "labelno", ")", ",", "UNSPEC_PIC_LABEL", ")", ";", "label", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "label", ")", ";", "sum", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "4", ",", "x", ",", "GEN_INT", "(", "TLS_IE32", ")", ",", "label", ",", "GEN_INT", "(", "TARGET_ARM", "?", "8", ":", "4", ")", ")", ",", "UNSPEC_TLS", ")", ";", "reg", "=", "load_tls_operand", "(", "sum", ",", "reg", ")", ";", "if", "(", "TARGET_ARM", ")", "emit_insn", "(", "gen_tls_load_dot_plus_eight", "(", "reg", ",", "reg", ",", "labelno", ")", ")", ";", "else", "if", "(", "TARGET_THUMB2", ")", "emit_insn", "(", "gen_tls_load_dot_plus_four", "(", "reg", ",", "NULL", ",", "reg", ",", "labelno", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_pic_add_dot_plus_four", "(", "reg", ",", "reg", ",", "labelno", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "gen_const_mem", "(", "SImode", ",", "reg", ")", ")", ";", "}", "tp", "=", "arm_load_tp", "(", "NULL_RTX", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "tp", "=", "arm_load_tp", "(", "NULL_RTX", ")", ";", "reg", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "TLS_LE32", ")", ")", ",", "UNSPEC_TLS", ")", ";", "reg", "=", "force_reg", "(", "SImode", ",", "gen_rtx_CONST", "(", "SImode", ",", "reg", ")", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "tp", ",", "reg", ")", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "</s>" ]

[ "ADDR", "contains", "a", "thread-local", "SYMBOL_REF", ".", "Generate", "code", "to", "compute", "this", "(", "thread-local", ")", "address", "." ]

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

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "AtStart", "=", "MI", "==", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "BeforeI", "=", "MI", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "assert", "(", "Reg", "!=", "XCore", "::", "LR", "&&", "!", "(", "Reg", "==", "XCore", "::", "R10", "&&", "hasFP", "(", "*", "MF", ")", ")", "&&", "\"LR & FP are always handled in emitEpilogue\"", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "if", "(", "AtStart", ")", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "MI", "=", "BeforeI", ";", "++", "MI", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::LR", "XCore::R10", "\"LR & FP are always handled in emitEpilogue\"", "\"loadRegFromStackSlot didn't insert any code!\"" ]

[]

[ "<s>", "void", "TPCPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createTPCHWWAGeneral", "(", ")", ")", ";", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createTPCPredicateOptimizer", "(", ")", ")", ";", "addPass", "(", "createTPCSetIndxCoalescer", "(", ")", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "void", "Note", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "ArrayRef", "<", "SMRange", ">", "Ranges", "=", "None", ")", "{", "return", "getParser", "(", ")", ".", "Note", "(", "L", ",", "Msg", ",", "Ranges", ")", ";", "}", "</s>" ]

[ "Emit", "a", "note", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "ARM" ]

[]

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

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

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

[]

[ "<s>", "MachineInstr", "*", "WebAssemblyInstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx1", ",", "unsigned", "OpIdx2", ")", "const", "{", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "MI", "->", "getOperand", "(", "OpIdx1", ")", ".", "getReg", "(", ")", ")", "||", "MFI", ".", "isVRegStackified", "(", "MI", "->", "getOperand", "(", "OpIdx2", ")", ".", "getReg", "(", ")", ")", ")", "return", "nullptr", ";", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "</s>" ]

[ "Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "." ]

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

[]

[ "<s>", "void", "WebAssemblyMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint64_t", "Start", "=", "OS", ".", "tell", "(", ")", ";", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "assert", "(", "Binary", "<", "UINT8_MAX", "&&", "\"Multi-byte opcodes not supported yet\"", ")", ";", "OS", "<<", "uint8_t", "(", "Binary", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "if", "(", "i", "<", "Desc", ".", "getNumOperands", "(", ")", ")", "{", "assert", "(", "Desc", ".", "TSFlags", "==", "0", "&&", "\"WebAssembly non-variable_ops don't use TSFlags\"", ")", ";", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "i", "]", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_I32IMM", ")", "{", "encodeSLEB128", "(", "int32_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "else", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_I64IMM", ")", "{", "encodeSLEB128", "(", "int64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "else", "{", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "{", "assert", "(", "Desc", ".", "TSFlags", "==", "(", "WebAssemblyII", "::", "VariableOpIsImmediate", "|", "WebAssemblyII", "::", "VariableOpImmediateIsLabel", ")", ")", ";", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "assert", "(", "i", "<", "Desc", ".", "getNumOperands", "(", ")", "&&", "\"Unexpected floating-point immediate as a non-fixed operand\"", ")", ";", "assert", "(", "Desc", ".", "TSFlags", "==", "0", "&&", "\"WebAssembly variable_ops floating point ops don't use TSFlags\"", ")", ";", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "i", "]", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F32IMM", ")", "{", "float", "f", "=", "float", "(", "MO", ".", "getFPImm", "(", ")", ")", ";", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "float", ">", "(", "f", ")", ";", "}", "else", "{", "assert", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F64IMM", ")", ";", "double", "d", "=", "MO", ".", "getFPImm", "(", ")", ";", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "double", ">", "(", "d", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "OS", ".", "tell", "(", ")", "-", "Start", ",", "MO", ".", "getExpr", "(", ")", ",", "STI", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", "?", "FK_Data_8", ":", "FK_Data_4", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "encodeULEB128", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", "?", "UINT64_MAX", ":", "uint64_t", "(", "UINT32_MAX", ")", ",", "OS", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"unexpected operand kind\"", ")", ";", "}", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"Multi-byte opcodes not supported yet\"", "0", "0", "\"WebAssembly non-variable_ops don't use TSFlags\"", "WebAssembly::OPERAND_I32IMM", "WebAssembly::OPERAND_I64IMM", "WebAssemblyII::VariableOpIsImmediate", "WebAssemblyII::VariableOpImmediateIsLabel", "\"Unexpected floating-point immediate as a non-fixed operand\"", "0", "\"WebAssembly variable_ops floating point ops don't use TSFlags\"", "WebAssembly::OPERAND_F32IMM", "support::endian", "support::little", "WebAssembly::OPERAND_F64IMM", "support::endian", "support::little", "\"unexpected operand kind\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AVRFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "AVR", "::", "R29R28", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "getStackAlign", "(", ")", "==", "Align", "(", "1", ")", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SUBIWRdK", ")", ",", "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", ")", ";", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "AVR", "::", "R31R30", ")", ";", "}", "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", "AVR::R29R28", "0", "1", "\"Unsupported stack alignment\"", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::SUBIWRdK", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getPPCSubtarget", "(", ")", ".", "hasVSX", "(", ")", ")", "{", "initializePPCVSXFMAMutatePass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "VSXFMAMutateEarly", "?", "&", "RegisterCoalescerID", ":", "&", "MachineSchedulerID", ",", "&", "PPCVSXFMAMutateID", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "pa_hard_regno_nregs", "(", "unsigned", "int", "regno", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "return", "PA_HARD_REGNO_NREGS", "(", "regno", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", "." ]

[ "pa" ]

[]

[ "<s>", "static", "tree", "rs6000_vector_type", "(", "const", "char", "*", "name", ",", "tree", "elt_type", ",", "unsigned", "num_elts", ")", "{", "tree", "result", "=", "build_vector_type", "(", "elt_type", ",", "num_elts", ")", ";", "result", "=", "build_variant_type_copy", "(", "result", ")", ";", "add_builtin_type", "(", "name", ",", "result", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Create", "a", "builtin", "vector", "type", "with", "a", "name", ".", "Taking", "care", "not", "to", "give", "the", "canonical", "type", "a", "name", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "MCExpr", "*", "X86_64MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "(", "Encoding", "&", "DW_EH_PE_indirect", ")", "&&", "(", "Encoding", "&", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOTPCREL", ",", "getContext", "(", ")", ")", ";", "const", "MCExpr", "*", "Four", "=", "MCConstantExpr", "::", "create", "(", "4", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createAdd", "(", "Res", ",", "Four", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

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

[]

[ "<s>", "bool", "SystemZRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "assert", "(", "MI", "->", "isCopy", "(", ")", "&&", "\"Only expecting COPY instructions\"", ")", ";", "if", "(", "!", "(", "NewRC", "->", "hasSuperClassEq", "(", "&", "SystemZ", "::", "GR128BitRegClass", ")", "&&", "(", "getRegSizeInBits", "(", "*", "SrcRC", ")", "<=", "64", "||", "getRegSizeInBits", "(", "*", "DstRC", ")", "<=", "64", ")", ")", ")", "return", "true", ";", "unsigned", "WideOpNo", "=", "(", "getRegSizeInBits", "(", "*", "SrcRC", ")", "==", "128", "?", "1", ":", "0", ")", ";", "Register", "GR128Reg", "=", "MI", "->", "getOperand", "(", "WideOpNo", ")", ".", "getReg", "(", ")", ";", "Register", "GRNarReg", "=", "MI", "->", "getOperand", "(", "(", "WideOpNo", "==", "1", ")", "?", "0", ":", "1", ")", ".", "getReg", "(", ")", ";", "LiveInterval", "&", "IntGR128", "=", "LIS", ".", "getInterval", "(", "GR128Reg", ")", ";", "LiveInterval", "&", "IntGRNar", "=", "LIS", ".", "getInterval", "(", "GRNarReg", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "FirstMI_GR128", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGR128", ".", "beginIndex", "(", ")", ")", ";", "MachineInstr", "*", "FirstMI_GRNar", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGRNar", ".", "beginIndex", "(", ")", ")", ";", "MachineInstr", "*", "LastMI_GR128", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGR128", ".", "endIndex", "(", ")", ")", ";", "MachineInstr", "*", "LastMI_GRNar", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGRNar", ".", "endIndex", "(", ")", ")", ";", "if", "(", "(", "!", "FirstMI_GR128", "||", "FirstMI_GR128", "->", "getParent", "(", ")", "!=", "MBB", ")", "||", "(", "!", "FirstMI_GRNar", "||", "FirstMI_GRNar", "->", "getParent", "(", ")", "!=", "MBB", ")", "||", "(", "!", "LastMI_GR128", "||", "LastMI_GR128", "->", "getParent", "(", ")", "!=", "MBB", ")", "||", "(", "!", "LastMI_GRNar", "||", "LastMI_GRNar", "->", "getParent", "(", ")", "!=", "MBB", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "MII", "=", "nullptr", ",", "MEE", "=", "nullptr", ";", "if", "(", "WideOpNo", "==", "1", ")", "{", "MII", "=", "FirstMI_GR128", ";", "MEE", "=", "LastMI_GRNar", ";", "}", "else", "{", "MII", "=", "FirstMI_GRNar", ";", "MEE", "=", "LastMI_GR128", ";", "}", "BitVector", "PhysClobbered", "(", "getNumRegs", "(", ")", ")", ";", "MEE", "++", ";", "for", "(", ";", "MII", "!=", "MEE", ";", "++", "MII", ")", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MII", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "Register", "::", "isPhysicalRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SI", "(", "MO", ".", "getReg", "(", ")", ",", "this", ",", "true", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "NewRC", "->", "contains", "(", "*", "SI", ")", ")", "{", "PhysClobbered", ".", "set", "(", "*", "SI", ")", ";", "break", ";", "}", "}", "}", "unsigned", "const", "DemandedFreeGR128", "=", "3", ";", "if", "(", "PhysClobbered", ".", "count", "(", ")", ">", "(", "NewRC", "->", "getNumRegs", "(", ")", "-", "DemandedFreeGR128", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "SystemZ", "SystemZ", "\"Only expecting COPY instructions\"", "SystemZ::GR128BitRegClass", "64", "64", "128", "1", "0", "1", "0", "1", "1", "3" ]

[]

[ "<s>", "static", "void", "s300_set_up_by_prologue", "(", "hard_reg_set_container", "*", "regs", ")", "{", "if", "(", "cfun", "->", "machine", "->", "base_reg", "&&", "!", "call_used_regs", "[", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "]", ")", "SET_HARD_REG_BIT", "(", "regs", "->", "set", ",", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SET_UP_BY_PROLOGUE", "." ]

[ "s390" ]

[]

[ "<s>", "int", "byte_accesses_mergeable_p", "(", "rtx", "addr1", ",", "rtx", "addr2", ")", "{", "HOST_WIDE_INT", "offset1", ",", "offset2", ";", "rtx", "reg1", ",", "reg2", ";", "if", "(", "REG_P", "(", "addr1", ")", ")", "{", "reg1", "=", "addr1", ";", "offset1", "=", "0", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr1", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "addr1", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "addr1", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "reg1", "=", "XEXP", "(", "addr1", ",", "0", ")", ";", "offset1", "=", "INTVAL", "(", "XEXP", "(", "addr1", ",", "1", ")", ")", ";", "}", "else", "return", "0", ";", "if", "(", "REG_P", "(", "addr2", ")", ")", "{", "reg2", "=", "addr2", ";", "offset2", "=", "0", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr2", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "addr2", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "addr2", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "reg2", "=", "XEXP", "(", "addr2", ",", "0", ")", ";", "offset2", "=", "INTVAL", "(", "XEXP", "(", "addr2", ",", "1", ")", ")", ";", "}", "else", "return", "0", ";", "if", "(", "(", "(", "reg1", "==", "stack_pointer_rtx", "&&", "reg2", "==", "stack_pointer_rtx", ")", "||", "(", "reg1", "==", "frame_pointer_rtx", "&&", "reg2", "==", "frame_pointer_rtx", ")", ")", "&&", "offset1", "%", "2", "==", "0", "&&", "offset1", "+", "1", "==", "offset2", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "ADDR1", "and", "ADDR2", "point", "to", "consecutive", "memory", "locations", "that", "can", "be", "accessed", "as", "a", "16-bit", "word", "." ]

[ "h8300", "0", "0", "1", "0", "1", "0", "0", "0", "1", "0", "1", "0", "2", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "!", "isInt", "<", "20", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "AddressingMode", "SupportedAM", "(", "true", ",", "true", ")", ";", "if", "(", "I", "!=", "nullptr", ")", "SupportedAM", "=", "supportedAddressingMode", "(", "I", ",", "Subtarget", ".", "hasVector", "(", ")", ")", ";", "if", "(", "!", "SupportedAM", ".", "LongDisplacement", "&&", "!", "isUInt", "<", "12", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "!", "SupportedAM", ".", "IndexReg", ")", "return", "AM", ".", "Scale", "==", "0", ";", "else", "return", "AM", ".", "Scale", "==", "0", "||", "AM", ".", "Scale", "==", "1", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "20", "12", "0", "0", "1" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "bool", "is64", "=", "getPointerSize", "(", ")", "==", "8", ";", "return", "createELFObjectWriter", "(", "new", "PPCELFObjectWriter", "(", "is64", ",", "OSType", ",", "is64", "?", "ELF", "::", "EM_PPC64", ":", "ELF", "::", "EM_PPC", ",", "true", ",", "false", ")", ",", "OS", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "~", "SystemZXPLINK64Registers", "(", ")", "{", "}", "</s>" ]

[ "Destroys", "the", "object", ".", "Bogus", "destructor", "overriding", "base", "class", "destructor", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "reg", ",", "count", ";", "int", "int_or_sig_p", "=", "(", "interrupt_function_p", "(", "current_function_decl", ")", "||", "signal_function_p", "(", "current_function_decl", ")", ")", ";", "int", "leaf_func_p", "=", "leaf_function_p", "(", ")", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "0", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", "return", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "32", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "leaf_func_p", "&&", "call_used_regs", "[", "reg", "]", ")", "||", "(", "regs_ever_live", "[", "reg", "]", "&&", "(", "int_or_sig_p", "||", "!", "call_used_regs", "[", "reg", "]", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "(", "REG_Y", "+", "1", ")", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "." ]

[ "avr", "0", "0", "0", "32", "1" ]

[]

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

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

[ "Z80", "MVT::i8" ]

[]

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

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

[ "SIC" ]

[]

[ "<s>", "AVRSubtarget", "::", "AVRSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "AVRTargetMachine", "&", "TM", ")", ":", "AVRGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ELFArch", "(", "0", ")", ",", "m_hasSRAM", "(", "false", ")", ",", "m_hasJMPCALL", "(", "false", ")", ",", "m_hasIJMPCALL", "(", "false", ")", ",", "m_hasEIJMPCALL", "(", "false", ")", ",", "m_hasADDSUBIW", "(", "false", ")", ",", "m_hasSmallStack", "(", "false", ")", ",", "m_hasMOVW", "(", "false", ")", ",", "m_hasLPM", "(", "false", ")", ",", "m_hasLPMX", "(", "false", ")", ",", "m_hasELPM", "(", "false", ")", ",", "m_hasELPMX", "(", "false", ")", ",", "m_hasSPM", "(", "false", ")", ",", "m_hasSPMX", "(", "false", ")", ",", "m_hasDES", "(", "false", ")", ",", "m_supportsRMW", "(", "false", ")", ",", "m_supportsMultiplication", "(", "false", ")", ",", "m_hasBREAK", "(", "false", ")", ",", "m_hasTinyEncoding", "(", "false", ")", ",", "m_hasMemMappedGPR", "(", "false", ")", ",", "m_FeatureSetDummy", "(", "false", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", ")", ",", "TLInfo", "(", "TM", ",", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ",", "TSInfo", "(", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "Creates", "an", "AVR", "subtarget", "." ]

[ "AVR", "AVR", "AVR", "AVR", "AVR", "0" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "c6x_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Allocate", "a", "new", ",", "cleared", "machine_function", "structure", "." ]

[ "c6x" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", "&", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "os16", "(", ")", ")", "addPass", "(", "createMipsOs16Pass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "inMips16HardFloat", "(", ")", ")", "addPass", "(", "createMips16HardFloatPass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "convertToThreeAddress", "(", "MachineFunction", "::", "iterator", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "LiveVariables", "*", "LV", ")", "const", "{", "bool", "IsF16", "=", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "nullptr", ";", "case", "AMDGPU", "::", "V_MAC_F16_e64", ":", "IsF16", "=", "true", ";", "case", "AMDGPU", "::", "V_MAC_F32_e64", ":", "break", ";", "case", "AMDGPU", "::", "V_MAC_F16_e32", ":", "IsF16", "=", "true", ";", "case", "AMDGPU", "::", "V_MAC_F32_e32", ":", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "const", "MachineOperand", "*", "Src0", "=", "&", "MI", ".", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "Src0", "->", "isImm", "(", ")", "&&", "!", "isInlineConstant", "(", "MI", ",", "Src0Idx", ",", "*", "Src0", ")", ")", "return", "nullptr", ";", "break", ";", "}", "}", "const", "MachineOperand", "*", "Dst", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "const", "MachineOperand", "*", "Src0", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "const", "MachineOperand", "*", "Src1", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "const", "MachineOperand", "*", "Src2", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "return", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "IsF16", "?", "AMDGPU", "::", "V_MAD_F16", ":", "AMDGPU", "::", "V_MAD_F32", ")", ")", ".", "addOperand", "(", "*", "Dst", ")", ".", "addImm", "(", "0", ")", ".", "addOperand", "(", "*", "Src0", ")", ".", "addImm", "(", "0", ")", ".", "addOperand", "(", "*", "Src1", ")", ".", "addImm", "(", "0", ")", ".", "addOperand", "(", "*", "Src2", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "convertToThreeAddress", "-", "This", "method", "must", "be", "implemented", "by", "targets", "that", "set", "the", "M_CONVERTIBLE_TO_3_ADDR", "flag", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MAC_F16_e64", "AMDGPU::V_MAC_F32_e64", "AMDGPU::V_MAC_F16_e32", "AMDGPU::V_MAC_F32_e32", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::V_MAD_F16", "AMDGPU::V_MAD_F32", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "MCSubtargetInfo", "*", "createMCSubtargetInfo", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "return", "createWebAssemblyMCSubtargetInfoImpl", "(", "TT", ",", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "createMCSubtargetInfo", "-", "Create", "a", "MCSubtargetInfo", "implementation", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "override_options", "(", "void", ")", "{", "if", "(", "TARGET_SEP_DATA", "&&", "TARGET_ID_SHARED_LIBRARY", ")", "error", "(", "\"cannot specify both -msep-data and -mid-shared-library\"", ")", ";", "if", "(", "TARGET_SEP_DATA", "||", "TARGET_ID_SHARED_LIBRARY", ")", "flag_pic", "=", "2", ";", "if", "(", "!", "TARGET_68020", "&&", "!", "TARGET_COLDFIRE", "&&", "(", "flag_pic", "==", "2", ")", ")", "error", "(", "\"-fPIC is not currently supported on the 68000 or 68010\"", ")", ";", "if", "(", "TARGET_PCREL", "&&", "flag_pic", "==", "0", ")", "flag_pic", "=", "1", ";", "if", "(", "flag_pic", ")", "flag_no_function_cse", "=", "1", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "}", "</s>" ]

[ "Set", "global", "variables", "as", "needed", "for", "the", "options", "enabled", "." ]

[ "m68k", "\"cannot specify both -msep-data and -mid-shared-library\"", "2", "2", "\"-fPIC is not currently supported on the 68000 or 68010\"", "0", "1", "1" ]

[]

[ "<s>", "bool", "LoongArchAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "Count", "%", "4", "!=", "0", ")", "return", "false", ";", "for", "(", ";", "Count", ">=", "4", ";", "Count", "-=", "4", ")", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "0x03400000", ",", "support", "::", "little", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "4", "0", "4", "4", "support::endian", "0x03400000", "support::little" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "convertToThreeAddress", "(", "MachineFunction", "::", "iterator", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "LiveVariables", "*", "LV", ")", "const", "{", "bool", "IsF16", "=", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "nullptr", ";", "case", "AMDGPU", "::", "V_MAC_F16_e64", ":", "IsF16", "=", "true", ";", "case", "AMDGPU", "::", "V_MAC_F32_e64", ":", "break", ";", "case", "AMDGPU", "::", "V_MAC_F16_e32", ":", "IsF16", "=", "true", ";", "case", "AMDGPU", "::", "V_MAC_F32_e32", ":", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "const", "MachineOperand", "*", "Src0", "=", "&", "MI", ".", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "Src0", "->", "isImm", "(", ")", "&&", "!", "isInlineConstant", "(", "MI", ",", "Src0Idx", ",", "*", "Src0", ")", ")", "return", "nullptr", ";", "break", ";", "}", "}", "const", "MachineOperand", "*", "Dst", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "const", "MachineOperand", "*", "Src0", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "const", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ";", "const", "MachineOperand", "*", "Src1", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "const", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "const", "MachineOperand", "*", "Src2", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "const", "MachineOperand", "*", "Clamp", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "clamp", ")", ";", "const", "MachineOperand", "*", "Omod", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "omod", ")", ";", "return", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "IsF16", "?", "AMDGPU", "::", "V_MAD_F16", ":", "AMDGPU", "::", "V_MAD_F32", ")", ")", ".", "add", "(", "*", "Dst", ")", ".", "addImm", "(", "Src0Mods", "?", "Src0Mods", "->", "getImm", "(", ")", ":", "0", ")", ".", "add", "(", "*", "Src0", ")", ".", "addImm", "(", "Src1Mods", "?", "Src1Mods", "->", "getImm", "(", ")", ":", "0", ")", ".", "add", "(", "*", "Src1", ")", ".", "addImm", "(", "0", ")", ".", "add", "(", "*", "Src2", ")", ".", "addImm", "(", "Clamp", "?", "Clamp", "->", "getImm", "(", ")", ":", "0", ")", ".", "addImm", "(", "Omod", "?", "Omod", "->", "getImm", "(", ")", ":", "0", ")", ";", "}", "</s>" ]

[ "convertToThreeAddress", "-", "This", "method", "must", "be", "implemented", "by", "targets", "that", "set", "the", "M_CONVERTIBLE_TO_3_ADDR", "flag", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MAC_F16_e64", "AMDGPU::V_MAC_F32_e64", "AMDGPU::V_MAC_F16_e32", "AMDGPU::V_MAC_F32_e32", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::V_MAD_F16", "AMDGPU::V_MAD_F32", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "aarch64_expand_epilogue", "(", "bool", "for_sibcall", ")", "{", "aarch64_layout_frame", "(", ")", ";", "HOST_WIDE_INT", "initial_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "initial_adjust", ";", "HOST_WIDE_INT", "callee_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "callee_adjust", ";", "HOST_WIDE_INT", "final_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "final_adjust", ";", "HOST_WIDE_INT", "callee_offset", "=", "cfun", "->", "machine", "->", "frame", ".", "callee_offset", ";", "unsigned", "reg1", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", ";", "unsigned", "reg2", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ";", "rtx", "cfi_ops", "=", "NULL", ";", "rtx_insn", "*", "insn", ";", "bool", "need_barrier_p", "=", "(", "get_frame_size", "(", ")", "+", "cfun", "->", "machine", "->", "frame", ".", "saved_varargs_size", ")", "!=", "0", ";", "if", "(", "final_adjust", ">", "crtl", "->", "outgoing_args_size", "||", "cfun", "->", "calls_alloca", "||", "crtl", "->", "calls_eh_return", ")", "{", "emit_insn", "(", "gen_stack_tie", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "need_barrier_p", "=", "false", ";", "}", "if", "(", "frame_pointer_needed", "&&", "(", "final_adjust", "||", "cfun", "->", "calls_alloca", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "GEN_INT", "(", "-", "callee_offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "callee_adjust", "==", "0", ";", "}", "else", "aarch64_add_sp", "(", "IP1_REGNUM", ",", "final_adjust", ",", "df_regs_ever_live_p", "(", "IP1_REGNUM", ")", ")", ";", "aarch64_restore_callee_saves", "(", "DImode", ",", "callee_offset", ",", "R0_REGNUM", ",", "R30_REGNUM", ",", "callee_adjust", "!=", "0", ",", "&", "cfi_ops", ")", ";", "aarch64_restore_callee_saves", "(", "DFmode", ",", "callee_offset", ",", "V0_REGNUM", ",", "V31_REGNUM", ",", "callee_adjust", "!=", "0", ",", "&", "cfi_ops", ")", ";", "if", "(", "need_barrier_p", ")", "emit_insn", "(", "gen_stack_tie", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "callee_adjust", "!=", "0", ")", "aarch64_pop_regs", "(", "reg1", ",", "reg2", ",", "callee_adjust", ",", "&", "cfi_ops", ")", ";", "if", "(", "callee_adjust", "!=", "0", "||", "initial_adjust", ">", "65536", ")", "{", "insn", "=", "get_last_insn", "(", ")", ";", "rtx", "new_cfa", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "initial_adjust", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "new_cfa", ",", "cfi_ops", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "cfi_ops", "=", "NULL", ";", "}", "aarch64_add_sp", "(", "IP0_REGNUM", ",", "initial_adjust", ",", "df_regs_ever_live_p", "(", "IP0_REGNUM", ")", ")", ";", "if", "(", "cfi_ops", ")", "{", "insn", "=", "get_last_insn", "(", ")", ";", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "stack_pointer_rtx", ",", "cfi_ops", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "cfi_ops", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "aarch64_return_address_signing_enabled", "(", ")", "&&", "(", "for_sibcall", "||", "!", "TARGET_ARMV8_3", "||", "crtl", "->", "calls_eh_return", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_autisp", "(", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_TOGGLE_RA_MANGLE", ",", "const0_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "}", "emit_use", "(", "gen_rtx_REG", "(", "DImode", ",", "LR_REGNUM", ")", ")", ";", "if", "(", "!", "for_sibcall", ")", "emit_jump_insn", "(", "ret_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "epilogue", "instructions", "for", "returning", "from", "a", "function", "." ]

[ "aarch64", "0", "0", "0", "0", "0", "0", "65536", "1", "1", "1" ]

[]

[ "<s>", "void", "BPFTargetMachine", "::", "registerPassBuilderCallbacks", "(", "PassBuilder", "&", "PB", ")", "{", "PB", ".", "registerPipelineStartEPCallback", "(", "[", "=", "]", "(", "ModulePassManager", "&", "MPM", ",", "OptimizationLevel", ")", "{", "FunctionPassManager", "FPM", ";", "FPM", ".", "addPass", "(", "BPFAbstractMemberAccessPass", "(", "this", ")", ")", ";", "FPM", ".", "addPass", "(", "BPFPreserveDITypePass", "(", ")", ")", ";", "MPM", ".", "addPass", "(", "createModuleToFunctionPassAdaptor", "(", "std", "::", "move", "(", "FPM", ")", ")", ")", ";", "}", ")", ";", "PB", ".", "registerPeepholeEPCallback", "(", "[", "=", "]", "(", "FunctionPassManager", "&", "FPM", ",", "OptimizationLevel", "Level", ")", "{", "FPM", ".", "addPass", "(", "SimplifyCFGPass", "(", "SimplifyCFGOptions", "(", ")", ".", "hoistCommonInsts", "(", "true", ")", ")", ")", ";", "}", ")", ";", "PB", ".", "registerPipelineEarlySimplificationEPCallback", "(", "[", "=", "]", "(", "ModulePassManager", "&", "MPM", ",", "OptimizationLevel", ")", "{", "MPM", ".", "addPass", "(", "BPFAdjustOptPass", "(", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Invoke", "the", "PassBuilder", "callback", "registration", "." ]

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

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "findOptimalMemOpLowering", "(", "std", "::", "vector", "<", "EVT", ">", "&", "MemOps", ",", "unsigned", "Limit", ",", "const", "MemOp", "&", "Op", ",", "unsigned", "DstAS", ",", "unsigned", "SrcAS", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "const", "int", "MVCFastLen", "=", "16", ";", "if", "(", "Op", ".", "isMemcpy", "(", ")", "&&", "Op", ".", "allowOverlap", "(", ")", "&&", "Op", ".", "size", "(", ")", "<=", "MVCFastLen", ")", "return", "false", ";", "if", "(", "Op", ".", "isMemset", "(", ")", "&&", "Op", ".", "size", "(", ")", "-", "1", "<=", "MVCFastLen", ")", "return", "false", ";", "if", "(", "Op", ".", "isZeroMemset", "(", ")", ")", "return", "false", ";", "return", "TargetLowering", "::", "findOptimalMemOpLowering", "(", "MemOps", ",", "Limit", ",", "Op", ",", "DstAS", ",", "SrcAS", ",", "FuncAttributes", ")", ";", "}", "</s>" ]

[ "Determines", "the", "optimal", "series", "of", "memory", "ops", "to", "replace", "the", "memset", "/", "memcpy", "." ]

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

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToUnpredicate", "(", "MachineBasicBlock", "&", "TMBB", ",", "MachineBasicBlock", "&", "FMBB", ")", "const", "{", "return", "Subtarget", ".", "isSwift", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "to", "unpredicate", "one", "side", "of", "a", "'diamond", "'", ",", "i.e", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Hardware Loops\"", ";", "}", "</s>" ]

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

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

[]

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

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

[ "LoongArch", "LoongArch", "\"Unhandled expression!\"" ]

[]

[ "<s>", "void", "expand_fusion_p9_store", "(", "rtx", "*", "operands", ")", "{", "rtx", "tmp_reg", "=", "operands", "[", "0", "]", ";", "rtx", "addis_value", "=", "operands", "[", "1", "]", ";", "rtx", "orig_mem", "=", "operands", "[", "2", "]", ";", "rtx", "src", "=", "operands", "[", "3", "]", ";", "rtx", "new_addr", ",", "new_mem", ",", "orig_addr", ",", "offset", ",", "set", ",", "clobber", ",", "insn", ",", "new_src", ";", "enum", "rtx_code", "plus_or_lo_sum", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "orig_mem", ")", ";", "machine_mode", "ptr_mode", "=", "Pmode", ";", "gcc_assert", "(", "MEM_P", "(", "orig_mem", ")", ")", ";", "orig_addr", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "plus_or_lo_sum", "=", "GET_CODE", "(", "orig_addr", ")", ";", "gcc_assert", "(", "plus_or_lo_sum", "==", "PLUS", "||", "plus_or_lo_sum", "==", "LO_SUM", ")", ";", "offset", "=", "XEXP", "(", "orig_addr", ",", "1", ")", ";", "new_addr", "=", "gen_rtx_fmt_ee", "(", "plus_or_lo_sum", ",", "ptr_mode", ",", "addis_value", ",", "offset", ")", ";", "new_mem", "=", "replace_equiv_address_nv", "(", "orig_mem", ",", "new_addr", ",", "false", ")", ";", "new_src", "=", "gen_rtx_UNSPEC", "(", "target_mode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "UNSPEC_FUSION_P9", ")", ";", "set", "=", "gen_rtx_SET", "(", "new_mem", ",", "new_src", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "tmp_reg", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", ";", "}", "</s>" ]

[ "During", "the", "peephole2", "pass", ",", "adjust", "and", "expand", "the", "insns", "for", "an", "extended", "fusion", "store", "sequence", ".", "The", "operands", "are", ":", "operands", "[", "0", "]", "register", "set", "with", "addis", "operands", "[", "1", "]", "value", "set", "via", "addis", "operands", "[", "2", "]", "target", "D-form", "memory", "being", "stored", "to", "operands", "[", "3", "]", "register", "being", "stored", "This", "is", "similar", "to", "the", "fusion", "introduced", "with", "power8", ",", "except", "it", "scales", "to", "both", "loads/stores", "and", "does", "not", "require", "the", "result", "register", "to", "be", "the", "same", "as", "the", "base", "register", ".", "At", "the", "moment", ",", "we", "only", "do", "this", "if", "register", "set", "with", "addis", "is", "dead", "." ]

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

[]

[ "<s>", "const", "char", "*", "output_movb", "(", "rtx", "*", "operands", ",", "rtx", "insn", ",", "int", "which_alternative", ",", "int", "reverse_comparison", ")", "{", "if", "(", "next_real_insn", "(", "JUMP_LABEL", "(", "insn", ")", ")", "==", "next_real_insn", "(", "insn", ")", ")", "{", "if", "(", "which_alternative", "==", "0", ")", "return", "\"copy %1,%0\"", ";", "else", "if", "(", "which_alternative", "==", "1", ")", "{", "output_asm_insn", "(", "\"stw %1,-16(%%r30)\"", ",", "operands", ")", ";", "return", "\"{fldws|fldw} -16(%%r30),%0\"", ";", "}", "else", "if", "(", "which_alternative", "==", "2", ")", "return", "\"stw %1,%0\"", ";", "else", "return", "\"mtsar %r1\"", ";", "}", "if", "(", "reverse_comparison", ")", "PUT_CODE", "(", "operands", "[", "2", "]", ",", "reverse_condition", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", ")", ")", ";", "if", "(", "which_alternative", "==", "0", ")", "{", "int", "nullify", "=", "INSN_ANNULLED_BRANCH_P", "(", "insn", ")", ";", "int", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", "==", "8", "&&", "dbr_sequence_length", "(", ")", "==", "0", ")", "nullify", "=", "1", ";", "if", "(", "!", "nullify", "&&", "length", "==", "4", "&&", "dbr_sequence_length", "(", ")", "==", "0", ")", "nullify", "=", "forward_branch_p", "(", "insn", ")", ";", "switch", "(", "length", ")", "{", "case", "4", ":", "if", "(", "nullify", ")", "return", "\"movb,%C2,n %1,%0,%3\"", ";", "else", "return", "\"movb,%C2 %1,%0,%3\"", ";", "case", "8", ":", "if", "(", "dbr_sequence_length", "(", ")", "!=", "0", "&&", "!", "forward_branch_p", "(", "insn", ")", "&&", "nullify", ")", "return", "\"movb,%N2,n %1,%0,.+12\\n\\tb %3\"", ";", "else", "if", "(", "dbr_sequence_length", "(", ")", "==", "0", "&&", "!", "forward_branch_p", "(", "insn", ")", "&&", "INSN_ADDRESSES_SET_P", "(", ")", "&&", "VAL_14_BITS_P", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "JUMP_LABEL", "(", "insn", ")", ")", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "-", "8", ")", ")", "return", "\"movb,%C2 %1,%0,%3%#\"", ";", "if", "(", "nullify", ")", "return", "\"or,%N2 %1,%%r0,%0\\n\\tb,n %3\"", ";", "else", "return", "\"or,%N2 %1,%%r0,%0\\n\\tb %3\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "which_alternative", "==", "1", ")", "{", "output_asm_insn", "(", "\"stw %1,-16(%%r30)\"", ",", "operands", ")", ";", "if", "(", "get_attr_length", "(", "insn", ")", "==", "12", ")", "return", "\"{comb|cmpb},%S2 %%r0,%1,%3\\n\\t{fldws|fldw} -16(%%r30),%0\"", ";", "else", "return", "\"{comclr|cmpclr},%B2 %%r0,%1,%%r0\\n\\tb %3\\n\\t{fldws|fldw} -16(%%r30),%0\"", ";", "}", "else", "if", "(", "which_alternative", "==", "2", ")", "{", "if", "(", "get_attr_length", "(", "insn", ")", "==", "8", ")", "return", "\"{comb|cmpb},%S2 %%r0,%1,%3\\n\\tstw %1,%0\"", ";", "else", "return", "\"{comclr|cmpclr},%B2 %%r0,%1,%%r0\\n\\tb %3\\n\\tstw %1,%0\"", ";", "}", "else", "{", "if", "(", "get_attr_length", "(", "insn", ")", "==", "8", ")", "return", "\"{comb|cmpb},%S2 %%r0,%1,%3\\n\\tmtsar %r1\"", ";", "else", "return", "\"{comclr|cmpclr},%B2 %%r0,%1,%%r0\\n\\tb %3\\n\\tmtsar %r1\"", ";", "}", "}", "</s>" ]

[ "Return", "the", "output", "template", "for", "emitting", "a", "dbra", "type", "insn", ".", "Note", "it", "may", "perform", "some", "output", "operations", "on", "its", "own", "before", "returning", "the", "final", "output", "string", "." ]

[ "pa", "0", "\"copy %1,%0\"", "1", "\"stw %1,-16(%%r30)\"", "\"{fldws|fldw} -16(%%r30),%0\"", "2", "\"stw %1,%0\"", "\"mtsar %r1\"", "2", "2", "0", "8", "0", "1", "4", "0", "4", "\"movb,%C2,n %1,%0,%3\"", "\"movb,%C2 %1,%0,%3\"", "8", "0", "\"movb,%N2,n %1,%0,.+12\\n\\tb %3\"", "0", "8", "\"movb,%C2 %1,%0,%3%#\"", "\"or,%N2 %1,%%r0,%0\\n\\tb,n %3\"", "\"or,%N2 %1,%%r0,%0\\n\\tb %3\"", "1", "\"stw %1,-16(%%r30)\"", "12", "\"{comb|cmpb},%S2 %%r0,%1,%3\\n\\t{fldws|fldw} -16(%%r30),%0\"", "\"{comclr|cmpclr},%B2 %%r0,%1,%%r0\\n\\tb %3\\n\\t{fldws|fldw} -16(%%r30),%0\"", "2", "8", "\"{comb|cmpb},%S2 %%r0,%1,%3\\n\\tstw %1,%0\"", "\"{comclr|cmpclr},%B2 %%r0,%1,%%r0\\n\\tb %3\\n\\tstw %1,%0\"", "8", "\"{comb|cmpb},%S2 %%r0,%1,%3\\n\\tmtsar %r1\"", "\"{comclr|cmpclr},%B2 %%r0,%1,%%r0\\n\\tb %3\\n\\tmtsar %r1\"" ]

[]