Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "aarch64_init_builtin_rsqrt", "(", "void", ")", "{", "tree", "fndecl", "=", "NULL", ";", "tree", "ftype", "=", "NULL", ";", "tree", "V2SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "2", ")", ";", "tree", "V2DF_type_node", "=", "build_vector_type", "(", "double_type_node", ",", "2", ")", ";", "tree", "V4SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "4", ")", ";", "struct", "builtin_decls_data", "{", "tree", "type_node", ";", "const", "char", "*", "builtin_name", ";", "int", "function_code", ";", "}", ";", "builtin_decls_data", "bdda", "[", "]", "=", "{", "{", "double_type_node", ",", "\"__builtin_aarch64_rsqrt_df\"", ",", "AARCH64_BUILTIN_RSQRT_DF", "}", ",", "{", "float_type_node", ",", "\"__builtin_aarch64_rsqrt_sf\"", ",", "AARCH64_BUILTIN_RSQRT_SF", "}", ",", "{", "V2DF_type_node", ",", "\"__builtin_aarch64_rsqrt_v2df\"", ",", "AARCH64_BUILTIN_RSQRT_V2DF", "}", ",", "{", "V2SF_type_node", ",", "\"__builtin_aarch64_rsqrt_v2sf\"", ",", "AARCH64_BUILTIN_RSQRT_V2SF", "}", ",", "{", "V4SF_type_node", ",", "\"__builtin_aarch64_rsqrt_v4sf\"", ",", "AARCH64_BUILTIN_RSQRT_V4SF", "}", "}", ";", "builtin_decls_data", "*", "bdd", "=", "bdda", ";", "builtin_decls_data", "*", "bdd_end", "=", "bdd", "+", "(", "sizeof", "(", "bdda", ")", "/", "sizeof", "(", "builtin_decls_data", ")", ")", ";", "for", "(", ";", "bdd", "<", "bdd_end", ";", "bdd", "++", ")", "{", "ftype", "=", "build_function_type_list", "(", "bdd", "->", "type_node", ",", "bdd", "->", "type_node", ",", "NULL_TREE", ")", ";", "tree", "attrs", "=", "aarch64_get_attributes", "(", "FLAG_FP", ",", "TYPE_MODE", "(", "bdd", "->", "type_node", ")", ")", ";", "fndecl", "=", "aarch64_general_add_builtin", "(", "bdd", "->", "builtin_name", ",", "ftype", ",", "bdd", "->", "function_code", ",", "attrs", ")", ";", "aarch64_builtin_decls", "[", "bdd", "->", "function_code", "]", "=", "fndecl", ";", "}", "}", "</s>" ]

[ "Add", "builtins", "for", "reciprocal", "square", "root", "." ]

[ "aarch64", "2", "2", "4", "\"__builtin_aarch64_rsqrt_df\"", "\"__builtin_aarch64_rsqrt_sf\"", "\"__builtin_aarch64_rsqrt_v2df\"", "\"__builtin_aarch64_rsqrt_v2sf\"", "\"__builtin_aarch64_rsqrt_v4sf\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "for", "(", "const", "APFloat", "&", "FPImm", ":", "LegalFPImmediates", ")", "if", "(", "Imm", ".", "bitwiseIsEqual", "(", "FPImm", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "ARMInstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "MachineInstr", "*", "PopMI", "=", "MF", ".", "CreateMachineInstr", "(", "get", "(", "ARM", "::", "tPOP", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "PopMI", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "PopMI", "->", "setDesc", "(", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "PopMI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "Reg", ",", "true", ")", ")", ";", "}", "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", "(", ")", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastLowerCall", "(", "CallLoweringInfo", "&", "CLI", ")", "{", "CallingConv", "::", "ID", "CC", "=", "CLI", ".", "CallConv", ";", "bool", "IsTailCall", "=", "CLI", ".", "IsTailCall", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "const", "Value", "*", "Callee", "=", "CLI", ".", "Callee", ";", "if", "(", "IsTailCall", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "MVT", "RetVT", ";", "if", "(", "CLI", ".", "RetTy", "->", "isVoidTy", "(", ")", ")", "RetVT", "=", "MVT", "::", "isVoid", ";", "else", "if", "(", "!", "isTypeLegal", "(", "CLI", ".", "RetTy", ",", "RetVT", ")", ")", "return", "false", ";", "for", "(", "auto", "Flag", ":", "CLI", ".", "OutFlags", ")", "if", "(", "Flag", ".", "isInReg", "(", ")", "||", "Flag", ".", "isSRet", "(", ")", "||", "Flag", ".", "isNest", "(", ")", "||", "Flag", ".", "isByVal", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "MVT", ",", "16", ">", "OutVTs", ";", "OutVTs", ".", "reserve", "(", "CLI", ".", "OutVals", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "*", "Val", ":", "CLI", ".", "OutVals", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "Val", "->", "getType", "(", ")", ",", "VT", ")", "&&", "!", "(", "VT", "==", "MVT", "::", "i1", "||", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", ">", "64", ")", "return", "false", ";", "OutVTs", ".", "push_back", "(", "VT", ")", ";", "}", "Address", "Addr", ";", "if", "(", "!", "computeCallAddress", "(", "Callee", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "CLI", ",", "OutVTs", ",", "NumBytes", ")", ")", "return", "false", ";", "unsigned", "DestAddress", "=", "materializeGV", "(", "Addr", ".", "getGlobalValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "emitInst", "(", "TargetOpcode", "::", "COPY", ",", "Mips", "::", "T9", ")", ".", "addReg", "(", "DestAddress", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "JALR", ")", ",", "Mips", "::", "RA", ")", ".", "addReg", "(", "Mips", "::", "T9", ")", ";", "for", "(", "auto", "Reg", ":", "CLI", ".", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "*", "FuncInfo", ".", "MF", ",", "CC", ")", ")", ";", "CLI", ".", "Call", "=", "MIB", ";", "return", "finishCall", "(", "CLI", ",", "RetVT", ",", "NumBytes", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "call", "lowering", "." ]

[ "Mips", "Mips", "MVT::isVoid", "16", "MVT::i1", "MVT::i8", "MVT::i16", "64", "MVT::i32", "Mips::T9", "Mips::JALR", "Mips::RA", "Mips::T9" ]

[]

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

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

[ "Nyuzi" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", ".", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "FP", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "FP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "MSP430", "::", "FP", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\"Shrink-wrapping not yet supported\"", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::FP", "MSP430::MOV16rr", "MSP430::FP", "MSP430::SP", "MSP430::FP", "MSP430", "MSP430::PUSH16r", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "static", "Align", "getPrefTypeAlign", "(", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "{", "return", "DAG", ".", "getDataLayout", "(", ")", ".", "getPrefTypeAlign", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "preferred", "stack/global", "alignment", "for", "the", "specified", "type", "." ]

[ "RISCV" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectWrite", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ",", "unsigned", "AddrChan", ")", "const", "{", "unsigned", "AddrReg", ";", "switch", "(", "AddrChan", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid Channel\"", ")", ";", "case", "0", ":", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "1", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_YRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "2", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_ZRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "3", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_WRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "}", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "*", "MOVA", ",", "AMDGPU", "::", "OpName", "::", "write", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "AddrReg", ",", "ValueReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "*", "Mov", ",", "AMDGPU", "::", "OpName", "::", "dst_rel", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "write", "." ]

[ "AMDGPU", "R600", "\"Invalid Channel\"", "0", "AMDGPU::R600_AddrRegClass", "1", "AMDGPU::R600_Addr_YRegClass", "2", "AMDGPU::R600_Addr_ZRegClass", "3", "AMDGPU::R600_Addr_WRegClass", "AMDGPU::MOVA_INT_eg", "AMDGPU::AR_X", "AMDGPU::OpName", "0", "AMDGPU::MOV", "AMDGPU::AR_X", "AMDGPU::OpName", "1" ]

[]

[ "<s>", "static", "void", "ix86_add_reg_usage_to_vzeroupper", "(", "rtx_insn", "*", "insn", ",", "bitmap", "live_regs", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "unsigned", "int", "nregs", "=", "TARGET_64BIT", "?", "16", ":", "8", ";", "unsigned", "int", "npats", "=", "nregs", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "nregs", ";", "++", "i", ")", "{", "unsigned", "int", "regno", "=", "GET_SSE_REGNO", "(", "i", ")", ";", "if", "(", "!", "bitmap_bit_p", "(", "live_regs", ",", "regno", ")", ")", "npats", "--", ";", "}", "if", "(", "npats", "==", "0", ")", "return", ";", "rtvec", "vec", "=", "rtvec_alloc", "(", "npats", "+", "1", ")", ";", "RTVEC_ELT", "(", "vec", ",", "0", ")", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ",", "j", "=", "0", ";", "i", "<", "nregs", ";", "++", "i", ")", "{", "unsigned", "int", "regno", "=", "GET_SSE_REGNO", "(", "i", ")", ";", "if", "(", "!", "bitmap_bit_p", "(", "live_regs", ",", "regno", ")", ")", "continue", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "V2DImode", ",", "regno", ")", ";", "++", "j", ";", "RTVEC_ELT", "(", "vec", ",", "j", ")", "=", "gen_rtx_SET", "(", "reg", ",", "reg", ")", ";", "}", "XVEC", "(", "pattern", ",", "0", ")", "=", "vec", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "}", "</s>" ]

[ "Modify", "the", "vzeroupper", "pattern", "in", "INSN", "so", "that", "it", "describes", "the", "effect", "that", "the", "instruction", "has", "on", "the", "SSE", "registers", ".", "LIVE_REGS", "are", "the", "set", "of", "registers", "that", "are", "live", "across", "the", "instruction", ".", "For", "a", "live", "register", "R", "we", "use", ":", "(", "set", "(", "reg", ":", "V2DF", "R", ")", "(", "reg", ":", "V2DF", "R", ")", ")", "which", "preserves", "the", "low", "128", "bits", "but", "clobbers", "the", "upper", "bits", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_debug_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "ret", "=", "rs6000_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ",", "opno", ",", "total", ",", "speed", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_rtx_costs, return = %s, code = %s, outer_code = %s, \"", "\"opno = %d, total = %d, speed = %s, x:\\n\"", ",", "ret", "?", "\"complete\"", ":", "\"scan inner\"", ",", "GET_RTX_NAME", "(", "code", ")", ",", "GET_RTX_NAME", "(", "outer_code", ")", ",", "opno", ",", "*", "total", ",", "speed", "?", "\"true\"", ":", "\"false\"", ")", ";", "debug_rtx", "(", "x", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "form", "of", "r6000_rtx_costs", "that", "is", "selected", "if", "-mdebug=cost", "." ]

[ "rs6000", "\"\\nrs6000_rtx_costs, return = %s, code = %s, outer_code = %s, \"", "\"opno = %d, total = %d, speed = %s, x:\\n\"", "\"complete\"", "\"scan inner\"", "\"true\"", "\"false\"" ]

[]

[ "<s>", "static", "int", "ix86_initialize_bounds", "(", "tree", "var", ",", "tree", "lb", ",", "tree", "ub", ",", "tree", "*", "stmts", ")", "{", "tree", "bnd_ptr", "=", "build_pointer_type", "(", "pointer_sized_int_node", ")", ";", "tree", "lhs", ",", "modify", ",", "var_p", ";", "ub", "=", "build1", "(", "BIT_NOT_EXPR", ",", "pointer_sized_int_node", ",", "ub", ")", ";", "var_p", "=", "fold_convert", "(", "bnd_ptr", ",", "build_fold_addr_expr", "(", "var", ")", ")", ";", "lhs", "=", "build1", "(", "INDIRECT_REF", ",", "pointer_sized_int_node", ",", "var_p", ")", ";", "modify", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "lhs", ")", ",", "lhs", ",", "lb", ")", ";", "append_to_statement_list", "(", "modify", ",", "stmts", ")", ";", "lhs", "=", "build1", "(", "INDIRECT_REF", ",", "pointer_sized_int_node", ",", "build2", "(", "POINTER_PLUS_EXPR", ",", "bnd_ptr", ",", "var_p", ",", "TYPE_SIZE_UNIT", "(", "pointer_sized_int_node", ")", ")", ")", ";", "modify", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "lhs", ")", ",", "lhs", ",", "ub", ")", ";", "append_to_statement_list", "(", "modify", ",", "stmts", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Generate", "a", "list", "of", "statements", "STMTS", "to", "initialize", "pointer", "bounds", "variable", "VAR", "with", "bounds", "LB", "and", "UB", ".", "Return", "the", "number", "of", "generated", "statements", "." ]

[ "i386", "2" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "RISCVABI", "::", "isCheriPureCapABI", "(", "STI", ".", "getTargetABI", "(", ")", ")", ")", "{", "SavedRegs", ".", "set", "(", "RISCV", "::", "C1", ")", ";", "SavedRegs", ".", "set", "(", "RISCV", "::", "C8", ")", ";", "}", "else", "{", "SavedRegs", ".", "set", "(", "RISCV", "::", "X1", ")", ";", "SavedRegs", ".", "set", "(", "RISCV", "::", "X8", ")", ";", "}", "}", "if", "(", "hasBP", "(", "MF", ")", ")", "SavedRegs", ".", "set", "(", "RISCVABI", "::", "getBPReg", "(", "STI", ".", "getTargetABI", "(", ")", ")", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", "&&", "MFI", ".", "hasCalls", "(", ")", ")", "{", "static", "const", "MCPhysReg", "CSGPRs", "[", "]", "=", "{", "RISCV", "::", "X1", ",", "RISCV", "::", "X5", ",", "RISCV", "::", "X6", ",", "RISCV", "::", "X7", ",", "RISCV", "::", "X10", ",", "RISCV", "::", "X11", ",", "RISCV", "::", "X12", ",", "RISCV", "::", "X13", ",", "RISCV", "::", "X14", ",", "RISCV", "::", "X15", ",", "RISCV", "::", "X16", ",", "RISCV", "::", "X17", ",", "RISCV", "::", "X28", ",", "RISCV", "::", "X29", ",", "RISCV", "::", "X30", ",", "RISCV", "::", "X31", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CSGPCRs", "[", "]", "=", "{", "RISCV", "::", "C1", ",", "RISCV", "::", "C5", ",", "RISCV", "::", "C6", ",", "RISCV", "::", "C7", ",", "RISCV", "::", "C10", ",", "RISCV", "::", "C11", ",", "RISCV", "::", "C12", ",", "RISCV", "::", "C13", ",", "RISCV", "::", "C14", ",", "RISCV", "::", "C15", ",", "RISCV", "::", "C16", ",", "RISCV", "::", "C17", ",", "RISCV", "::", "C28", ",", "RISCV", "::", "C29", ",", "RISCV", "::", "C30", ",", "RISCV", "::", "C31", ",", "0", "}", ";", "ArrayRef", "<", "MCPhysReg", ">", "CSRegs", ";", "if", "(", "RISCVABI", "::", "isCheriPureCapABI", "(", "STI", ".", "getTargetABI", "(", ")", ")", ")", "CSRegs", "=", "CSGPCRs", ";", "else", "CSRegs", "=", "CSGPRs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "CSRegs", "[", "i", "]", ";", "++", "i", ")", "SavedRegs", ".", "set", "(", "CSRegs", "[", "i", "]", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "hasStdExtF", "(", ")", ")", "{", "const", "MCPhysReg", "*", "Regs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getCalleeSavedRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "Regs", "[", "i", "]", ";", "++", "i", ")", "if", "(", "RISCV", "::", "FPR16RegClass", ".", "contains", "(", "Regs", "[", "i", "]", ")", "||", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "Regs", "[", "i", "]", ")", "||", "RISCV", "::", "FPR64RegClass", ".", "contains", "(", "Regs", "[", "i", "]", ")", ")", "SavedRegs", ".", "set", "(", "Regs", "[", "i", "]", ")", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVABI::isCheriPureCapABI", "RISCV::C1", "RISCV::C8", "RISCV::X1", "RISCV::X8", "RISCVABI::getBPReg", "\"interrupt\"", "RISCV::X1", "RISCV::X5", "RISCV::X6", "RISCV::X7", "RISCV::X10", "RISCV::X11", "RISCV::X12", "RISCV::X13", "RISCV::X14", "RISCV::X15", "RISCV::X16", "RISCV::X17", "RISCV::X28", "RISCV::X29", "RISCV::X30", "RISCV::X31", "0", "RISCV::C1", "RISCV::C5", "RISCV::C6", "RISCV::C7", "RISCV::C10", "RISCV::C11", "RISCV::C12", "RISCV::C13", "RISCV::C14", "RISCV::C15", "RISCV::C16", "RISCV::C17", "RISCV::C28", "RISCV::C29", "RISCV::C30", "RISCV::C31", "0", "RISCVABI::isCheriPureCapABI", "0", "RISCV", "0", "RISCV::FPR16RegClass", "RISCV::FPR32RegClass", "RISCV::FPR64RegClass" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Condition Optimizer\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Condition Optimizer\"" ]

[]

[ "<s>", "void", "HexagonMCELFStreamer", "::", "emitInstruction", "(", "const", "MCInst", "&", "MCB", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "assert", "(", "MCB", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "BUNDLE", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<=", "HEXAGON_PACKET_SIZE", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", ">", "0", ")", ";", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "MCB", ")", ")", "{", "MCInst", "*", "MCI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "I", ".", "getInst", "(", ")", ")", ";", "EmitSymbol", "(", "*", "MCI", ")", ";", "}", "MCObjectStreamer", "::", "emitInstruction", "(", "MCB", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::BUNDLE", "Hexagon", "Hexagon", "0", "Hexagon" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createX86RetpolineThunksPass", "(", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "TM", "->", "getMCAsmInfo", "(", ")", ";", "if", "(", "!", "TT", ".", "isOSDarwin", "(", ")", "&&", "(", "!", "TT", ".", "isOSWindows", "(", ")", "||", "MAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "DwarfCFI", ")", ")", "addPass", "(", "createCFIInstrInserter", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

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

[]

[ "<s>", "void", "bfin_expand_prologue", "(", "void", ")", "{", "HOST_WIDE_INT", "frame_size", "=", "get_frame_size", "(", ")", ";", "rtx", "spreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "REG_SP", ")", ";", "e_funkind", "fkind", "=", "funkind", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "rtx", "pic_reg_loaded", "=", "NULL_RTX", ";", "tree", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "bool", "all", "=", "lookup_attribute", "(", "\"saveall\"", ",", "attrs", ")", "!=", "NULL_TREE", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "frame_size", ";", "if", "(", "fkind", "!=", "SUBROUTINE", ")", "{", "expand_interrupt_handler_prologue", "(", "spreg", ",", "fkind", ",", "all", ")", ";", "return", ";", "}", "if", "(", "crtl", "->", "limit_stack", "||", "(", "TARGET_STACK_CHECK_L1", "&&", "!", "DECL_NO_LIMIT_STACK", "(", "current_function_decl", ")", ")", ")", "{", "HOST_WIDE_INT", "offset", "=", "bfin_initial_elimination_offset", "(", "ARG_POINTER_REGNUM", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "lim", "=", "crtl", "->", "limit_stack", "?", "stack_limit_rtx", ":", "NULL_RTX", ";", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "REG_R3", ")", ";", "rtx", "p2reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "REG_P2", ")", ";", "emit_move_insn", "(", "tmp", ",", "p2reg", ")", ";", "if", "(", "!", "lim", ")", "{", "emit_move_insn", "(", "p2reg", ",", "gen_int_mode", "(", "0xFFB00000", ",", "SImode", ")", ")", ";", "emit_move_insn", "(", "p2reg", ",", "gen_rtx_MEM", "(", "Pmode", ",", "p2reg", ")", ")", ";", "lim", "=", "p2reg", ";", "}", "if", "(", "GET_CODE", "(", "lim", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "TARGET_ID_SHARED_LIBRARY", ")", "{", "rtx", "p1reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "REG_P1", ")", ";", "rtx", "val", ";", "pic_reg_loaded", "=", "bfin_load_pic_reg", "(", "p2reg", ")", ";", "val", "=", "legitimize_pic_address", "(", "stack_limit_rtx", ",", "p1reg", ",", "pic_reg_loaded", ")", ";", "emit_move_insn", "(", "p1reg", ",", "val", ")", ";", "frame_related_constant_load", "(", "p2reg", ",", "offset", ",", "FALSE", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "p2reg", ",", "p2reg", ",", "p1reg", ")", ")", ";", "lim", "=", "p2reg", ";", "}", "else", "{", "rtx", "limit", "=", "plus_constant", "(", "Pmode", ",", "lim", ",", "offset", ")", ";", "emit_move_insn", "(", "p2reg", ",", "limit", ")", ";", "lim", "=", "p2reg", ";", "}", "}", "else", "{", "if", "(", "lim", "!=", "p2reg", ")", "emit_move_insn", "(", "p2reg", ",", "lim", ")", ";", "add_to_reg", "(", "p2reg", ",", "offset", ",", "0", ",", "0", ")", ";", "lim", "=", "p2reg", ";", "}", "emit_insn", "(", "gen_compare_lt", "(", "bfin_cc_rtx", ",", "spreg", ",", "lim", ")", ")", ";", "emit_insn", "(", "gen_trapifcc", "(", ")", ")", ";", "emit_move_insn", "(", "p2reg", ",", "tmp", ")", ";", "}", "expand_prologue_reg_save", "(", "spreg", ",", "all", ",", "false", ")", ";", "do_link", "(", "spreg", ",", "frame_size", ",", "all", ")", ";", "if", "(", "TARGET_ID_SHARED_LIBRARY", "&&", "!", "TARGET_SEP_DATA", "&&", "(", "crtl", "->", "uses_pic_offset_table", "||", "!", "crtl", "->", "is_leaf", ")", ")", "bfin_load_pic_reg", "(", "pic_offset_table_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "RTL", "for", "the", "prologue", "of", "the", "current", "function", "." ]

[ "bfin", "\"saveall\"", "0xFFB00000", "0", "0" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "nvptx_hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "!=", "NVPTX_RETURN_REGNUM", "||", "cfun", "==", "NULL", "||", "cfun", "->", "machine", "->", "ret_reg_mode", "==", "VOIDmode", ")", "return", "true", ";", "return", "mode", "==", "cfun", "->", "machine", "->", "ret_reg_mode", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_MODE_OK", ".", "We", "barely", "use", "hard", "regs", ",", "but", "we", "want", "to", "ensure", "that", "the", "return", "register", "'s", "mode", "is", "n't", "changed", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "rtx", "ft32_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fntype_or_decl", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "valtype", ")", ",", "FT32_R0", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "We", "always", "return", "values", "in", "register", "$", "r0", "for", "ft32", "." ]

[ "ft32" ]

[]

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

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

[ "XCore", "\"XCore DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createRISCVExpandPseudoPass", "(", ")", ")", ";", "addPass", "(", "createRISCVExpandAtomicPseudoPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

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

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "IsBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "return", "Dis", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address", ",", "IsBranch", ",", "Offset", ",", "Width", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "Lanai" ]

[]

[ "<s>", "bool", "ix86_pre_reload_split", "(", "void", ")", "{", "return", "(", "can_create_pseudo_p", "(", ")", "&&", "!", "(", "cfun", "->", "curr_properties", "&", "PROP_rtl_split_insns", ")", ")", ";", "}", "</s>" ]

[ "Predicate", "for", "pre-reload", "splitters", "with", "associated", "instructions", ",", "which", "can", "match", "any", "time", "before", "the", "split1", "pass", "(", "usually", "combine", ")", ",", "then", "are", "unconditionally", "split", "in", "that", "pass", "and", "should", "not", "be", "matched", "again", "afterwards", "." ]

[ "i386" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU IR optimizations\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU IR optimizations\"" ]

[]

[ "<s>", "static", "rtx", "mt_check_delay_slot", "(", "rtx", "branch", ",", "rtx", "insn", ")", "{", "rtx", "slot", ";", "rtx", "tmp", ";", "rtx", "p", ";", "rtx", "jmp", ";", "gcc_assert", "(", "GET_CODE", "(", "PATTERN", "(", "branch", ")", ")", "==", "SEQUENCE", ")", ";", "if", "(", "INSN_DELETED_P", "(", "branch", ")", ")", "return", "NULL_RTX", ";", "slot", "=", "XVECEXP", "(", "PATTERN", "(", "branch", ")", ",", "0", ",", "1", ")", ";", "tmp", "=", "PATTERN", "(", "insn", ")", ";", "note_stores", "(", "PATTERN", "(", "slot", ")", ",", "insn_dependent_p_1", ",", "&", "tmp", ")", ";", "if", "(", "tmp", ")", "return", "NULL_RTX", ";", "jmp", "=", "XVECEXP", "(", "PATTERN", "(", "branch", ")", ",", "0", ",", "0", ")", ";", "tmp", "=", "PATTERN", "(", "jmp", ")", ";", "note_stores", "(", "PATTERN", "(", "slot", ")", ",", "insn_dependent_p_1", ",", "&", "tmp", ")", ";", "if", "(", "!", "tmp", ")", "return", "branch", ";", "p", "=", "PREV_INSN", "(", "branch", ")", ";", "NEXT_INSN", "(", "p", ")", "=", "slot", ";", "PREV_INSN", "(", "slot", ")", "=", "p", ";", "NEXT_INSN", "(", "slot", ")", "=", "jmp", ";", "PREV_INSN", "(", "jmp", ")", "=", "slot", ";", "NEXT_INSN", "(", "jmp", ")", "=", "branch", ";", "PREV_INSN", "(", "branch", ")", "=", "jmp", ";", "XVECEXP", "(", "PATTERN", "(", "branch", ")", ",", "0", ",", "0", ")", "=", "NULL_RTX", ";", "XVECEXP", "(", "PATTERN", "(", "branch", ")", ",", "0", ",", "1", ")", "=", "NULL_RTX", ";", "delete_insn", "(", "branch", ")", ";", "return", "jmp", ";", "}", "</s>" ]

[ "If", "BRANCH", "has", "a", "filled", "delay", "slot", ",", "check", "if", "INSN", "is", "dependent", "upon", "it", ".", "If", "so", ",", "undo", "the", "delay", "slot", "fill", ".", "Returns", "the", "next", "insn", ",", "if", "we", "patch", "out", "the", "branch", ".", "Returns", "the", "branch", "insn", ",", "if", "we", "can", "not", "patch", "out", "the", "branch", "(", "due", "to", "anti-dependency", "in", "the", "delay", "slot", ")", ".", "In", "that", "case", ",", "the", "caller", "must", "insert", "nops", "at", "the", "branch", "target", "." ]

[ "mt", "0", "1", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "CALL", ":", "return", "LowerCALL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FORMAL_ARGUMENTS", ":", "return", "LowerFORMAL_ARGUMENTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RET", ":", "return", "LowerRET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "ExpandADDSUB", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "assert", "(", "0", "&&", "\"unimplemented operand\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::CALL", "ISD::FORMAL_ARGUMENTS", "ISD::RET", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::ConstantPool", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::VAARG", "ISD::VASTART", "ISD::ADD", "ISD::SUB", "ISD::FRAMEADDR", "0", "\"unimplemented operand\"" ]

[]

[ "<s>", "unsigned", "AMDGPURegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "Dst", ",", "const", "RegisterBank", "&", "Src", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VGPRRegBankID", ")", "{", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "}", "if", "(", "Size", "==", "1", "&&", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SCCRegBankID", "||", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", ")", "&&", "(", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VGPRRegBankID", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SCCRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "return", "RegisterBankInfo", "::", "copyCost", "(", "Dst", ",", "Src", ",", "Size", ")", ";", "}", "</s>" ]

[ "Get", "the", "cost", "of", "a", "copy", "from", "B", "to", "A", ",", "or", "put", "differently", ",", "get", "the", "cost", "of", "A", "=", "COPY", "B", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::SGPRRegBankID", "AMDGPU::VGPRRegBankID", "1", "AMDGPU::SCCRegBankID", "AMDGPU::SGPRRegBankID", "AMDGPU::SGPRRegBankID", "AMDGPU::VGPRRegBankID", "AMDGPU::VCCRegBankID", "AMDGPU::SCCRegBankID", "AMDGPU::VCCRegBankID" ]

[]

[ "<s>", "CCAssignFn", "*", "AArch64TargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "case", "CallingConv", "::", "WebKit_JS", ":", "return", "CC_AArch64_WebKit_JS", ";", "case", "CallingConv", "::", "GHC", ":", "return", "CC_AArch64_GHC", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "PreserveMost", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "case", "CallingConv", "::", "Swift", ":", "if", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "IsVarArg", ")", "return", "CC_AArch64_Win64_VarArg", ";", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "CC_AArch64_AAPCS", ";", "if", "(", "!", "IsVarArg", ")", "return", "CC_AArch64_DarwinPCS", ";", "return", "Subtarget", "->", "isTargetILP32", "(", ")", "?", "CC_AArch64_DarwinPCS_ILP32_VarArg", ":", "CC_AArch64_DarwinPCS_VarArg", ";", "case", "CallingConv", "::", "Win64", ":", "return", "IsVarArg", "?", "CC_AArch64_Win64_VarArg", ":", "CC_AArch64_AAPCS", ";", "case", "CallingConv", "::", "CFGuard_Check", ":", "return", "CC_AArch64_Win64_CFGuard_Check", ";", "case", "CallingConv", "::", "AArch64_VectorCall", ":", "case", "CallingConv", "::", "AArch64_SVE_VectorCall", ":", "return", "CC_AArch64_AAPCS", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "AArch64", "AArch64", "\"Unsupported calling convention.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "rtx", "fixup_modeless_constant", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "x", "=", "convert_to_mode", "(", "mode", ",", "x", ",", "1", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Fixup", "modeless", "constants", "to", "fit", "required", "mode", "." ]

[ "i386", "1" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_sve_container_bits", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "poly_uint64", "vector_bits", "=", "(", "vec_flags", "&", "(", "VEC_PARTIAL", "|", "VEC_SVE_PRED", ")", "?", "BITS_PER_SVE_VECTOR", ":", "GET_MODE_BITSIZE", "(", "mode", ")", ")", ";", "return", "vector_element_size", "(", "vector_bits", ",", "GET_MODE_NUNITS", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "MODE", "is", "some", "form", "of", "SVE", "vector", "mode", ".", "For", "data", "modes", ",", "return", "the", "number", "of", "vector", "register", "bits", "that", "each", "element", "of", "MODE", "occupies", ",", "such", "as", "64", "for", "both", "VNx2DImode", "and", "VNx2SImode", "(", "where", "each", "32-bit", "value", "is", "stored", "in", "a", "64-bit", "container", ")", ".", "For", "predicate", "modes", ",", "return", "the", "number", "of", "data", "bits", "controlled", "by", "each", "significant", "predicate", "bit", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "mmix_local_regno", "(", "int", "regno", ")", "{", "return", "(", "regno", "<=", "MMIX_LAST_STACK_REGISTER_REGNUM", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ";", "}", "</s>" ]

[ "LOCAL_REGNO", ".", "All", "registers", "that", "are", "part", "of", "the", "register", "stack", "and", "that", "will", "be", "saved", "are", "local", "." ]

[ "mmix" ]

[]

[ "<s>", "bool", "AVRAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "assert", "(", "(", "Count", "%", "2", ")", "==", "0", "&&", "\"NOP instructions must be 2 bytes\"", ")", ";", "OS", ".", "write_zeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "2", "0", "\"NOP instructions must be 2 bytes\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "SDValue", "getNode", "(", "unsigned", "MachineOpc", ",", "const", "SDLoc", "&", "dl", ",", "MVT", "Ty", ",", "ArrayRef", "<", "SDValue", ">", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDNode", "*", "N", "=", "DAG", ".", "getMachineNode", "(", "MachineOpc", ",", "dl", ",", "Ty", ",", "Ops", ")", ";", "return", "SDValue", "(", "N", ",", "0", ")", ";", "}", "</s>" ]

[ "getNode", "{" ]

[ "Hexagon", "0" ]

[]

[ "<s>", "void", "AArch64TargetStreamer", "::", "finish", "(", ")", "{", "if", "(", "MarkBTIProperty", ")", "emitNoteSection", "(", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "RISCVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint32_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "(", "Bits", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "support::endian", "support::little" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "must_save_p", "(", "bool", "is_inthandler", ",", "unsigned", "regno", ")", "{", "if", "(", "D_REGNO_P", "(", "regno", ")", ")", "{", "bool", "is_eh_return_reg", "=", "false", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "j", ";", "for", "(", "j", "=", "0", ";", ";", "j", "++", ")", "{", "unsigned", "test", "=", "EH_RETURN_DATA_REGNO", "(", "j", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "regno", ")", "is_eh_return_reg", "=", "true", ";", "}", "}", "return", "(", "is_eh_return_reg", "||", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "(", "is_inthandler", "||", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", ")", ";", "}", "else", "if", "(", "P_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "(", "is_inthandler", "||", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", "||", "(", "is_inthandler", "&&", "(", "ENABLE_WA_05000283", "||", "ENABLE_WA_05000315", ")", "&&", "regno", "==", "REG_P5", ")", "||", "(", "!", "TARGET_FDPIC", "&&", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "(", "crtl", "->", "uses_pic_offset_table", "||", "(", "TARGET_ID_SHARED_LIBRARY", "&&", "!", "crtl", "->", "is_leaf", ")", ")", ")", ")", ";", "}", "else", "return", "(", "(", "is_inthandler", "||", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "&&", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "(", "!", "leaf_function_p", "(", ")", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "For", "a", "given", "REGNO", ",", "determine", "whether", "it", "must", "be", "saved", "in", "the", "function", "prologue", ".", "IS_INTHANDLER", "specifies", "whether", "we", "'re", "generating", "a", "normal", "prologue", "or", "an", "interrupt/exception", "one", "." ]

[ "bfin", "0" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createPartiallyInlineLibCallsPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "Size", ",", "unsigned", "Align", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFL", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "assert", "(", "Size", "&&", "\"Byval argument's size shouldn't be 0.\"", ")", ";", "Align", "=", "std", "::", "min", "(", "Align", ",", "TFL", "->", "getStackAlignment", "(", ")", ")", ";", "unsigned", "FirstReg", "=", "0", ";", "unsigned", "NumRegs", "=", "0", ";", "if", "(", "State", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "Fast", ")", "{", "unsigned", "RegSizeInBytes", "=", "Subtarget", ".", "getGPRSizeInBytes", "(", ")", ";", "ArrayRef", "<", "MCPhysReg", ">", "IntArgRegs", "=", "ABI", ".", "GetByValArgRegs", "(", ")", ";", "const", "MCPhysReg", "*", "ShadowRegs", "=", "ABI", ".", "IsO32", "(", ")", "?", "IntArgRegs", ".", "data", "(", ")", ":", "Mips64DPRegs", ";", "assert", "(", "!", "(", "Align", "%", "RegSizeInBytes", ")", "&&", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", ")", ";", "FirstReg", "=", "State", "->", "getFirstUnallocated", "(", "IntArgRegs", ")", ";", "if", "(", "(", "Align", ">", "RegSizeInBytes", ")", "&&", "(", "FirstReg", "%", "2", ")", ")", "{", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "FirstReg", "]", ",", "ShadowRegs", "[", "FirstReg", "]", ")", ";", "++", "FirstReg", ";", "}", "Size", "=", "alignTo", "(", "Size", ",", "RegSizeInBytes", ")", ";", "for", "(", "unsigned", "I", "=", "FirstReg", ";", "Size", ">", "0", "&&", "(", "I", "<", "IntArgRegs", ".", "size", "(", ")", ")", ";", "Size", "-=", "RegSizeInBytes", ",", "++", "I", ",", "++", "NumRegs", ")", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "I", "]", ",", "ShadowRegs", "[", "I", "]", ")", ";", "}", "State", "->", "addInRegsParamInfo", "(", "FirstReg", ",", "FirstReg", "+", "NumRegs", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "Mips", "Mips", "\"Byval argument's size shouldn't be 0.\"", "0", "0", "Mips", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", "2", "0" ]

[]

[ "<s>", "static", "bool", "s390_match_ccmode_set", "(", "rtx", "set", ",", "enum", "machine_mode", "req_mode", ")", "{", "enum", "machine_mode", "set_mode", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "REG", "||", "!", "CC_REGNO_P", "(", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", ")", ")", "return", "1", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "CCSmode", ":", "case", "CCSRmode", ":", "case", "CCUmode", ":", "case", "CCURmode", ":", "case", "CCLmode", ":", "case", "CCL1mode", ":", "case", "CCL2mode", ":", "case", "CCL3mode", ":", "case", "CCT1mode", ":", "case", "CCT2mode", ":", "case", "CCT3mode", ":", "if", "(", "req_mode", "!=", "set_mode", ")", "return", "0", ";", "break", ";", "case", "CCZmode", ":", "if", "(", "req_mode", "!=", "CCSmode", "&&", "req_mode", "!=", "CCUmode", "&&", "req_mode", "!=", "CCTmode", "&&", "req_mode", "!=", "CCSRmode", "&&", "req_mode", "!=", "CCURmode", ")", "return", "0", ";", "break", ";", "case", "CCAPmode", ":", "case", "CCANmode", ":", "if", "(", "req_mode", "!=", "CCAmode", ")", "return", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SET", "either", "does", "n't", "set", "the", "CC", "register", ",", "or", "else", "the", "source", "and", "destination", "have", "matching", "CC", "modes", "and", "that", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

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

[]

[ "<s>", "void", "LM32FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", ")", "const", "{", "}", "</s>" ]

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

[ "LM32", "LM32" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SystemZTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "case", "'a'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR32BitRegClass", ")", ";", "case", "'h'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GRH32BitRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP32BitRegClass", ")", ";", "}", "}", "if", "(", "Constraint", "[", "0", "]", "==", "'{'", ")", "{", "if", "(", "Constraint", "[", "1", "]", "==", "'r'", ")", "{", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR32BitRegClass", ",", "SystemZMC", "::", "GR32Regs", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR128BitRegClass", ",", "SystemZMC", "::", "GR128Regs", ")", ";", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR64BitRegClass", ",", "SystemZMC", "::", "GR64Regs", ")", ";", "}", "if", "(", "Constraint", "[", "1", "]", "==", "'f'", ")", "{", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP32BitRegClass", ",", "SystemZMC", "::", "FP32Regs", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP128BitRegClass", ",", "SystemZMC", "::", "FP128Regs", ")", ";", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "SystemZMC", "::", "FP64Regs", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1", "0", "MVT::i64", "0U", "SystemZ::GR64BitRegClass", "MVT::i128", "0U", "SystemZ::GR128BitRegClass", "0U", "SystemZ::GR32BitRegClass", "MVT::i64", "0U", "SystemZ::ADDR64BitRegClass", "MVT::i128", "0U", "SystemZ::ADDR128BitRegClass", "0U", "SystemZ::ADDR32BitRegClass", "0U", "SystemZ::GRH32BitRegClass", "MVT::f64", "0U", "SystemZ::FP64BitRegClass", "MVT::f128", "0U", "SystemZ::FP128BitRegClass", "0U", "SystemZ::FP32BitRegClass", "0", "1", "MVT::i32", "SystemZ::GR32BitRegClass", "SystemZMC::GR32Regs", "MVT::i128", "SystemZ::GR128BitRegClass", "SystemZMC::GR128Regs", "SystemZ::GR64BitRegClass", "SystemZMC::GR64Regs", "1", "MVT::f32", "SystemZ::FP32BitRegClass", "SystemZMC::FP32Regs", "MVT::f128", "SystemZ::FP128BitRegClass", "SystemZMC::FP128Regs", "SystemZ::FP64BitRegClass", "SystemZMC::FP64Regs" ]

[]

[ "<s>", "static", "void", "nvptx_init_builtins", "(", "void", ")", "{", "(", "nvptx_builtin_decls", "[", "NVPTX_BUILTIN_", "##", "ID", "]", "\\", "=", "add_builtin_function", "(", "\"__builtin_nvptx_\"", "NAME", ",", "\\", "build_function_type_list", "T", ",", "\\", "NVPTX_BUILTIN_", "##", "ID", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ")", "DEF", "(", "SHUFFLE", ",", "\"shuffle\"", ",", "(", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "SHUFFLELL", ",", "\"shufflell\"", ",", "(", "LLUINT", ",", "LLUINT", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "WORKER_ADDR", ",", "\"worker_addr\"", ",", "(", "PTRVOID", ",", "ST", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "VECTOR_ADDR", ",", "\"vector_addr\"", ",", "(", "PTRVOID", ",", "ST", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "CMP_SWAP", ",", "\"cmp_swap\"", ",", "(", "UINT", ",", "PTRVOID", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "CMP_SWAPLL", ",", "\"cmp_swapll\"", ",", "(", "LLUINT", ",", "PTRVOID", ",", "LLUINT", ",", "LLUINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "MEMBAR_GL", ",", "\"membar_gl\"", ",", "(", "VOID", ",", "VOID", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "MEMBAR_CTA", ",", "\"membar_cta\"", ",", "(", "VOID", ",", "VOID", ",", "NULL_TREE", ")", ")", ";", "}", "</s>" ]

[ "Set", "up", "all", "builtin", "functions", "for", "this", "target", "." ]

[ "nvptx", "\"__builtin_nvptx_\"", "\"shuffle\"", "\"shufflell\"", "\"worker_addr\"", "\"vector_addr\"", "\"cmp_swap\"", "\"cmp_swapll\"", "\"membar_gl\"", "\"membar_cta\"" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "loongarch_allocate_fcc", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ",", "count", ";", "gcc_assert", "(", "TARGET_HARD_FLOAT", ")", ";", "if", "(", "mode", "==", "FCCmode", ")", "count", "=", "1", ";", "else", "gcc_unreachable", "(", ")", ";", "cfun", "->", "machine", "->", "next_fcc", "+=", "-", "cfun", "->", "machine", "->", "next_fcc", "&", "(", "count", "-", "1", ")", ";", "if", "(", "cfun", "->", "machine", "->", "next_fcc", ">", "FCC_REG_LAST", "-", "FCC_REG_FIRST", ")", "cfun", "->", "machine", "->", "next_fcc", "=", "0", ";", "regno", "=", "FCC_REG_FIRST", "+", "cfun", "->", "machine", "->", "next_fcc", ";", "cfun", "->", "machine", "->", "next_fcc", "+=", "count", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Allocate", "a", "floating-point", "condition-code", "register", "of", "mode", "MODE", "." ]

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

[]

[ "<s>", "bool", "PPCCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "PPCTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "I", "=", "0", ";", "for", "(", "const", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", ".", "isZero", "(", ")", ")", "continue", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "I", "]", ",", "Arg", ",", "I", "}", ";", "setArgFlags", "(", "OrigArg", ",", "I", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "I", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "ccAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "IncomingValueAssigner", "ArgAssigner", "(", "AssignFn", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ")", ";", "return", "determineAndHandleAssignments", "(", "ArgHandler", ",", "ArgAssigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

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

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "auto", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "X86MaterializeInt", "(", "CI", ",", "VT", ")", ";", "else", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "X86MaterializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "X86MaterializeGV", "(", "GV", ",", "VT", ")", ";", "return", "0", ";", "}", "</s>" ]

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

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

[]

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

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

[ "RV16K" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "bool", "Vector", ")", "const", "override", "{", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasNEON", "(", ")", ")", "return", "32", ";", "return", "0", ";", "}", "return", "32", ";", "}", "</s>" ]

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

[ "AArch64", "32", "0", "32" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MSP430", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "MSP430", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other", "0" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "uint16_t", "*", "Dst", "=", "(", "uint16_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", ";", "*", "Dst", "=", "(", "Value", "-", "4", ")", "/", "4", ";", "}", "</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", "." ]

[ "R600", "4", "4" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "LanaiAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createLanaiELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "if", "(", "CommentStream", ")", "{", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "c4x_reorg", "(", "void", ")", "{", "rtx", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "int", "insn_code_number", ";", "rtx", "old", ";", "insn_code_number", "=", "recog_memoized", "(", "insn", ")", ";", "if", "(", "insn_code_number", "<", "0", ")", "continue", ";", "if", "(", "insn_code_number", "==", "CODE_FOR_rptb_end", ")", "c4x_rptb_insert", "(", "insn", ")", ";", "old", "=", "insn", ";", "if", "(", "!", "INSN_DELETED_P", "(", "old", ")", ")", "insn", "=", "try_split", "(", "PATTERN", "(", "old", ")", ",", "old", ",", "1", ")", ";", "if", "(", "INSN_DELETED_P", "(", "old", ")", ")", "{", "PUT_CODE", "(", "old", ",", "NOTE", ")", ";", "NOTE_LINE_NUMBER", "(", "old", ")", "=", "NOTE_INSN_DELETED", ";", "NOTE_SOURCE_FILE", "(", "old", ")", "=", "0", ";", "}", "}", "}", "}", "</s>" ]

[ "We", "need", "to", "use", "direct", "addressing", "for", "large", "constants", "and", "addresses", "that", "can", "not", "fit", "within", "an", "instruction", ".", "We", "must", "check", "for", "these", "after", "after", "the", "final", "jump", "optimization", "pass", ",", "since", "this", "may", "introduce", "a", "local_move", "insn", "for", "a", "SYMBOL_REF", ".", "This", "pass", "must", "come", "before", "delayed", "branch", "slot", "filling", "since", "it", "can", "generate", "additional", "instructions", ".", "This", "function", "also", "fixes", "up", "RTPB", "style", "loops", "that", "did", "n't", "get", "RC", "allocated", "as", "the", "loop", "counter", "." ]

[ "c4x", "0", "1", "0" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "Count", "=", "CSI", ".", "size", "(", ")", ";", "DebugLoc", "DL", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "2", ")", "{", "unsigned", "idx", "=", "Count", "-", "i", "-", "2", ";", "unsigned", "Reg1", "=", "CSI", "[", "idx", "]", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "CSI", "[", "idx", "+", "1", "]", ".", "getReg", "(", ")", ";", "assert", "(", "CSI", "[", "idx", "]", ".", "getFrameIdx", "(", ")", "+", "1", "==", "CSI", "[", "idx", "+", "1", "]", ".", "getFrameIdx", "(", ")", "&&", "\"Out of order callee saved regs!\"", ")", ";", "unsigned", "StrOpc", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "assert", "(", "(", "i", "&", "1", ")", "==", "0", "&&", "\"Odd index for callee-saved reg spill!\"", ")", ";", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected GPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "0", ")", "StrOpc", "=", "AArch64", "::", "STPXpre", ";", "else", "StrOpc", "=", "AArch64", "::", "STPXi", ";", "}", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected FPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "0", ")", "StrOpc", "=", "AArch64", "::", "STPDpre", ";", "else", "StrOpc", "=", "AArch64", "::", "STPDi", ";", "}", "else", "llvm_unreachable", "(", "\"Unexpected callee saved register!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", "<<", "\") -> fi#(\"", "<<", "CSI", "[", "idx", "]", ".", "getFrameIdx", "(", ")", "<<", "\", \"", "<<", "CSI", "[", "idx", "+", "1", "]", ".", "getFrameIdx", "(", ")", "<<", "\")\\n\"", ")", ";", "const", "int", "Offset", "=", "(", "i", "==", "0", ")", "?", "-", "Count", ":", "i", ";", "assert", "(", "(", "Offset", ">=", "-", "64", "&&", "Offset", "<=", "63", ")", "&&", "\"Offset out of bounds for STP immediate\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "if", "(", "StrOpc", "==", "AArch64", "::", "STPDpre", "||", "StrOpc", "==", "AArch64", "::", "STPXpre", ")", "MIB", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "0", "2", "2", "1", "1", "1", "\"Out of order callee saved regs!\"", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "1", "0", "\"Odd index for callee-saved reg spill!\"", "AArch64::GPR64RegClass", "AArch64::GPR64RegClass", "\"Expected GPR64 callee-saved register pair!\"", "0", "AArch64::STPXpre", "AArch64::STPXi", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "\"Expected FPR64 callee-saved register pair!\"", "0", "AArch64::STPDpre", "AArch64::STPDi", "\"Unexpected callee saved register!\"", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "0", "64", "63", "\"Offset out of bounds for STP immediate\"", "AArch64::STPDpre", "AArch64::STPXpre", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "void", "general_scalar_chain", "::", "convert_op", "(", "rtx", "*", "op", ",", "rtx_insn", "*", "insn", ")", "{", "*", "op", "=", "copy_rtx_if_shared", "(", "*", "op", ")", ";", "if", "(", "GET_CODE", "(", "*", "op", ")", "==", "NOT", ")", "{", "convert_op", "(", "&", "XEXP", "(", "*", "op", ",", "0", ")", ",", "insn", ")", ";", "PUT_MODE", "(", "*", "op", ",", "vmode", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "*", "op", ")", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "*", "op", ")", ")", ";", "if", "(", "!", "memory_operand", "(", "*", "op", ",", "GET_MODE", "(", "*", "op", ")", ")", ")", "{", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "*", "op", ")", ")", ";", "emit_insn_before", "(", "gen_rtx_SET", "(", "tmp2", ",", "*", "op", ")", ",", "insn", ")", ";", "*", "op", "=", "tmp2", ";", "}", "emit_insn_before", "(", "gen_rtx_SET", "(", "gen_rtx_SUBREG", "(", "vmode", ",", "tmp", ",", "0", ")", ",", "gen_gpr_to_xmm_move_src", "(", "vmode", ",", "*", "op", ")", ")", ",", "insn", ")", ";", "*", "op", "=", "gen_rtx_SUBREG", "(", "vmode", ",", "tmp", ",", "0", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Preloading operand for insn %d into r%d\\n\"", ",", "INSN_UID", "(", "insn", ")", ",", "REGNO", "(", "tmp", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "*", "op", ")", ")", "{", "*", "op", "=", "gen_rtx_SUBREG", "(", "vmode", ",", "*", "op", ",", "0", ")", ";", "}", "else", "if", "(", "CONST_INT_P", "(", "*", "op", ")", ")", "{", "rtx", "vec_cst", ";", "rtx", "tmp", "=", "gen_rtx_SUBREG", "(", "vmode", ",", "gen_reg_rtx", "(", "smode", ")", ",", "0", ")", ";", "if", "(", "constm1_operand", "(", "*", "op", ",", "GET_MODE", "(", "*", "op", ")", ")", ")", "vec_cst", "=", "CONSTM1_RTX", "(", "vmode", ")", ";", "else", "{", "unsigned", "n", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "rtx", "*", "v", "=", "XALLOCAVEC", "(", "rtx", ",", "n", ")", ";", "v", "[", "0", "]", "=", "*", "op", ";", "for", "(", "unsigned", "i", "=", "1", ";", "i", "<", "n", ";", "++", "i", ")", "v", "[", "i", "]", "=", "const0_rtx", ";", "vec_cst", "=", "gen_rtx_CONST_VECTOR", "(", "vmode", ",", "gen_rtvec_v", "(", "n", ",", "v", ")", ")", ";", "}", "if", "(", "!", "standard_sse_constant_p", "(", "vec_cst", ",", "vmode", ")", ")", "{", "start_sequence", "(", ")", ";", "vec_cst", "=", "validize_mem", "(", "force_const_mem", "(", "vmode", ",", "vec_cst", ")", ")", ";", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn_before", "(", "seq", ",", "insn", ")", ";", "}", "emit_insn_before", "(", "gen_move_insn", "(", "copy_rtx", "(", "tmp", ")", ",", "vec_cst", ")", ",", "insn", ")", ";", "*", "op", "=", "tmp", ";", "}", "else", "{", "gcc_assert", "(", "SUBREG_P", "(", "*", "op", ")", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "*", "op", ")", "==", "vmode", ")", ";", "}", "}", "</s>" ]

[ "Convert", "operand", "OP", "in", "INSN", ".", "We", "should", "handle", "memory", "operands", "and", "uninitialized", "registers", ".", "All", "other", "register", "uses", "are", "converted", "during", "registers", "conversion", "." ]

[ "i386", "0", "0", "0", "\" Preloading operand for insn %d into r%d\\n\"", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "arm_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "TARGET_HAVE_MVE", "&&", "(", "VALID_MVE_PRED_MODE", "(", "mode1", ")", "&&", "VALID_MVE_PRED_MODE", "(", "mode2", ")", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_NEON", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode1", ")", ")", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode2", ")", ")", ")", "||", "(", "TARGET_HAVE_MVE", "&&", "(", "VALID_MVE_MODE", "(", "mode1", ")", "||", "VALID_MVE_STRUCT_MODE", "(", "mode1", ")", ")", "&&", "(", "VALID_MVE_MODE", "(", "mode2", ")", "||", "VALID_MVE_STRUCT_MODE", "(", "mode2", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "MODES_TIEABLE_P", "." ]

[ "arm" ]

[]

[ "<s>", "void", "nvptx_declare_function_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const_tree", "decl", ")", "{", "tree", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "tree", "result_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "int", "argno", "=", "0", ";", "std", "::", "stringstream", "s", ";", "write_fn_proto", "(", "s", ",", "true", ",", "name", ",", "decl", ")", ";", "s", "<<", "\"{\\n\"", ";", "bool", "return_in_mem", "=", "write_return_type", "(", "s", ",", "false", ",", "result_type", ")", ";", "if", "(", "return_in_mem", ")", "argno", "=", "write_arg_type", "(", "s", ",", "0", ",", "argno", ",", "ptr_type_node", ",", "true", ")", ";", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "bool", "prototyped", "=", "true", ";", "if", "(", "!", "args", ")", "{", "args", "=", "DECL_ARGUMENTS", "(", "decl", ")", ";", "prototyped", "=", "false", ";", "}", "for", "(", ";", "args", "!=", "NULL_TREE", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "{", "tree", "type", "=", "prototyped", "?", "TREE_VALUE", "(", "args", ")", ":", "TREE_TYPE", "(", "args", ")", ";", "argno", "=", "write_arg_type", "(", "s", ",", "0", ",", "argno", ",", "type", ",", "prototyped", ")", ";", "}", "if", "(", "stdarg_p", "(", "fntype", ")", ")", "argno", "=", "write_arg_type", "(", "s", ",", "ARG_POINTER_REGNUM", ",", "argno", ",", "ptr_type_node", ",", "true", ")", ";", "if", "(", "DECL_STATIC_CHAIN", "(", "decl", ")", "||", "cfun", "->", "machine", "->", "has_chain", ")", "write_arg_type", "(", "s", ",", "STATIC_CHAIN_REGNUM", ",", "DECL_STATIC_CHAIN", "(", "decl", ")", "?", "argno", ":", "-", "1", ",", "ptr_type_node", ",", "true", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "s", ".", "str", "(", ")", ".", "c_str", "(", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "has_varadic", ")", "init_frame", "(", "file", ",", "STACK_POINTER_REGNUM", ",", "UNITS_PER_WORD", ",", "crtl", "->", "outgoing_args_size", ")", ";", "HOST_WIDE_INT", "sz", "=", "get_frame_size", "(", ")", ";", "if", "(", "sz", "||", "cfun", "->", "machine", "->", "has_chain", ")", "init_frame", "(", "file", ",", "FRAME_POINTER_REGNUM", ",", "crtl", "->", "stack_alignment_needed", "/", "BITS_PER_UNIT", ",", "sz", ")", ";", "int", "maxregs", "=", "max_reg_num", "(", ")", ";", "for", "(", "int", "i", "=", "LAST_VIRTUAL_REGISTER", "+", "1", ";", "i", "<", "maxregs", ";", "i", "++", ")", "{", "if", "(", "regno_reg_rtx", "[", "i", "]", "!=", "const0_rtx", ")", "{", "machine_mode", "mode", "=", "PSEUDO_REGNO_MODE", "(", "i", ")", ";", "machine_mode", "split", "=", "maybe_split_mode", "(", "mode", ")", ";", "if", "(", "split", "!=", "VOIDmode", ")", "mode", "=", "split", ";", "fprintf", "(", "file", ",", "\"\\t.reg%s \"", ",", "nvptx_ptx_type_from_mode", "(", "mode", ",", "true", ")", ")", ";", "output_reg", "(", "file", ",", "i", ",", "split", ",", "-", "2", ")", ";", "fprintf", "(", "file", ",", "\";\\n\"", ")", ";", "}", "}", "if", "(", "cfun", "->", "machine", "->", "axis_predicate", "[", "0", "]", ")", "nvptx_init_axis_predicate", "(", "file", ",", "REGNO", "(", "cfun", "->", "machine", "->", "axis_predicate", "[", "0", "]", ")", ",", "\"y\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "axis_predicate", "[", "1", "]", ")", "nvptx_init_axis_predicate", "(", "file", ",", "REGNO", "(", "cfun", "->", "machine", "->", "axis_predicate", "[", "1", "]", ")", ",", "\"x\"", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_DECLARE_FUNCTION_NAME", ".", "Writes", "the", "start", "of", "a", "ptx", "function", ",", "including", "local", "var", "decls", "and", "copies", "from", "the", "arguments", "to", "local", "regs", "." ]

[ "nvptx", "0", "\"{\\n\"", "0", "0", "1", "\"%s\"", "1", "\"\\t.reg%s \"", "2", "\";\\n\"", "0", "0", "\"y\"", "1", "1", "\"x\"" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "128", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Nand", ")", "return", "AtomicExpansionKind", "::", "LLSC", ";", "if", "(", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "And", ")", "||", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Sub", ")", ")", "return", "AtomicExpansionKind", "::", "LLSC", ";", "return", "(", "Subtarget", "->", "hasLSE", "(", ")", "&&", "Size", "<", "128", ")", "?", "AtomicExpansionKind", "::", "None", ":", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

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

[]

[ "<s>", "MachineInstr", "*", "X86FrameLowering", "::", "emitStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "bool", "InProlog", ")", "const", "{", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isTargetWindowsCoreCLR", "(", ")", ")", "{", "if", "(", "InProlog", ")", "{", "return", "emitStackProbeInlineStub", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "true", ")", ";", "}", "else", "{", "return", "emitStackProbeInline", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "false", ")", ";", "}", "}", "else", "{", "return", "emitStackProbeCall", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "InProlog", ")", ";", "}", "}", "</s>" ]

[ "Emit", "target", "stack", "probe", "code", "." ]

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

[]

[ "<s>", "static", "rtx", "m68k_call_m68k_read_tp", "(", "void", ")", "{", "rtx", "a0", ";", "rtx", "eqv", ";", "rtx_insn", "*", "insns", ";", "rtx", "dest", ";", "start_sequence", "(", ")", ";", "m68k_libcall_value_in_a0_p", "=", "true", ";", "a0", "=", "emit_library_call_value", "(", "m68k_get_m68k_read_tp", "(", ")", ",", "NULL_RTX", ",", "LCT_PURE", ",", "Pmode", ",", "0", ")", ";", "m68k_libcall_value_in_a0_p", "=", "false", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const1_rtx", ")", ",", "UNSPEC_RELOC32", ")", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "a0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Emit", "instruction", "sequence", "that", "calls", "__m68k_read_tp", ".", "A", "pseudo", "register", "with", "result", "of", "__m68k_read_tp", "call", "is", "returned", "." ]

[ "m68k", "0", "1" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no-realign-stack\"", ")", ")", "return", "false", ";", "if", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "ARM", "ARM", "ARM", "ARM", "\"no-realign-stack\"" ]

[]

[ "<s>", "int", "legitimate_pic_operand_p", "(", "rtx", "op", ")", "{", "if", "(", "!", "SYMBOLIC_CONST", "(", "op", ")", ")", "return", "1", ";", "if", "(", "larl_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "bool", "Vector", ")", "{", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasNEON", "(", ")", ")", "return", "16", ";", "if", "(", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "8", ";", "return", "0", ";", "}", "if", "(", "ST", "->", "isThumb1Only", "(", ")", ")", "return", "8", ";", "return", "13", ";", "}", "</s>" ]

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

[ "ARM", "16", "8", "0", "8", "13" ]

[]

[ "<s>", "static", "int", "m68k_sched_issue_rate", "(", "void", ")", "{", "switch", "(", "m68k_sched_cpu", ")", "{", "case", "CPU_CFV1", ":", "case", "CPU_CFV2", ":", "case", "CPU_CFV3", ":", "return", "1", ";", "case", "CPU_CFV4", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "maximal", "number", "of", "insns", "that", "can", "be", "scheduled", "on", "a", "single", "cycle", "." ]

[ "m68k", "1", "2", "0" ]

[]

[ "<s>", "static", "inline", "tree", "def_builtin_pure2", "(", "HOST_WIDE_INT", "mask", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "def_builtin2", "(", "mask", ",", "name", ",", "tcode", ",", "code", ")", ";", "if", "(", "decl", ")", "DECL_PURE_P", "(", "decl", ")", "=", "1", ";", "else", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "pure_p", "=", "true", ";", "return", "decl", ";", "}", "</s>" ]

[ "Like", "def_builtin", ",", "but", "also", "marks", "the", "function", "decl", "``", "pure", "''", "." ]

[ "i386", "1" ]

[]

[ "<s>", "Optional", "<", "ParamLoadedValue", ">", "AArch64InstrInfo", "::", "describeLoadedValue", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "Reg", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getMF", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "MOVZWi", ":", "case", "AArch64", "::", "MOVZXi", ":", "{", "if", "(", "!", "TRI", "->", "isSuperRegisterEq", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "Reg", ")", ")", "return", "None", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "return", "None", ";", "int64_t", "Immediate", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "int", "Shift", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "ParamLoadedValue", "(", "MachineOperand", "::", "CreateImm", "(", "Immediate", "<<", "Shift", ")", ",", "nullptr", ")", ";", "}", "case", "AArch64", "::", "ORRWrs", ":", "case", "AArch64", "::", "ORRXrs", ":", "return", "describeORRLoadedValue", "(", "MI", ",", "Reg", ",", "this", ",", "TRI", ")", ";", "}", "return", "TargetInstrInfo", "::", "describeLoadedValue", "(", "MI", ",", "Reg", ")", ";", "}", "</s>" ]

[ "Produce", "the", "expression", "describing", "the", "MI", "loading", "a", "value", "into", "the", "physical", "register", "Reg", "." ]

[ "AArch64", "AArch64", "AArch64::MOVZWi", "AArch64::MOVZXi", "0", "1", "1", "2", "AArch64::ORRWrs", "AArch64::ORRXrs" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tRestore", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "ARM", "ARM::tGPRRegisterClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegisterClass", "ARM", "0", "ARM::tRestore", "0" ]

[]

[ "<s>", "static", "void", "ia64_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "int", "mask", ",", "grsave", ",", "grsave_prev", ";", "if", "(", "current_frame_info", ".", "need_regstk", ")", "fprintf", "(", "file", ",", "\"\\t.regstk %d, %d, %d, %d\\n\"", ",", "current_frame_info", ".", "n_input_regs", ",", "current_frame_info", ".", "n_local_regs", ",", "current_frame_info", ".", "n_output_regs", ",", "current_frame_info", ".", "n_rotate_regs", ")", ";", "if", "(", "!", "flag_unwind_tables", "&&", "(", "!", "flag_exceptions", "||", "USING_SJLJ_EXCEPTIONS", ")", ")", "return", ";", "mask", "=", "0", ";", "grsave", "=", "grsave_prev", "=", "0", ";", "if", "(", "current_frame_info", ".", "reg_save_b0", "!=", "0", ")", "{", "mask", "|=", "8", ";", "grsave", "=", "grsave_prev", "=", "current_frame_info", ".", "reg_save_b0", ";", "}", "if", "(", "current_frame_info", ".", "reg_save_ar_pfs", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "reg_save_ar_pfs", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "4", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "current_frame_info", ".", "reg_save_ar_pfs", ";", "grsave_prev", "=", "current_frame_info", ".", "reg_save_ar_pfs", ";", "}", "if", "(", "current_frame_info", ".", "reg_fp", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "reg_fp", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "2", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "HARD_FRAME_POINTER_REGNUM", ";", "grsave_prev", "=", "current_frame_info", ".", "reg_fp", ";", "}", "if", "(", "current_frame_info", ".", "reg_save_pr", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "reg_save_pr", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "1", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "current_frame_info", ".", "reg_save_pr", ";", "}", "if", "(", "mask", "&&", "TARGET_GNU_AS", ")", "fprintf", "(", "file", ",", "\"\\t.prologue %d, %d\\n\"", ",", "mask", ",", "ia64_dbx_register_number", "(", "grsave", ")", ")", ";", "else", "fputs", "(", "\"\\t.prologue\\n\"", ",", "file", ")", ";", "if", "(", "current_frame_info", ".", "spill_cfa_off", "!=", "-", "16", ")", "fprintf", "(", "file", ",", "\"\\t.spill %ld\\n\"", ",", "(", "long", ")", "(", "current_frame_info", ".", "spill_cfa_off", "+", "current_frame_info", ".", "spill_size", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "function", "prologue", "." ]

[ "ia64", "\"\\t.regstk %d, %d, %d, %d\\n\"", "0", "0", "0", "8", "0", "0", "1", "4", "0", "0", "0", "1", "2", "0", "0", "0", "1", "1", "0", "\"\\t.prologue %d, %d\\n\"", "\"\\t.prologue\\n\"", "16", "\"\\t.spill %ld\\n\"" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "handleD16VData", "(", "SDValue", "VData", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "StoreVT", "=", "VData", ".", "getValueType", "(", ")", ";", "if", "(", "!", "StoreVT", ".", "isVector", "(", ")", ")", "return", "VData", ";", "SDLoc", "DL", "(", "VData", ")", ";", "unsigned", "NumElements", "=", "StoreVT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "Subtarget", "->", "hasUnpackedD16VMem", "(", ")", ")", "{", "EVT", "IntStoreVT", "=", "StoreVT", ".", "changeTypeToInteger", "(", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "EquivStoreVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i32", ",", "NumElements", ")", ";", "SDValue", "ZExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "EquivStoreVT", ",", "IntVData", ")", ";", "return", "DAG", ".", "UnrollVectorOp", "(", "ZExt", ".", "getNode", "(", ")", ")", ";", "}", "else", "if", "(", "NumElements", "==", "3", ")", "{", "EVT", "IntStoreVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StoreVT", ".", "getStoreSizeInBits", "(", ")", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "WidenedStoreVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StoreVT", ".", "getVectorElementType", "(", ")", ",", "NumElements", "+", "1", ")", ";", "EVT", "WidenedIntVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WidenedStoreVT", ".", "getStoreSizeInBits", "(", ")", ")", ";", "SDValue", "ZExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "WidenedIntVT", ",", "IntVData", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "WidenedStoreVT", ",", "ZExt", ")", ";", "}", "assert", "(", "isTypeLegal", "(", "StoreVT", ")", ")", ";", "return", "VData", ";", "}", "</s>" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "AMDGPU", "SI", "ISD::BITCAST", "MVT::i32", "ISD::ZERO_EXTEND", "3", "ISD::BITCAST", "1", "ISD::ZERO_EXTEND", "ISD::BITCAST" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "parsePrimaryExpr", "(", "const", "MCExpr", "*", "&", "Res", ",", "SMLoc", "&", "EndLoc", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "if", "(", "Parser", ".", "parsePrimaryExpr", "(", "Res", ",", "EndLoc", ")", ")", "{", "SMLoc", "StartLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "unsigned", "RegNo", ";", "bool", "TryRegParse", "=", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Percent", ")", "||", "(", "isParsingIntelSyntax", "(", ")", "&&", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", ";", "if", "(", "!", "TryRegParse", "||", "ParseRegister", "(", "RegNo", ",", "StartLoc", ",", "EndLoc", ")", ")", "return", "true", ";", "Parser", ".", "clearPendingErrors", "(", ")", ";", "Res", "=", "X86MCExpr", "::", "create", "(", "RegNo", ",", "Parser", ".", "getContext", "(", ")", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Parse", "a", "primary", "expression", "." ]

[ "X86", "X86", "X86MCExpr::create" ]

[]

[ "<s>", "bool", "PPCFastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "return", "MI", "&&", "OpNo", "&&", "LI", "&&", "false", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "AVRAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "&", "Asm", ".", "getContext", "(", ")", ")", ";", "if", "(", "Value", "==", "0", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "auto", "NumBits", "=", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ";", "auto", "NumBytes", "=", "(", "NumBits", "/", "8", ")", "+", "(", "(", "NumBits", "%", "8", ")", "==", "0", "?", "0", ":", "1", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "{", "uint8_t", "mask", "=", "(", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "mask", ";", "}", "}", "</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", "." ]

[ "AVR", "AVR", "0", "8", "8", "0", "0", "1", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "void", "cris_conditional_register_usage", "(", "void", ")", "{", "if", "(", "flag_pic", ")", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_HAS_MUL_INSNS", ")", "fixed_regs", "[", "CRIS_MOF_REGNUM", "]", "=", "0", ";", "if", "(", "cris_cpu_version", "<", "8", ")", "reg_names", "[", "CRIS_CC0_REGNUM", "]", "=", "\"ccr\"", ";", "}", "</s>" ]

[ "The", "CONDITIONAL_REGISTER_USAGE", "worker", "." ]

[ "cris", "1", "0", "8", "\"ccr\"" ]

[]

[ "<s>", "bool", "RISCVSExtWRemoval", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "DisableSExtWRemoval", ")", "return", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "RISCVSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "SmallPtrSet", "<", "MachineInstr", "*", ",", "4", ">", "SExtWRemovalCands", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "I", "++", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "RISCV", "::", "ADDIW", "||", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "||", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "!=", "0", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "continue", ";", "Register", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "SrcReg", ".", "isVirtual", "(", ")", ")", "continue", ";", "SExtWRemovalCands", ".", "insert", "(", "MI", ")", ";", "}", "}", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "MI", ":", "SExtWRemovalCands", ")", "{", "SmallPtrSet", "<", "MachineInstr", "*", ",", "4", ">", "FixableDef", ";", "Register", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "&", "SrcMI", "=", "*", "MRI", ".", "getVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "isSignExtendedW", "(", "SrcMI", ",", "MRI", ",", "FixableDef", ")", ")", "continue", ";", "Register", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "MRI", ".", "getRegClass", "(", "DstReg", ")", ")", ")", "continue", ";", "for", "(", "MachineInstr", "*", "Fixable", ":", "FixableDef", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "Fixable", "->", "getParent", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "Fixable", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Code", "=", "getWOp", "(", "Fixable", "->", "getOpcode", "(", ")", ")", ";", "MachineInstrBuilder", "Replacement", "=", "BuildMI", "(", "MBB", ",", "Fixable", ",", "DL", ",", "ST", ".", "getInstrInfo", "(", ")", "->", "get", "(", "Code", ")", ")", ";", "for", "(", "auto", "Op", ":", "Fixable", "->", "operands", "(", ")", ")", "Replacement", ".", "add", "(", "Op", ")", ";", "for", "(", "auto", "Op", ":", "Fixable", "->", "memoperands", "(", ")", ")", "Replacement", ".", "addMemOperand", "(", "Op", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Replacing \"", "<<", "*", "Fixable", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" with \"", "<<", "*", "Replacement", ")", ";", "Fixable", "->", "eraseFromParent", "(", ")", ";", "++", "NumTransformedToWInstrs", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Removing redundant sign-extension\\n\"", ")", ";", "MRI", ".", "replaceRegWith", "(", "DstReg", ",", "SrcReg", ")", ";", "MRI", ".", "clearKillFlags", "(", "SrcReg", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "++", "NumRemovedSExtW", ";", "MadeChange", "=", "true", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "4", "RISCV::ADDIW", "2", "2", "0", "1", "1", "4", "1", "0", "\"Replacing \"", "\" with \"", "\"Removing redundant sign-extension\\n\"" ]

[]

[ "<s>", "void", "GBZ80RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "GBZ80TargetMachine", "&", "TM", "=", "(", "const", "GBZ80TargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "GB", "::", "FRMIDX", "||", "MI", ".", "getOpcode", "(", ")", "==", "GB", "::", "LD8_FI", "||", "MI", ".", "getOpcode", "(", ")", "==", "GB", "::", "ST8_FI", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "GBZ80", "GB", "0", "\"Unexpected SPAdj value\"", "GB", "GB", "GB::FRMIDX", "GB::LD8_FI", "GB::ST8_FI" ]

[]

[ "<s>", "static", "void", "emit_vrsave_prologue", "(", "rs6000_stack_t", "*", "info", ",", "int", "save_regno", ",", "HOST_WIDE_INT", "frame_off", ",", "rtx", "frame_reg_rtx", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "save_regno", ")", ";", "rtx", "vrsave", "=", "gen_rtx_REG", "(", "SImode", ",", "VRSAVE_REGNO", ")", ";", "if", "(", "TARGET_MACHO", ")", "emit_insn", "(", "gen_get_vrsave_internal", "(", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "vrsave", ")", ")", ";", "int", "offset", "=", "info", "->", "vrsave_save_offset", "+", "frame_off", ";", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "frame_reg_rtx", ",", "offset", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "info", "->", "vrsave_mask", ")", ")", ")", ";", "emit_insn", "(", "generate_set_vrsave", "(", "reg", ",", "info", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "VRSAVE", "is", "a", "bit", "vector", "representing", "which", "AltiVec", "registers", "are", "used", ".", "The", "OS", "uses", "this", "to", "determine", "which", "vector", "registers", "to", "save", "on", "a", "context", "switch", ".", "We", "need", "to", "save", "VRSAVE", "on", "the", "stack", "frame", ",", "add", "whatever", "AltiVec", "registers", "we", "used", "in", "this", "function", ",", "and", "do", "the", "corresponding", "magic", "in", "the", "epilogue", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vzip", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "high", ",", "mask", ",", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "rtx", "out0", ",", "out1", ",", "in0", ",", "in1", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "first_elem", ";", "bool", "is_swapped", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ">=", "8", ")", "return", "false", ";", "is_swapped", "=", "BYTES_BIG_ENDIAN", ";", "first_elem", "=", "d", "->", "perm", "[", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", "^", "is_swapped", "]", ";", "high", "=", "nelt", "/", "2", ";", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "high", ")", ")", ";", "else", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", ")", "high", "=", "0", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", "/", "2", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "i", "+", "high", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "2", "*", "i", "+", "is_swapped", ")", "]", "!=", "elt", ")", "return", "false", ";", "elt", "=", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "i", "+", "nelt", "+", "high", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "2", "*", "i", "+", "!", "is_swapped", ")", "]", "!=", "elt", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "gen", "=", "gen_neon_vzipv16qi_internal", ";", "break", ";", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vzipv8qi_internal", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_neon_vzipv8hi_internal", ";", "break", ";", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vzipv4hi_internal", ";", "break", ";", "case", "E_V8HFmode", ":", "gen", "=", "gen_neon_vzipv8hf_internal", ";", "break", ";", "case", "E_V4HFmode", ":", "gen", "=", "gen_neon_vzipv4hf_internal", ";", "break", ";", "case", "E_V4SImode", ":", "gen", "=", "gen_neon_vzipv4si_internal", ";", "break", ";", "case", "E_V2SImode", ":", "gen", "=", "gen_neon_vzipv2si_internal", ";", "break", ";", "case", "E_V2SFmode", ":", "gen", "=", "gen_neon_vzipv2sf_internal", ";", "break", ";", "case", "E_V4SFmode", ":", "gen", "=", "gen_neon_vzipv4sf_internal", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "is_swapped", ")", "std", "::", "swap", "(", "in0", ",", "in1", ")", ";", "out0", "=", "d", "->", "target", ";", "out1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "if", "(", "high", ")", "std", "::", "swap", "(", "out0", ",", "out1", ")", ";", "emit_insn", "(", "gen", "(", "out0", ",", "in0", ",", "in1", ",", "out1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VZIP", "insns", "." ]

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

[]

[ "<s>", "void", "ARCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Only GPR32 src copy supported.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ")", "&&", "\"Only GPR32 dest copy supported.\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARC", "::", "MOV_rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC::GPR32RegClass", "\"Only GPR32 src copy supported.\"", "ARC::GPR32RegClass", "\"Only GPR32 dest copy supported.\"", "ARC::MOV_rr" ]

[]

[ "<s>", "bool", "aarch64_use_return_insn_p", "(", "void", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "false", ";", "if", "(", "crtl", "->", "profile", ")", "return", "false", ";", "return", "known_eq", "(", "cfun", "->", "machine", "->", "frame", ".", "frame_size", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "we", "can", "use", "a", "simple_return", "insn", ".", "This", "function", "checks", "whether", "the", "callee", "saved", "stack", "is", "empty", ",", "which", "means", "no", "restore", "actions", "are", "need", ".", "The", "pro_and_epilogue", "will", "use", "this", "to", "check", "whether", "shrink-wrapping", "opt", "is", "feasible", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "void", "nds32_emit_isr_jmptbl_section", "(", "int", "vector_id", ")", "{", "char", "section_name", "[", "100", "]", ";", "char", "symbol_name", "[", "100", "]", ";", "snprintf", "(", "section_name", ",", "sizeof", "(", "section_name", ")", ",", "\".nds32_jmptbl.%02d\"", ",", "vector_id", ")", ";", "snprintf", "(", "symbol_name", ",", "sizeof", "(", "symbol_name", ")", ",", "\"_nds32_jmptbl_%02d\"", ",", "vector_id", ")", ";", "nds32_emit_section_head_template", "(", "section_name", ",", "symbol_name", ",", "2", ",", "true", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.word\\t%s\\n\"", ",", "nds32_isr_vectors", "[", "vector_id", "]", ".", "func_name", ")", ";", "nds32_emit_section_tail_template", "(", "symbol_name", ")", ";", "}", "</s>" ]

[ "Function", "to", "emit", "isr", "jump", "table", "section", "." ]

[ "nds32", "100", "100", "\".nds32_jmptbl.%02d\"", "\"_nds32_jmptbl_%02d\"", "2", "\"\\t.word\\t%s\\n\"" ]

[]

[ "<s>", "void", "PPCMIPeephole", "::", "initialize", "(", "MachineFunction", "&", "MFParm", ")", "{", "MF", "=", "&", "MFParm", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MPDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "MBFI", "=", "&", "getAnalysis", "<", "MachineBlockFrequencyInfo", ">", "(", ")", ";", "EntryFreq", "=", "MBFI", "->", "getEntryFreq", "(", ")", ";", "TII", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** PowerPC MI peephole pass ***\\n\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "\"*** PowerPC MI peephole pass ***\\n\\n\"" ]

[]

[ "<s>", "static", "void", "emit_pop_byte", "(", "unsigned", "regno", ")", "{", "rtx", "mem", ",", "reg", ";", "mem", "=", "gen_rtx_PRE_INC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

[ "Helper", "for", "avr_expand_epilogue", ".", "Emit", "a", "pop", "of", "a", "byte", "register", "." ]

[ "avr" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "insertPass", "(", "&", "LiveVariablesID", ",", "&", "SIFixSGPRLiveRangesID", ",", "false", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", "RegAllocPass", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "void", "MipsSETargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "bool", "IsCallReloc", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ",", "unsigned", "nargs", ")", "const", "{", "Ops", ".", "push_back", "(", "Callee", ")", ";", "MipsTargetLowering", "::", "getOpndList", "(", "Ops", ",", "RegsToPass", ",", "IsPICCall", ",", "GlobalOrExternal", ",", "InternalLinkage", ",", "IsCallReloc", ",", "CLI", ",", "Callee", ",", "Chain", ",", "nargs", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

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

[]

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

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

[ "R600", "MVT::f32" ]

[]

[ "<s>", "static", "rtx_insn", "*", "aarch64_speculation_establish_tracker", "(", ")", "{", "rtx", "sp", "=", "gen_rtx_REG", "(", "DImode", ",", "SP_REGNUM", ")", ";", "rtx", "tracker", "=", "gen_rtx_REG", "(", "DImode", ",", "SPECULATION_TRACKER_REGNUM", ")", ";", "start_sequence", "(", ")", ";", "rtx", "cc", "=", "aarch64_gen_compare_reg", "(", "EQ", ",", "sp", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_cstoredi_neg", "(", "tracker", ",", "gen_rtx_NE", "(", "CCmode", ",", "cc", ",", "const0_rtx", ")", ",", "cc", ")", ")", ";", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "seq", ";", "}", "</s>" ]

[ "Generate", "a", "code", "sequence", "to", "establish", "the", "tracker", "variable", "from", "the", "contents", "of", "SP", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "vms_c_register_pragma", "(", "void", ")", "{", "c_register_pragma", "(", "NULL", ",", "\"__nostandard\"", ",", "vms_pragma_nostandard", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"nostandard\"", ",", "vms_pragma_nostandard", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"__standard\"", ",", "vms_pragma_standard", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"standard\"", ",", "vms_pragma_standard", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"__member_alignment\"", ",", "vms_pragma_member_alignment", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"member_alignment\"", ",", "vms_pragma_member_alignment", ")", ";", "c_register_pragma_with_expansion", "(", "NULL", ",", "\"__nomember_alignment\"", ",", "vms_pragma_nomember_alignment", ")", ";", "c_register_pragma_with_expansion", "(", "NULL", ",", "\"nomember_alignment\"", ",", "vms_pragma_nomember_alignment", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"__pointer_size\"", ",", "vms_pragma_pointer_size", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"__required_pointer_size\"", ",", "vms_pragma_required_pointer_size", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"__extern_model\"", ",", "vms_pragma_extern_model", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"extern_model\"", ",", "vms_pragma_extern_model", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"__message\"", ",", "vms_pragma_message", ")", ";", "c_register_pragma", "(", "NULL", ",", "\"__extern_prefix\"", ",", "vms_pragma_extern_prefix", ")", ";", "}", "</s>" ]

[ "Add", "vms-specific", "pragma", "." ]

[ "vms", "\"__nostandard\"", "\"nostandard\"", "\"__standard\"", "\"standard\"", "\"__member_alignment\"", "\"member_alignment\"", "\"__nomember_alignment\"", "\"nomember_alignment\"", "\"__pointer_size\"", "\"__required_pointer_size\"", "\"__extern_model\"", "\"extern_model\"", "\"__message\"", "\"__extern_prefix\"" ]

[]

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

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

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

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "getTargetStreamer", "(", ")", ".", "emitFrame", "(", "stackReg", ",", "stackSize", ",", "returnReg", ")", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "sh_expand_prologue", "(", "void", ")", "{", "int", "save_flags", "=", "target_flags", ";", "tree", "sp_switch_attr", "=", "lookup_attribute", "(", "\"sp_switch\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", ";", "current_function_interrupt", "=", "sh_cfun_interrupt_handler_p", "(", ")", ";", "int", "pretend_args", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "if", "(", "TARGET_VARARGS_PRETEND_ARGS", "(", "current_function_decl", ")", "&&", "(", "NPARM_REGS", "(", "SImode", ")", ">", "crtl", "->", "args", ".", "info", ".", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", ")", ")", "pretend_args", "=", "0", ";", "output_stack_adjust", "(", "-", "pretend_args", ",", "stack_pointer_rtx", ",", "0", ",", "NULL", ",", "true", ")", ";", "int", "stack_usage", "=", "pretend_args", ";", "if", "(", "cfun", "->", "stdarg", ")", "{", "if", "(", "TARGET_VARARGS_PRETEND_ARGS", "(", "current_function_decl", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "NPARM_REGS", "(", "SImode", ")", ";", "i", "++", ")", "{", "int", "rn", "=", "NPARM_REGS", "(", "SImode", ")", "+", "FIRST_PARM_REG", "-", "i", "-", "1", ";", "if", "(", "i", ">=", "(", "NPARM_REGS", "(", "SImode", ")", "-", "crtl", "->", "args", ".", "info", ".", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", ")", ")", "break", ";", "push", "(", "rn", ")", ";", "stack_usage", "+=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "}", "}", "}", "if", "(", "sp_switch_attr", ")", "{", "rtx", "lab", ",", "newsrc", ";", "tree", "arg", "=", "TREE_VALUE", "(", "TREE_VALUE", "(", "sp_switch_attr", ")", ")", ";", "const", "char", "*", "s", "=", "ggc_strdup", "(", "TREE_STRING_POINTER", "(", "arg", ")", ")", ";", "rtx", "sp_switch", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "s", ")", ";", "lab", "=", "add_constant", "(", "sp_switch", ",", "SImode", ",", "0", ")", ";", "newsrc", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "lab", ")", ";", "emit_insn", "(", "gen_sp_switch_1", "(", "newsrc", ")", ")", ";", "}", "HARD_REG_SET", "live_regs_mask", ";", "int", "d", "=", "calc_live_regs", "(", "&", "live_regs_mask", ")", ";", "if", "(", "target_flags", "!=", "save_flags", "&&", "!", "current_function_interrupt", ")", "emit_insn", "(", "gen_toggle_sz", "(", ")", ")", ";", "push_regs", "(", "&", "live_regs_mask", ",", "current_function_interrupt", ")", ";", "stack_usage", "+=", "d", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_FDPIC", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "emit_insn", "(", "gen_GOTaddr2picreg", "(", "const0_rtx", ")", ")", ";", "if", "(", "target_flags", "!=", "save_flags", "&&", "!", "current_function_interrupt", ")", "emit_insn", "(", "gen_toggle_sz", "(", ")", ")", ";", "target_flags", "=", "save_flags", ";", "output_stack_adjust", "(", "-", "rounded_frame_size", "(", "d", ")", ",", "stack_pointer_rtx", ",", "0", ",", "NULL", ",", "true", ")", ";", "stack_usage", "+=", "rounded_frame_size", "(", "d", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_frame_insn", "(", "GEN_MOV", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "crtl", "->", "profile", "||", "flag_exceptions", "||", "flag_unwind_tables", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "stack_usage", ";", "}", "</s>" ]

[ "Expand", "code", "for", "the", "function", "prologue", "." ]

[ "sh", "\"sp_switch\"", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "M68kInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"M68k branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "M68k", "::", "BRA8", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "bool", "FallThru", "=", "FBB", "==", "nullptr", ";", "unsigned", "Count", "=", "0", ";", "M68k", "::", "CondCode", "CC", "=", "(", "M68k", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "CC", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "!", "FallThru", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "M68k", "::", "BRA8", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "M68k", "M68k", "\"InsertBranch must not be told to insert a fallthrough\"", "1", "0", "\"M68k branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "M68k::BRA8", "1", "0", "M68k::CondCode", "M68k::CondCode", "0", "M68k::BRA8" ]

[]

[ "<s>", "const", "TPCInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "TPC", "TPC" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "bool", "mayLoad", "(", ")", "const", "{", "return", "Load", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "could", "possibly", "read", "memory", "." ]

[ "Hexagon" ]

[]

[ "<s>", "BitVector", "MSP430RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGW", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "MSP430", "::", "FPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "FPW", ")", ";", "}", "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", "." ]

[ "MSP430", "MSP430", "MSP430::PCB", "MSP430::SPB", "MSP430::SRB", "MSP430::CGB", "MSP430::PCW", "MSP430::SPW", "MSP430::SRW", "MSP430::CGW", "MSP430::FPB", "MSP430::FPW" ]

[]

[ "<s>", "static", "rtx", "ia64_function_incoming_arg", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "ia64_function_arg_1", "(", "cum", ",", "arg", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCION_INCOMING_ARG", "target", "hook", "." ]

[ "ia64" ]

[]

[ "<s>", "bool", "SIPeepholeSDWA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasSDWA", "(", ")", "||", "!", "AMDGPU", "::", "isVI", "(", "ST", ")", ")", "{", "return", "false", ";", "}", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "std", "::", "unordered_map", "<", "MachineInstr", "*", ",", "SDWAOperandsVector", ">", "PotentialMatches", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "SDWAOperands", ".", "clear", "(", ")", ";", "matchSDWAOperands", "(", "MBB", ")", ";", "PotentialMatches", ".", "clear", "(", ")", ";", "for", "(", "auto", "&", "OperandPair", ":", "SDWAOperands", ")", "{", "auto", "&", "Operand", "=", "OperandPair", ".", "second", ";", "MachineInstr", "*", "PotentialMI", "=", "Operand", "->", "potentialToConvert", "(", "TII", ")", ";", "if", "(", "PotentialMI", ")", "{", "PotentialMatches", "[", "PotentialMI", "]", ".", "push_back", "(", "std", "::", "move", "(", "Operand", ")", ")", ";", "}", "}", "for", "(", "auto", "&", "PotentialPair", ":", "PotentialMatches", ")", "{", "MachineInstr", "&", "PotentialMI", "=", "*", "PotentialPair", ".", "first", ";", "convertToSDWA", "(", "PotentialMI", ",", "PotentialPair", ".", "second", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::isVI" ]

[]

[ "<s>", "bool", "TPCAAResult", "::", "pointsToConstantMemory", "(", "const", "MemoryLocation", "&", "Loc", ",", "AAQueryInfo", "&", "QInfo", ",", "bool", "OrLocal", ")", "{", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "QInfo", ",", "OrLocal", ")", ";", "}", "</s>" ]

[ "A", "convenience", "wrapper", "around", "the", "primary", "pointsToConstantMemory", "interface", "." ]

[ "TPC", "TPC" ]

[]