Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "PPCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "return", "getPPCRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTCRF", "PPC::MFOCRF", "PPC::CR0", "PPC::CR7", "PPC", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

[ "<s>", "bool", "hasModifiers", "(", ")", "const", "{", "return", "getModifiers", "(", ")", ".", "hasModifiers", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "has", "any", "modifiers", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "DAG", ".", "getTarget", "(", ")", ",", "RetLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "if", "(", "RetLocs", ".", "empty", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RetLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "RetLocs", "[", "I", "]", ";", "SDValue", "RetValue", "=", "OutVals", "[", "I", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "RetValue", "=", "convertValVTToLocVT", "(", "DAG", ",", "DL", ",", "VA", ",", "RetValue", ")", ";", "unsigned", "Reg", "=", "VA", ".", "getLocReg", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RetValue", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::OutputArg", "16", "SystemZ", "SystemZISD::RET_FLAG", "MVT::Other", "4", "0", "\"Can only return in registers!\"", "1", "0", "SystemZISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "ix86_hard_regno_mode_ok", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "CC_REGNO_P", "(", "regno", ")", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_RANDOM", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_PARTIAL_INT", ")", "return", "0", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "VALID_FP_MODE_P", "(", "mode", ")", ";", "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "VALID_SSE_REG_MODE", "(", "mode", ")", "||", "VALID_SSE2_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "MMX_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "mode", "==", "QImode", ")", "{", "if", "(", "regno", "<", "4", "||", "TARGET_64BIT", ")", "return", "1", ";", "if", "(", "!", "TARGET_PARTIAL_REG_STALL", ")", "return", "1", ";", "return", "reload_in_progress", "||", "reload_completed", ";", "}", "else", "if", "(", "VALID_INT_MODE_P", "(", "mode", ")", ")", "return", "1", ";", "else", "if", "(", "VALID_FP_MODE_P", "(", "mode", ")", ")", "return", "1", ";", "else", "if", "(", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", "||", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

[ "i386", "0", "4", "1", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "sh_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "fprintf", "(", "stream", ",", "\"@%s\"", ",", "reg_names", "[", "true_regnum", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "index", "=", "XEXP", "(", "x", ",", "1", ")", ";", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "stream", ",", "\"@(%d,%s)\"", ",", "(", "int", ")", "INTVAL", "(", "index", ")", ",", "reg_names", "[", "true_regnum", "(", "base", ")", "]", ")", ";", "break", ";", "case", "REG", ":", "case", "SUBREG", ":", "{", "int", "base_num", "=", "true_regnum", "(", "base", ")", ";", "int", "index_num", "=", "true_regnum", "(", "index", ")", ";", "fprintf", "(", "stream", ",", "\"@(r0,%s)\"", ",", "reg_names", "[", "MAX", "(", "base_num", ",", "index_num", ")", "]", ")", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "stream", ",", "\"@-%s\"", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "stream", ",", "\"@%s+\"", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "break", ";", "default", ":", "x", "=", "mark_constant_pool_use", "(", "x", ")", ";", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "in", "x", "to", "the", "stream", "." ]

[ "sh", "\"@%s\"", "0", "1", "\"@(%d,%s)\"", "\"@(r0,%s)\"", "\"@-%s\"", "0", "\"@%s+\"", "0" ]

[]

[ "<s>", "static", "void", "tilepro_init_builtins", "(", "void", ")", "{", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "tilepro_builtins", ")", ";", "i", "++", ")", "{", "const", "struct", "tilepro_builtin_def", "*", "p", "=", "&", "tilepro_builtins", "[", "i", "]", ";", "tree", "ftype", ",", "ret_type", ",", "arg_type_list", "=", "void_list_node", ";", "tree", "decl", ";", "int", "j", ";", "for", "(", "j", "=", "strlen", "(", "p", "->", "type", ")", "-", "1", ";", "j", ">", "0", ";", "j", "--", ")", "{", "arg_type_list", "=", "tree_cons", "(", "NULL_TREE", ",", "char_to_type", "(", "p", "->", "type", "[", "j", "]", ")", ",", "arg_type_list", ")", ";", "}", "ret_type", "=", "char_to_type", "(", "p", "->", "type", "[", "0", "]", ")", ";", "ftype", "=", "build_function_type", "(", "ret_type", ",", "arg_type_list", ")", ";", "decl", "=", "add_builtin_function", "(", "p", "->", "name", ",", "ftype", ",", "p", "->", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "if", "(", "p", "->", "is_const", ")", "TREE_READONLY", "(", "decl", ")", "=", "1", ";", "TREE_NOTHROW", "(", "decl", ")", "=", "1", ";", "if", "(", "tilepro_builtin_info", "[", "p", "->", "code", "]", ".", "fndecl", "==", "NULL", ")", "tilepro_builtin_info", "[", "p", "->", "code", "]", ".", "fndecl", "=", "decl", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_INIT_BUILTINS", "." ]

[ "tilepro", "0", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "NyuziPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createNyuziISelDag", "(", "getNyuziTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "Register", "getFramePtr", "(", ")", "const", "{", "return", "FramePtr", ";", "}", "</s>" ]

[ "Returns", "physical", "register", "used", "as", "frame", "pointer", "." ]

[ "X86" ]

[]

[ "<s>", "void", "X86InstPrinterCommon", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "SymbolizeOperands", ")", "return", ";", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "PrintBranchImmAsAddress", ")", "{", "uint64_t", "Target", "=", "Address", "+", "Op", ".", "getImm", "(", ")", ";", "if", "(", "MAI", ".", "getCodePointerSize", "(", ")", "==", "4", ")", "Target", "&=", "0xffffffff", ";", "O", "<<", "formatHex", "(", "Target", ")", ";", "}", "else", "O", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"unknown pcrel immediate operand\"", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "evaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "formatHex", "(", "(", "uint64_t", ")", "Address", ")", ";", "}", "else", "{", "Op", ".", "getExpr", "(", ")", "->", "print", "(", "O", ",", "&", "MAI", ")", ";", "}", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "X86", "X86", "4", "0xffffffff", "\"unknown pcrel immediate operand\"" ]

[]

[ "<s>", "static", "rtx", "find_ltrel_base", "(", "rtx", "x", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_LTREL_BASE", ")", "return", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "rtx", "fnd", "=", "find_ltrel_base", "(", "XEXP", "(", "x", ",", "i", ")", ")", ";", "if", "(", "fnd", ")", "return", "fnd", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "x", ",", "i", ")", ";", "j", "++", ")", "{", "rtx", "fnd", "=", "find_ltrel_base", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ";", "if", "(", "fnd", ")", "return", "fnd", ";", "}", "}", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Check", "whether", "X", "contains", "an", "UNSPEC_LTREL_BASE", ".", "Return", "its", "constant", "pool", "symbol", "if", "found", ",", "NULL_RTX", "otherwise", "." ]

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

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "llvm_unreachable", "(", "\"TODO: implement printRegName\"", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "WebAssembly", "WebAssembly", "\"TODO: implement printRegName\"" ]

[]

[ "<s>", "bool", "Z80oldInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "!", "MI", ".", "isBarrier", "(", ")", ")", "{", "return", "true", ";", "}", "if", "(", "!", "MI", ".", "isPredicable", "(", ")", ")", "{", "return", "true", ";", "}", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "Z80old", "Z80old" ]

[]

[ "<s>", "SDValue", "LEGTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InGlue", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "assert", "(", "!", "isVarArg", "&&", "\"Unsupported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_LEG", ")", ";", "for", "(", "auto", "&", "Loc", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Loc", ".", "getLocReg", "(", ")", ",", "Loc", ".", "getValVT", "(", ")", ",", "InGlue", ")", ".", "getValue", "(", "1", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "ISD::InputArg", "\"Unsupported\"", "16", "LEG", "1", "2", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "SIMachineFunctionInfo", "*", "MFI", "=", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "TRI", "->", "getCommonSubClass", "(", "RC", ",", "&", "AMDGPU", "::", "SReg_32RegClass", ")", ")", "{", "SIMachineFunctionInfo", "::", "SpilledReg", "Spill", "=", "MFI", "->", "SpillTracker", ".", "getSpilledReg", "(", "FrameIndex", ")", ";", "assert", "(", "Spill", ".", "VGPR", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_READLANE_B32", ")", ",", "DestReg", ")", ".", "addReg", "(", "Spill", ".", "VGPR", ")", ".", "addImm", "(", "Spill", ".", "Lane", ")", ";", "insertNOPs", "(", "MI", ",", "3", ")", ";", "}", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "unsigned", "Opcode", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Cannot spill register class\"", ")", ";", "}", "SIMachineFunctionInfo", "::", "SpilledReg", "Spill", "=", "MFI", "->", "SpillTracker", ".", "getSpilledReg", "(", "FrameIndex", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "Spill", ".", "VGPR", ")", ".", "addImm", "(", "FrameIndex", ")", ";", "insertNOPs", "(", "MI", ",", "3", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"VGPR spilling not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "SI", "3", "8", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "\"Cannot spill register class\"", "SI", "3", "\"VGPR spilling not supported\"" ]

[]

[ "<s>", "int", "arith_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "return", "(", "register_operand", "(", "op", ",", "mode", ")", "||", "GET_CODE", "(", "op", ")", "==", "CONST_INT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "register", ",", "or", "is", "a", "CONST_INT", "that", "can", "fit", "in", "a", "signed", "13", "bit", "immediate", "field", ".", "This", "is", "an", "acceptable", "SImode", "operand", "for", "most", "3", "address", "instructions", "." ]

[ "pdp11" ]

[]

[ "<s>", "static", "rtx", "ix86_gen_TWO52", "(", "machine_mode", "mode", ")", "{", "const", "struct", "real_format", "*", "fmt", ";", "REAL_VALUE_TYPE", "TWO52r", ";", "rtx", "TWO52", ";", "fmt", "=", "REAL_MODE_FORMAT", "(", "mode", ")", ";", "real_2expN", "(", "&", "TWO52r", ",", "fmt", "->", "p", "-", "1", ",", "mode", ")", ";", "TWO52", "=", "const_double_from_real_value", "(", "TWO52r", ",", "mode", ")", ";", "TWO52", "=", "force_reg", "(", "mode", ",", "TWO52", ")", ";", "return", "TWO52", ";", "}", "</s>" ]

[ "Generate", "and", "return", "a", "rtx", "of", "mode", "MODE", "for", "2", "*", "*", "n", "where", "n", "is", "the", "number", "of", "bits", "of", "the", "mantissa", "of", "MODE", ",", "which", "must", "be", "one", "of", "DFmode", "or", "SFmode", "." ]

[ "i386", "1" ]

[]

[ "<s>", "static", "void", "mips_sim_wait_insn", "(", "struct", "mips_sim", "*", "state", ",", "rtx", "insn", ")", "{", "mips_sim_wait_regs", "(", "state", ",", "insn", ")", ";", "mips_sim_wait_units", "(", "state", ",", "insn", ")", ";", "}", "</s>" ]

[ "Advance", "simulation", "state", "STATE", "until", "INSN", "is", "ready", "to", "issue", "." ]

[ "mips" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", "||", "RC", "==", "ARM", "::", "DPR_VFP2RegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FSTD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FSTS", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "RC", "==", "ARM", "::", "QPRRegisterClass", "&&", "\"Unknown regclass!\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VSTRQ", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegisterClass", "ARM::STR", "0", "0", "ARM::DPRRegisterClass", "ARM::DPR_VFP2RegisterClass", "ARM::FSTD", "0", "ARM::SPRRegisterClass", "ARM::FSTS", "0", "ARM::QPRRegisterClass", "\"Unknown regclass!\"", "ARM::VSTRQ", "0" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "LowerFormalArguments_64", "(", "Chain", ",", "CallConv", ",", "IsVarArg", ",", "Ins", ",", "DL", ",", "DAG", ",", "InVals", ")", ";", "return", "LowerFormalArguments_32", "(", "Chain", ",", "CallConv", ",", "IsVarArg", ",", "Ins", ",", "DL", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "ISD::InputArg" ]

[]

[ "<s>", "void", "PTXInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printPredicate", "(", "MI", ",", "O", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "printInstruction", "(", "MI", ",", "O", ")", ";", "break", ";", "case", "PTX", "::", "CALL", ":", "printCall", "(", "MI", ",", "O", ")", ";", "}", "O", "<<", "\";\"", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX::CALL", "\";\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "XCoreTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "SELECT_CC", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "BRFT_lru6", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "transferSuccessors", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "F", "->", "DeleteMachineInstr", "(", "MI", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::SELECT_CC", "\"Unexpected instr type to insert\"", "XCore::BRFT_lru6", "1", "XCore::PHI", "0", "3", "2" ]

[]

[ "<s>", "void", "rs6000_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "before", ",", "rtx", "after", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL_RTX", ")", "before", "=", "scratch", ";", "emit_load_locked", "(", "mode", ",", "before", ",", "mem", ")", ";", "if", "(", "code", "==", "NOT", ")", "x", "=", "gen_rtx_AND", "(", "mode", ",", "gen_rtx_NOT", "(", "mode", ",", "before", ")", ",", "val", ")", ";", "else", "if", "(", "code", "==", "AND", ")", "x", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "before", ",", "val", ")", ",", "UNSPEC_AND", ")", ";", "else", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "if", "(", "after", "!=", "NULL_RTX", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "after", ",", "copy_rtx", "(", "x", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "scratch", ",", "x", ")", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "emit_insn", "(", "gen_isync", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "an", "atomic", "fetch-and-operate", "pattern", ".", "CODE", "is", "the", "binary", "operation", "to", "perform", ".", "MEM", "is", "the", "memory", "on", "which", "to", "operate", ".", "VAL", "is", "the", "second", "operand", "of", "the", "binary", "operator", ".", "BEFORE", "and", "AFTER", "are", "optional", "locations", "to", "return", "the", "value", "of", "MEM", "either", "before", "of", "after", "the", "operation", ".", "SCRATCH", "is", "a", "scratch", "register", "." ]

[ "rs6000", "2" ]

[]

[ "<s>", "static", "Mfix", "*", "create_fix_barrier", "(", "Mfix", "*", "fix", ",", "HOST_WIDE_INT", "max_address", ")", "{", "HOST_WIDE_INT", "count", "=", "0", ";", "rtx_barrier", "*", "barrier", ";", "rtx_insn", "*", "from", "=", "fix", "->", "insn", ";", "rtx_insn", "*", "selected", "=", "NULL", ";", "int", "selected_cost", ";", "HOST_WIDE_INT", "selected_address", ";", "Mfix", "*", "new_fix", ";", "HOST_WIDE_INT", "max_count", "=", "max_address", "-", "fix", "->", "address", ";", "rtx_code_label", "*", "label", "=", "gen_label_rtx", "(", ")", ";", "selected_cost", "=", "arm_barrier_cost", "(", "from", ")", ";", "selected_address", "=", "fix", "->", "address", ";", "while", "(", "from", "&&", "count", "<", "max_count", ")", "{", "rtx_jump_table_data", "*", "tmp", ";", "int", "new_cost", ";", "gcc_assert", "(", "!", "BARRIER_P", "(", "from", ")", ")", ";", "if", "(", "LABEL_P", "(", "from", ")", ")", "count", "+=", "get_label_padding", "(", "from", ")", ";", "else", "count", "+=", "get_attr_length", "(", "from", ")", ";", "if", "(", "tablejump_p", "(", "from", ",", "NULL", ",", "&", "tmp", ")", ")", "{", "count", "+=", "get_jump_table_size", "(", "tmp", ")", ";", "new_cost", "=", "arm_barrier_cost", "(", "from", ")", ";", "if", "(", "count", "<", "max_count", "&&", "(", "!", "selected", "||", "new_cost", "<=", "selected_cost", ")", ")", "{", "selected", "=", "tmp", ";", "selected_cost", "=", "new_cost", ";", "selected_address", "=", "fix", "->", "address", "+", "count", ";", "}", "from", "=", "NEXT_INSN", "(", "tmp", ")", ";", "continue", ";", "}", "new_cost", "=", "arm_barrier_cost", "(", "from", ")", ";", "if", "(", "count", "<", "max_count", "&&", "(", "!", "selected", "||", "new_cost", "<=", "selected_cost", ")", ")", "{", "selected", "=", "from", ";", "selected_cost", "=", "new_cost", ";", "selected_address", "=", "fix", "->", "address", "+", "count", ";", "}", "from", "=", "NEXT_INSN", "(", "from", ")", ";", "}", "gcc_assert", "(", "selected", ")", ";", "from", "=", "emit_jump_insn_after", "(", "gen_jump", "(", "label", ")", ",", "selected", ")", ";", "JUMP_LABEL", "(", "from", ")", "=", "label", ";", "barrier", "=", "emit_barrier_after", "(", "from", ")", ";", "emit_label_after", "(", "label", ",", "barrier", ")", ";", "new_fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "new_fix", ")", ")", ";", "new_fix", "->", "insn", "=", "barrier", ";", "new_fix", "->", "address", "=", "selected_address", ";", "new_fix", "->", "next", "=", "fix", "->", "next", ";", "fix", "->", "next", "=", "new_fix", ";", "return", "new_fix", ";", "}", "</s>" ]

[ "Find", "the", "best", "place", "in", "the", "insn", "stream", "in", "the", "range", "(", "FIX-", ">", "address", ",", "MAX_ADDRESS", ")", "to", "forcibly", "insert", "a", "minipool", "barrier", ".", "Create", "the", "barrier", "by", "inserting", "a", "jump", "and", "add", "a", "new", "fix", "entry", "for", "it", "." ]

[ "arm", "0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", "&&", "(", "Subtarget", "->", "hasNEON", "(", ")", "||", "isLegalMVEShuffleOp", "(", "PFEntry", ")", ")", ")", "return", "true", ";", "}", "bool", "ReverseVEXT", ",", "isV_UNDEF", ";", "unsigned", "Imm", ",", "WhichResult", ";", "unsigned", "EltSize", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "EltSize", ">=", "32", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "16", ")", ")", "return", "true", ";", "else", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "isVEXTMask", "(", "M", ",", "VT", ",", "ReverseVEXT", ",", "Imm", ")", "||", "isVTBLMask", "(", "M", ",", "VT", ")", "||", "isNEONTwoResultShuffleMask", "(", "M", ",", "VT", ",", "WhichResult", ",", "isV_UNDEF", ")", ")", ")", "return", "true", ";", "else", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", ")", "&&", "isReverseMask", "(", "M", ",", "VT", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "ARM", "ARM", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "32", "0", "64", "32", "16", "MVT::v8i16", "MVT::v16i8" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MEMCPY", ")", "{", "attachMEMCPYScratchRegs", "(", "Subtarget", ",", "MI", ",", "Node", ")", ";", "return", ";", "}", "const", "MCInstrDesc", "*", "MCID", "=", "&", "MI", ".", "getDesc", "(", ")", ";", "unsigned", "NewOpc", "=", "convertAddSubFlagsOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "NewOpc", ")", "{", "const", "ARMBaseInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MCID", "=", "&", "TII", "->", "get", "(", "NewOpc", ")", ";", "assert", "(", "MCID", "->", "getNumOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "+", "1", "&&", "\"converted opcode should be the same except for cc_out\"", ")", ";", "MI", ".", "setDesc", "(", "*", "MCID", ")", ";", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "0", ",", "true", ")", ")", ";", "}", "unsigned", "ccOutIdx", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "1", ";", "if", "(", "!", "MI", ".", "hasOptionalDef", "(", ")", "||", "!", "MCID", "->", "OpInfo", "[", "ccOutIdx", "]", ".", "isOptionalDef", "(", ")", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "bool", "definesCPSR", "=", "false", ";", "bool", "deadCPSR", "=", "false", ";", "for", "(", "unsigned", "i", "=", "MCID", "->", "getNumOperands", "(", ")", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", "{", "definesCPSR", "=", "true", ";", "if", "(", "MO", ".", "isDead", "(", ")", ")", "deadCPSR", "=", "true", ";", "MI", ".", "RemoveOperand", "(", "i", ")", ";", "break", ";", "}", "}", "if", "(", "!", "definesCPSR", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "assert", "(", "deadCPSR", "==", "!", "Node", "->", "hasAnyUseOfValue", "(", "1", ")", "&&", "\"inconsistent dead flag\"", ")", ";", "if", "(", "deadCPSR", ")", "{", "assert", "(", "!", "MI", ".", "getOperand", "(", "ccOutIdx", ")", ".", "getReg", "(", ")", "&&", "\"expect uninitialized optional cc_out operand\"", ")", ";", "return", ";", "}", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "ccOutIdx", ")", ";", "MO", ".", "setReg", "(", "ARM", "::", "CPSR", ")", ";", "MO", ".", "setIsDef", "(", "true", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::MEMCPY", "ARM", "1", "\"converted opcode should be the same except for cc_out\"", "0", "1", "\"Optional cc_out operand required\"", "ARM::CPSR", "\"Optional cc_out operand required\"", "1", "\"inconsistent dead flag\"", "\"expect uninitialized optional cc_out operand\"", "ARM::CPSR" ]

[]

[ "<s>", "int", "const_ok_for_op", "(", "HOST_WIDE_INT", "i", ",", "enum", "rtx_code", "code", ")", "{", "if", "(", "const_ok_for_arm", "(", "i", ")", ")", "return", "1", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "if", "(", "TARGET_HAVE_MOVT", "&&", "(", "i", "&", "0xffff0000", ")", "==", "0", ")", "return", "1", ";", "else", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "~", "i", ")", ")", ";", "case", "PLUS", ":", "if", "(", "TARGET_THUMB2", "&&", "(", "(", "i", "&", "0xfffff000", ")", "==", "0", "||", "(", "(", "-", "i", ")", "&", "0xfffff000", ")", "==", "0", ")", ")", "return", "1", ";", "case", "COMPARE", ":", "case", "EQ", ":", "case", "NE", ":", "case", "GT", ":", "case", "LE", ":", "case", "LT", ":", "case", "GE", ":", "case", "GEU", ":", "case", "LTU", ":", "case", "GTU", ":", "case", "LEU", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "case", "UNEQ", ":", "case", "UNGE", ":", "case", "UNLT", ":", "case", "UNGT", ":", "case", "UNLE", ":", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "-", "i", ")", ")", ";", "case", "MINUS", ":", "case", "XOR", ":", "return", "0", ";", "case", "IOR", ":", "if", "(", "TARGET_THUMB2", ")", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "~", "i", ")", ")", ";", "return", "0", ";", "case", "AND", ":", "return", "const_ok_for_arm", "(", "ARM_SIGN_EXTEND", "(", "~", "i", ")", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "I", "is", "a", "valid", "constant", "for", "the", "operation", "CODE", "." ]

[ "arm", "1", "0xffff0000", "0", "1", "0xfffff000", "0", "0xfffff000", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "nds32_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "machine", "->", "naked_p", "=", "0", ";", "machine", "->", "fp_as_gp_p", "=", "0", ";", "return", "machine", ";", "}", "</s>" ]

[ "Function", "to", "save", "and", "restore", "machine-specific", "function", "data", "." ]

[ "nds32", "0", "0" ]

[]

[ "<s>", "static", "void", "tilepro_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "POST_DEC", "||", "GET_CODE", "(", "addr", ")", "==", "POST_INC", ")", "{", "int", "offset", "=", "GET_MODE_SIZE", "(", "output_memory_reference_mode", ")", ";", "gcc_assert", "(", "output_memory_reference_mode", "!=", "VOIDmode", ")", ";", "if", "(", "output_memory_autoinc_first", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%d\"", ",", "GET_CODE", "(", "addr", ")", "==", "POST_DEC", "?", "-", "offset", ":", "offset", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "POST_MODIFY", ")", "{", "gcc_assert", "(", "output_memory_reference_mode", "!=", "VOIDmode", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "PLUS", ")", ";", "if", "(", "output_memory_autoinc_first", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "1", ")", ")", ")", ";", "}", "else", "tilepro_print_operand", "(", "file", ",", "addr", ",", "'r'", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "tilepro", "\"%s\"", "0", "\"%d\"", "1", "\"%s\"", "0", "1", "1" ]

[]

[ "<s>", "void", "arm_declare_function_name", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "tree", "decl", ")", "{", "tree", "target_parts", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "decl", ")", ";", "struct", "cl_target_option", "*", "targ_options", ";", "if", "(", "target_parts", ")", "targ_options", "=", "TREE_TARGET_OPTION", "(", "target_parts", ")", ";", "else", "targ_options", "=", "TREE_TARGET_OPTION", "(", "target_option_current_node", ")", ";", "gcc_assert", "(", "targ_options", ")", ";", "arm_print_asm_arch_directives", "(", "stream", ",", "targ_options", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.syntax unified\\n\"", ")", ";", "if", "(", "TARGET_THUMB", ")", "{", "if", "(", "is_called_in_ARM_mode", "(", "decl", ")", "||", "(", "TARGET_THUMB1", "&&", "!", "TARGET_THUMB1_ONLY", "&&", "cfun", "->", "is_thunk", ")", ")", "fprintf", "(", "stream", ",", "\"\\t.code 32\\n\"", ")", ";", "else", "if", "(", "TARGET_THUMB1", ")", "fprintf", "(", "stream", ",", "\"\\t.code\\t16\\n\\t.thumb_func\\n\"", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\t.thumb\\n\\t.thumb_func\\n\"", ")", ";", "}", "else", "fprintf", "(", "stream", ",", "\"\\t.arm\\n\"", ")", ";", "if", "(", "TARGET_POKE_FUNCTION_NAME", ")", "arm_poke_function_name", "(", "stream", ",", "(", "const", "char", "*", ")", "name", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_DECLARE_FUNCTION_NAME", ".", "Output", "the", "ISA", "features", "used", "by", "the", "function", "fndecl", "." ]

[ "arm", "\"\\t.syntax unified\\n\"", "\"\\t.code 32\\n\"", "\"\\t.code\\t16\\n\\t.thumb_func\\n\"", "\"\\t.thumb\\n\\t.thumb_func\\n\"", "\"\\t.arm\\n\"" ]

[]

[ "<s>", "TargetPassConfig", "*", "PTXTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "PTXPassConfig", "*", "PassConfig", "=", "new", "PTXPassConfig", "(", "this", ",", "PM", ")", ";", "PassConfig", "->", "disablePass", "(", "PrologEpilogCodeInserterID", ")", ";", "return", "PassConfig", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX", "PTX" ]

[]

[ "<s>", "void", "M680x0InstrInfo", "::", "AddSExt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "Reg", ",", "MVT", "From", ",", "MVT", "To", ")", "const", "{", "if", "(", "From", "==", "MVT", "::", "i8", ")", "{", "unsigned", "R", "=", "Reg", ";", "if", "(", "To", "==", "MVT", "::", "i32", ")", "{", "R", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "M680x0", "::", "MxSubRegIndex16Lo", ")", ";", "assert", "(", "R", "&&", "\"No viable SUB register available\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M680x0", "::", "EXT16", ")", ",", "R", ")", ".", "addReg", "(", "R", ")", ";", "}", "if", "(", "To", "==", "MVT", "::", "i32", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M680x0", "::", "EXT32", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Add", "appropriate", "SExt", "nodes", "." ]

[ "M680x0", "M680x0", "MVT::i8", "MVT::i32", "M680x0::MxSubRegIndex16Lo", "\"No viable SUB register available\"", "M680x0::EXT16", "MVT::i32", "M680x0::EXT32" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "FastISel", "*", "MipsTargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "const", "{", "if", "(", "!", "EnableMipsFastISel", ")", "return", "TargetLowering", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "return", "Mips", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "Mips", "Mips", "Mips", "Mips::createFastISel" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI prepare scratch registers\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI prepare scratch registers\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "PIC16AsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "O", "<<", "\"\\t#include P16F1937.INC\\n\"", ";", "EmitExternsAndGlobals", "(", "M", ")", ";", "EmitInitData", "(", "M", ")", ";", "EmitUnInitData", "(", "M", ")", ";", "EmitRomData", "(", "M", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "PIC16", "PIC16", "\"\\t#include P16F1937.INC\\n\"" ]

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getMaxValue", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "unsigned", "isSigned", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "unsigned", "bits", "=", "(", "F", ">>", "HexagonII", "::", "ExtentBitsPos", ")", "&", "HexagonII", "::", "ExtentBitsMask", ";", "if", "(", "isSigned", ")", "return", "~", "(", "-", "1", "<<", "(", "bits", "-", "1", ")", ")", ";", "else", "return", "~", "(", "-", "1", "<<", "bits", ")", ";", "}", "</s>" ]

[ "Return", "the", "maximal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "HexagonII::ExtentBitsPos", "HexagonII::ExtentBitsMask", "1", "1", "1" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "Register", "DstReg", ",", "Register", "TrueReg", ",", "Register", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "switch", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "case", "VCCNZ", ":", "case", "VCCZ", ":", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FalseReg", ")", "!=", "RC", ")", "return", "false", ";", "int", "NumInsts", "=", "AMDGPU", "::", "getRegBitWidth", "(", "RC", "->", "getID", "(", ")", ")", "/", "32", ";", "CondCycles", "=", "TrueCycles", "=", "FalseCycles", "=", "NumInsts", ";", "return", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "NumInsts", "<=", "6", ";", "}", "case", "SCC_TRUE", ":", "case", "SCC_FALSE", ":", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FalseReg", ")", "!=", "RC", ")", "return", "false", ";", "int", "NumInsts", "=", "AMDGPU", "::", "getRegBitWidth", "(", "RC", "->", "getID", "(", ")", ")", "/", "32", ";", "if", "(", "NumInsts", "%", "2", "==", "0", ")", "NumInsts", "/=", "2", ";", "CondCycles", "=", "TrueCycles", "=", "FalseCycles", "=", "NumInsts", ";", "return", "RI", ".", "isSGPRClass", "(", "RC", ")", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "AMDGPU", "SI", "0", "AMDGPU::getRegBitWidth", "32", "6", "AMDGPU::getRegBitWidth", "32", "2", "0", "2" ]

[]

[ "<s>", "bool", "offset_ok_for_ldrd_strd", "(", "HOST_WIDE_INT", "offset", ")", "{", "HOST_WIDE_INT", "max_offset", ";", "if", "(", "TARGET_THUMB2", "&&", "(", "(", "offset", "&", "3", ")", "!=", "0", ")", ")", "return", "false", ";", "if", "(", "TARGET_THUMB2", ")", "max_offset", "=", "1020", ";", "else", "if", "(", "TARGET_ARM", ")", "max_offset", "=", "255", ";", "else", "return", "false", ";", "return", "(", "(", "offset", "<=", "max_offset", ")", "&&", "(", "offset", ">=", "-", "max_offset", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "OFFSET", "is", "valid", "for", "use", "in", "an", "LDRD/STRD", "instruction", ",", "assuming", "that", "the", "address", "in", "the", "base", "register", "is", "word", "aligned", "." ]

[ "arm", "3", "0", "1020", "255" ]

[]

[ "<s>", "rtx", "bfin_return_addr_rtx", "(", "int", "count", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "REG_RETS", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "of", "the", "return", "address", "for", "the", "frame", "COUNT", "steps", "up", "from", "the", "current", "frame", ",", "after", "the", "prologue", ".", "We", "punt", "for", "everything", "but", "the", "current", "frame", "by", "returning", "const0_rtx", "." ]

[ "bfin", "0" ]

[]

[ "<s>", "unsigned", "getCallingConv", "(", ")", "const", "{", "return", "CallingConv", ";", "}", "</s>" ]

[ "Return", "the", "calling", "convention", "." ]

[ "Hexagon" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "AArch64", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"sp\"", "AArch64::SP", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "emitStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "bool", "InProlog", ",", "Optional", "<", "MachineFunction", "::", "DebugInstrOperandPair", ">", "InstrNum", ")", "const", "{", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isTargetWindowsCoreCLR", "(", ")", ")", "{", "if", "(", "InProlog", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "STACKALLOC_W_PROBING", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "emitStackProbeInline", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "false", ")", ";", "}", "}", "else", "{", "emitStackProbeCall", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "InProlog", ",", "InstrNum", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86::STACKALLOC_W_PROBING", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

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

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

[ "LoongArch" ]

[]

[ "<s>", "void", "TeakPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createTeakOptimizeMovImmPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "Teak" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "isHardwareLoopProfitable", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "AssumptionCache", "&", "AC", ",", "TargetLibraryInfo", "*", "LibInfo", ",", "TTI", "::", "HardwareLoopInfo", "&", "HWLoopInfo", ")", "{", "const", "PPCTargetMachine", "&", "TM", "=", "ST", "->", "getTargetMachine", "(", ")", ";", "TargetSchedModel", "SchedModel", ";", "SchedModel", ".", "init", "(", "ST", ")", ";", "unsigned", "ConstTripCount", "=", "SE", ".", "getSmallConstantTripCount", "(", "L", ")", ";", "if", "(", "ConstTripCount", "&&", "ConstTripCount", "<", "SmallCTRLoopThreshold", ")", "{", "SmallPtrSet", "<", "const", "Value", "*", ",", "32", ">", "EphValues", ";", "CodeMetrics", "::", "collectEphemeralValues", "(", "L", ",", "&", "AC", ",", "EphValues", ")", ";", "CodeMetrics", "Metrics", ";", "for", "(", "BasicBlock", "*", "BB", ":", "L", "->", "blocks", "(", ")", ")", "Metrics", ".", "analyzeBasicBlock", "(", "BB", ",", "*", "this", ",", "EphValues", ")", ";", "if", "(", "Metrics", ".", "NumInsts", "<=", "(", "6", "*", "SchedModel", ".", "getIssueWidth", "(", ")", ")", ")", "return", "false", ";", "}", "for", "(", "Loop", "::", "block_iterator", "I", "=", "L", "->", "block_begin", "(", ")", ",", "IE", "=", "L", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "if", "(", "mightUseCTR", "(", "*", "I", ",", "LibInfo", ")", ")", "return", "false", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "for", "(", "auto", "&", "BB", ":", "ExitingBlocks", ")", "{", "Instruction", "*", "TI", "=", "BB", "->", "getTerminator", "(", ")", ";", "if", "(", "!", "TI", ")", "continue", ";", "if", "(", "BranchInst", "*", "BI", "=", "dyn_cast", "<", "BranchInst", ">", "(", "TI", ")", ")", "{", "uint64_t", "TrueWeight", "=", "0", ",", "FalseWeight", "=", "0", ";", "if", "(", "!", "BI", "->", "isConditional", "(", ")", "||", "!", "BI", "->", "extractProfMetadata", "(", "TrueWeight", ",", "FalseWeight", ")", ")", "continue", ";", "bool", "TrueIsExit", "=", "!", "L", "->", "contains", "(", "BI", "->", "getSuccessor", "(", "0", ")", ")", ";", "if", "(", "(", "TrueIsExit", "&&", "FalseWeight", "<", "TrueWeight", ")", "||", "(", "!", "TrueIsExit", "&&", "FalseWeight", ">", "TrueWeight", ")", ")", "return", "false", ";", "}", "}", "LLVMContext", "&", "C", "=", "L", "->", "getHeader", "(", ")", "->", "getContext", "(", ")", ";", "HWLoopInfo", ".", "CountType", "=", "TM", ".", "isPPC64", "(", ")", "?", "Type", "::", "getInt64Ty", "(", "C", ")", ":", "Type", "::", "getInt32Ty", "(", "C", ")", ";", "HWLoopInfo", ".", "LoopDecrement", "=", "ConstantInt", "::", "get", "(", "HWLoopInfo", ".", "CountType", ",", "1", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Query", "the", "target", "whether", "it", "would", "be", "profitable", "to", "convert", "the", "given", "loop", "into", "a", "hardware", "loop", "." ]

[ "PowerPC", "PPC", "PPC", "32", "6", "4", "0", "0", "0", "PPC", "1" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "static", "rtx", "rs6000_pre_atomic_barrier", "(", "rtx", "mem", ",", "enum", "memmodel", "model", ")", "{", "rtx", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "int", "strict_p", "=", "(", "reload_in_progress", "||", "reload_completed", ")", ";", "if", "(", "!", "legitimate_indirect_address_p", "(", "addr", ",", "strict_p", ")", "&&", "!", "legitimate_indexed_address_p", "(", "addr", ",", "strict_p", ")", ")", "{", "addr", "=", "force_reg", "(", "Pmode", ",", "addr", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "addr", ")", ";", "}", "switch", "(", "model", ")", "{", "case", "MEMMODEL_RELAXED", ":", "case", "MEMMODEL_CONSUME", ":", "case", "MEMMODEL_ACQUIRE", ":", "break", ";", "case", "MEMMODEL_RELEASE", ":", "case", "MEMMODEL_ACQ_REL", ":", "emit_insn", "(", "gen_lwsync", "(", ")", ")", ";", "break", ";", "case", "MEMMODEL_SEQ_CST", ":", "emit_insn", "(", "gen_hwsync", "(", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "mem", ";", "}", "</s>" ]

[ "Expand", "barriers", "before", "and", "after", "a", "load_locked/store_cond", "sequence", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "HexagonGenMux", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "MF", ")", "Changed", "|=", "genMuxInBlock", "(", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "tree", "altivec_resolve_overloaded_builtin", "(", "tree", "fndecl", ",", "tree", "arglist", ")", "{", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "fnargs", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "tree", "types", "[", "3", "]", ",", "args", "[", "3", "]", ";", "const", "struct", "altivec_builtin_types", "*", "desc", ";", "int", "n", ";", "if", "(", "fcode", "<", "ALTIVEC_BUILTIN_OVERLOADED_FIRST", "||", "fcode", ">", "ALTIVEC_BUILTIN_OVERLOADED_LAST", ")", "return", "NULL_TREE", ";", "for", "(", "n", "=", "0", ";", "!", "VOID_TYPE_P", "(", "TREE_VALUE", "(", "fnargs", ")", ")", "&&", "arglist", ";", "fnargs", "=", "TREE_CHAIN", "(", "fnargs", ")", ",", "arglist", "=", "TREE_CHAIN", "(", "arglist", ")", ",", "n", "++", ")", "{", "tree", "decl_type", "=", "TREE_VALUE", "(", "fnargs", ")", ";", "tree", "arg", "=", "TREE_VALUE", "(", "arglist", ")", ";", "tree", "type", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "error_mark_node", ";", "if", "(", "n", ">=", "3", ")", "abort", "(", ")", ";", "arg", "=", "default_conversion", "(", "arg", ")", ";", "type", "=", "TREE_TYPE", "(", "arg", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "type", ")", "&&", "TREE_CODE", "(", "arg", ")", "==", "NOP_EXPR", "&&", "lang_hooks", ".", "types_compatible_p", "(", "TREE_TYPE", "(", "arg", ")", ",", "const_ptr_type_node", ")", "&&", "lang_hooks", ".", "types_compatible_p", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "arg", ",", "0", ")", ")", ",", "ptr_type_node", ")", ")", "{", "arg", "=", "TREE_OPERAND", "(", "arg", ",", "0", ")", ";", "type", "=", "TREE_TYPE", "(", "arg", ")", ";", "}", "if", "(", "POINTER_TYPE_P", "(", "decl_type", ")", "&&", "POINTER_TYPE_P", "(", "type", ")", "&&", "TYPE_QUALS", "(", "TREE_TYPE", "(", "type", ")", ")", "!=", "0", ")", "{", "if", "(", "TYPE_READONLY", "(", "TREE_TYPE", "(", "type", ")", ")", "&&", "!", "TYPE_READONLY", "(", "TREE_TYPE", "(", "decl_type", ")", ")", ")", "warning", "(", "0", ",", "\"passing arg %d of %qE discards qualifiers from\"", "\"pointer target type\"", ",", "n", "+", "1", ",", "fndecl", ")", ";", "type", "=", "build_pointer_type", "(", "build_qualified_type", "(", "TREE_TYPE", "(", "type", ")", ",", "0", ")", ")", ";", "arg", "=", "fold_convert", "(", "type", ",", "arg", ")", ";", "}", "args", "[", "n", "]", "=", "arg", ";", "types", "[", "n", "]", "=", "type", ";", "}", "if", "(", "!", "VOID_TYPE_P", "(", "TREE_VALUE", "(", "fnargs", ")", ")", "||", "arglist", ")", "return", "NULL", ";", "if", "(", "n", "==", "0", ")", "abort", "(", ")", ";", "if", "(", "fcode", "==", "ALTIVEC_BUILTIN_VEC_STEP", ")", "{", "if", "(", "TREE_CODE", "(", "types", "[", "0", "]", ")", "!=", "VECTOR_TYPE", ")", "goto", "bad", ";", "return", "build_int_cst", "(", "NULL_TREE", ",", "TYPE_VECTOR_SUBPARTS", "(", "types", "[", "0", "]", ")", ")", ";", "}", "for", "(", "desc", "=", "altivec_overloaded_builtins", ";", "desc", "->", "code", "&&", "desc", "->", "code", "!=", "fcode", ";", "desc", "++", ")", "continue", ";", "for", "(", ";", "desc", "->", "code", "==", "fcode", ";", "desc", "++", ")", "if", "(", "(", "desc", "->", "op1", "==", "RS6000_BTI_NOT_OPAQUE", "||", "rs6000_builtin_type_compatible", "(", "types", "[", "0", "]", ",", "desc", "->", "op1", ")", ")", "&&", "(", "desc", "->", "op2", "==", "RS6000_BTI_NOT_OPAQUE", "||", "rs6000_builtin_type_compatible", "(", "types", "[", "1", "]", ",", "desc", "->", "op2", ")", ")", "&&", "(", "desc", "->", "op3", "==", "RS6000_BTI_NOT_OPAQUE", "||", "rs6000_builtin_type_compatible", "(", "types", "[", "2", "]", ",", "desc", "->", "op3", ")", ")", ")", "return", "altivec_build_resolved_builtin", "(", "args", ",", "n", ",", "desc", ")", ";", "bad", ":", "error", "(", "\"invalid parameter combination for AltiVec intrinsic\"", ")", ";", "return", "error_mark_node", ";", "}", "</s>" ]

[ "Implementation", "of", "the", "resolve_overloaded_builtin", "target", "hook", ",", "to", "support", "Altivec", "'s", "overloaded", "builtins", "." ]

[ "rs6000", "3", "3", "0", "3", "0", "0", "0", "0", "\"passing arg %d of %qE discards qualifiers from\"", "\"pointer target type\"", "1", "0", "0", "0", "0", "0", "1", "2", "\"invalid parameter combination for AltiVec intrinsic\"" ]

[]

[ "<s>", "void", "MCS51InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "MCS51Subtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "const", "MCS51RegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "Opc", ";", "if", "(", "MCS51", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "STI", ".", "hasMOVW", "(", ")", "&&", "MCS51", "::", "DREGSMOVWRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MCS51", "::", "MOVWRdRr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "Register", "DestLo", ",", "DestHi", ",", "SrcLo", ",", "SrcHi", ";", "TRI", ".", "splitReg", "(", "DestReg", ",", "DestLo", ",", "DestHi", ")", ";", "TRI", ".", "splitReg", "(", "SrcReg", ",", "SrcLo", ",", "SrcHi", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MCS51", "::", "MOVRdRr", ")", ",", "DestLo", ")", ".", "addReg", "(", "SrcLo", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MCS51", "::", "MOVRdRr", ")", ",", "DestHi", ")", ".", "addReg", "(", "SrcHi", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "else", "{", "if", "(", "MCS51", "::", "GPR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "MCS51", "::", "MOVRdRr", ";", "}", "else", "if", "(", "SrcReg", "==", "MCS51", "::", "SP", "&&", "MCS51", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "Opc", "=", "MCS51", "::", "SPREAD", ";", "}", "else", "if", "(", "DestReg", "==", "MCS51", "::", "SP", "&&", "MCS51", "::", "DREGSRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "Opc", "=", "MCS51", "::", "SPWRITE", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51", "MCS51", "MCS51::DREGSRegClass", "MCS51::DREGSMOVWRegClass", "MCS51::MOVWRdRr", "MCS51::MOVRdRr", "MCS51::MOVRdRr", "MCS51::GPR8RegClass", "MCS51::MOVRdRr", "MCS51::SP", "MCS51::DREGSRegClass", "MCS51::SPREAD", "MCS51::SP", "MCS51::DREGSRegClass", "MCS51::SPWRITE", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "bool", "aarch64_sve_inc_dec_immediate_p", "(", "rtx", "x", ")", "{", "return", "aarch64_sve_inc_dec_immediate_p", "(", "x", ",", "NULL", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "for", "an", "SVE", "vector", "INC", "or", "DEC", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8mr", ":", "case", "X86", "::", "MOV16mr", ":", "case", "X86", "::", "MOV16_mr", ":", "case", "X86", "::", "MOV32mr", ":", "case", "X86", "::", "MOV32_mr", ":", "case", "X86", "::", "MOV64mr", ":", "case", "X86", "::", "ST_FpP64m", ":", "case", "X86", "::", "MOVSSmr", ":", "case", "X86", "::", "MOVSDmr", ":", "case", "X86", "::", "MOVAPSmr", ":", "case", "X86", "::", "MOVAPDmr", ":", "case", "X86", "::", "MOVDQAmr", ":", "case", "X86", "::", "MMX_MOVD64mr", ":", "case", "X86", "::", "MMX_MOVQ64mr", ":", "case", "X86", "::", "MMX_MOVNTQmr", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "1", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "4", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::MOV8mr", "X86::MOV16mr", "X86::MOV16_mr", "X86::MOV32mr", "X86::MOV32_mr", "X86::MOV64mr", "X86::ST_FpP64m", "X86::MOVSSmr", "X86::MOVSDmr", "X86::MOVAPSmr", "X86::MOVAPDmr", "X86::MOVDQAmr", "X86::MMX_MOVD64mr", "X86::MMX_MOVQ64mr", "X86::MMX_MOVNTQmr", "0", "1", "2", "3", "1", "1", "2", "0", "3", "0", "0", "4", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "csky_function_arg", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "reg", "=", "pcum", "->", "reg", ";", "machine_mode", "mode", "=", "arg", ".", "mode", ";", "if", "(", "FUNCTION_VARG_MODE_P", "(", "mode", ")", "&&", "!", "pcum", "->", "is_stdarg", ")", "{", "reg", "=", "pcum", "->", "freg", ";", "if", "(", "reg", "<", "CSKY_NPARM_FREGS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "CSKY_FIRST_VFP_REGNUM", "+", "reg", ")", ";", "else", "return", "NULL_RTX", ";", "}", "if", "(", "reg", "<", "CSKY_NPARM_REGS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "CSKY_FIRST_PARM_REGNUM", "+", "reg", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

[ "csky" ]

[]

[ "<s>", "bool", "SILowerSGPRSpills", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "assert", "(", "SaveBlocks", ".", "empty", "(", ")", "&&", "RestoreBlocks", ".", "empty", "(", ")", ")", ";", "calculateSaveRestoreBlocks", "(", "MF", ")", ";", "bool", "HasCSRs", "=", "spillCalleeSavedRegs", "(", "MF", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", "&&", "!", "HasCSRs", ")", "{", "SaveBlocks", ".", "clear", "(", ")", ";", "RestoreBlocks", ".", "clear", "(", ")", ";", "if", "(", "FuncInfo", "->", "VGPRReservedForSGPRSpill", ")", "{", "FuncInfo", "->", "removeVGPRForSGPRSpill", "(", "FuncInfo", "->", "VGPRReservedForSGPRSpill", ",", "MF", ")", ";", "MRI", ".", "freezeReservedRegs", "(", "MF", ")", ";", "}", "return", "false", ";", "}", "bool", "MadeChange", "=", "false", ";", "bool", "NewReservedRegs", "=", "false", ";", "const", "bool", "HasSGPRSpillToVGPR", "=", "TRI", "->", "spillSGPRToVGPR", "(", ")", "&&", "(", "HasCSRs", "||", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", ";", "if", "(", "HasSGPRSpillToVGPR", ")", "{", "lowerShiftReservedVGPR", "(", "MF", ",", "ST", ")", ";", "BitVector", "SpillFIs", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ",", "false", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_early_inc_range", "(", "MBB", ")", ")", "{", "if", "(", "!", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "continue", ";", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "NewReservedRegs", "=", "true", ";", "bool", "Spilled", "=", "TRI", "->", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "nullptr", ",", "LIS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "\"failed to spill SGPR to VGPR when allocated\"", ")", ";", "SpillFIs", ".", "set", "(", "FI", ")", ";", "}", "}", "}", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "SSpill", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "SSpill", ".", "VGPR", ")", ";", "MBB", ".", "sortUniqueLiveIns", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "SpillFIs", "[", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", "]", ")", "{", "MI", ".", "getOperand", "(", "0", ")", ".", "ChangeToRegister", "(", "Register", "(", ")", ",", "false", ")", ";", "}", "}", "}", "FuncInfo", "->", "removeDeadFrameIndices", "(", "MFI", ")", ";", "MadeChange", "=", "true", ";", "}", "else", "if", "(", "FuncInfo", "->", "VGPRReservedForSGPRSpill", ")", "{", "FuncInfo", "->", "removeVGPRForSGPRSpill", "(", "FuncInfo", "->", "VGPRReservedForSGPRSpill", ",", "MF", ")", ";", "}", "SaveBlocks", ".", "clear", "(", ")", ";", "RestoreBlocks", ".", "clear", "(", ")", ";", "if", "(", "NewReservedRegs", ")", "MRI", ".", "freezeReservedRegs", "(", "MF", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::OpName", "\"failed to spill SGPR to VGPR when allocated\"", "0", "0", "0" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "RC", "==", "&", "Hexagon", "::", "IntRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Hexagon", "::", "PredRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::L2_loadri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::L2_loadrd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::LDriw_pred", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "void", "avr_file_end", "(", "void", ")", "{", "fputs", "(", "\"/* File \"", ",", "asm_out_file", ")", ";", "output_quoted_string", "(", "asm_out_file", ",", "main_input_filename", ")", ";", "fprintf", "(", "asm_out_file", ",", "\": code %4d = 0x%04x (%4d), prologues %3d, epilogues %3d */\\n\"", ",", "commands_in_file", ",", "commands_in_file", ",", "commands_in_file", "-", "commands_in_prologues", "-", "commands_in_epilogues", ",", "commands_in_prologues", ",", "commands_in_epilogues", ")", ";", "}", "</s>" ]

[ "Outputs", "to", "the", "stdio", "stream", "FILE", "some", "appropriate", "text", "to", "go", "at", "the", "end", "of", "an", "assembler", "file", "." ]

[ "avr", "\"/* File \"", "\": code %4d = 0x%04x (%4d), prologues %3d, epilogues %3d */\\n\"" ]

[]

[ "<s>", "static", "void", "rs6000_do_expand_vec_perm", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "vmode", ",", "unsigned", "nelt", ",", "rtx", "perm", "[", "]", ")", "{", "machine_mode", "imode", ";", "rtx", "x", ";", "imode", "=", "vmode", ";", "if", "(", "GET_MODE_CLASS", "(", "vmode", ")", "!=", "MODE_VECTOR_INT", ")", "{", "imode", "=", "GET_MODE_INNER", "(", "vmode", ")", ";", "imode", "=", "mode_for_size", "(", "GET_MODE_BITSIZE", "(", "imode", ")", ",", "MODE_INT", ",", "0", ")", ";", "imode", "=", "mode_for_vector", "(", "imode", ",", "nelt", ")", ";", "}", "x", "=", "gen_rtx_CONST_VECTOR", "(", "imode", ",", "gen_rtvec_v", "(", "nelt", ",", "perm", ")", ")", ";", "x", "=", "expand_vec_perm", "(", "vmode", ",", "op0", ",", "op1", ",", "x", ",", "target", ")", ";", "if", "(", "x", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "x", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "for", "rs6000_expand_extract_even", "&", "rs6000_expand_interleave", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "MMI", "->", "AnalyzeModule", "(", "M", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "emitHeader", "(", "M", ",", "OS1", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "!", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "AddComment", "(", "\"Start of file scope inline assembly\"", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "M", ".", "getModuleInlineAsm", "(", ")", ")", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "OutStreamer", ".", "AddComment", "(", "\"End of file scope inline assembly\"", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "GlobalsEmitted", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "NVPTX", "NVPTX", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"", "NVPTX::CUDA" ]

[]

[ "<s>", "void", "GCNIterativeScheduler", "::", "finalizeSchedule", "(", ")", "{", "if", "(", "Regions", ".", "empty", "(", ")", ")", "return", ";", "switch", "(", "Strategy", ")", "{", "case", "SCHEDULE_MINREGONLY", ":", "scheduleMinReg", "(", ")", ";", "break", ";", "case", "SCHEDULE_MINREGFORCED", ":", "scheduleMinReg", "(", "true", ")", ";", "break", ";", "case", "SCHEDULE_LEGACYMAXOCCUPANCY", ":", "scheduleLegacyMaxOccupancy", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "After", "the", "schedule", "has", "been", "formed", ",", "call", "this", "function", "to", "combine", "the", "instructions", "from", "the", "different", "stages/cycles", "." ]

[ "AMDGPU" ]

[]

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

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

[ "Xtensa", "Xtensa" ]

[]

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

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

[ "RI5CY" ]

[]

[ "<s>", "void", "XtensaFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "{", "return", ";", "}", "llvm_unreachable", "(", "\"Couldn't reach here\"", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Xtensa", "Xtensa", "\"Couldn't reach here\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM64 branch relaxation pass\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 branch relaxation pass\"" ]

[]

[ "<s>", "char", "*", "xstormy16_output_cbranch_si", "(", "rtx", "op", ",", "const", "char", "*", "label", ",", "int", "reversed", ",", "rtx", "insn", ")", "{", "static", "char", "string", "[", "64", "]", ";", "int", "need_longbranch", "=", "get_attr_length", "(", "insn", ")", ">=", "8", ";", "int", "really_reversed", "=", "reversed", "^", "need_longbranch", ";", "const", "char", "*", "ccode", ";", "const", "char", "*", "template", ";", "char", "prevop", "[", "16", "]", ";", "enum", "rtx_code", "code", ";", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "really_reversed", ")", "code", "=", "reverse_condition", "(", "code", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "ccode", "=", "\"z\"", ";", "break", ";", "case", "NE", ":", "ccode", "=", "\"nz\"", ";", "break", ";", "case", "GE", ":", "ccode", "=", "\"ge\"", ";", "break", ";", "case", "LT", ":", "ccode", "=", "\"lt\"", ";", "break", ";", "case", "GEU", ":", "ccode", "=", "\"nc\"", ";", "break", ";", "case", "LTU", ":", "ccode", "=", "\"c\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "{", "int", "regnum", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "REG", ")", ";", "regnum", "=", "REGNO", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "sprintf", "(", "prevop", ",", "\"or %s,%s\"", ",", "reg_names", "[", "regnum", "]", ",", "reg_names", "[", "regnum", "+", "1", "]", ")", ";", "}", "break", ";", "case", "GE", ":", "case", "LT", ":", "case", "GEU", ":", "case", "LTU", ":", "strcpy", "(", "prevop", ",", "\"sbc %2,%3\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "need_longbranch", ")", "template", "=", "\"%s | b%s .+6 | jmpf %s\"", ";", "else", "template", "=", "\"%s | b%s %s\"", ";", "sprintf", "(", "string", ",", "template", ",", "prevop", ",", "ccode", ",", "label", ")", ";", "return", "string", ";", "}", "</s>" ]

[ "Return", "the", "string", "to", "output", "a", "conditional", "branch", "to", "LABEL", ",", "which", "is", "the", "operand", "number", "of", "the", "label", ",", "but", "suitable", "for", "the", "tail", "of", "a", "SImode", "branch", ".", "OP", "is", "the", "conditional", "expression", "(", "OP", "is", "never", "NULL_RTX", ")", ".", "REVERSED", "is", "non-zero", "if", "we", "should", "reverse", "the", "sense", "of", "the", "comparison", ".", "INSN", "is", "the", "insn", "." ]

[ "stormy16", "64", "8", "16", "\"z\"", "\"nz\"", "\"ge\"", "\"lt\"", "\"nc\"", "\"c\"", "0", "0", "\"or %s,%s\"", "1", "\"sbc %2,%3\"", "\"%s | b%s .+6 | jmpf %s\"", "\"%s | b%s %s\"" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "int", "FPOffset", "=", "MipsFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MipsFI", "->", "getRAStackOffset", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "LW", ")", ",", "Mips", "::", "FP", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "LW", ")", ",", "Mips", "::", "RA", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "if", "(", "NumBytes", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::ADDu", "Mips::SP", "Mips::FP", "Mips::ZERO", "Mips::LW", "Mips::FP", "Mips::SP", "Mips::LW", "Mips::RA", "Mips::SP", "Mips::ADDiu", "Mips::SP", "Mips::SP" ]

[]

[ "<s>", "static", "void", "arm32_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "this_regno", "=", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", "?", "R1_REGNUM", ":", "R0_REGNUM", ")", ";", "rtx", "temp", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP_REGNUM", ")", ";", "rtx", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "this_regno", ")", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "delta", "!=", "0", ")", "arm_split_constant", "(", "PLUS", ",", "Pmode", ",", "NULL_RTX", ",", "delta", ",", "this_rtx", ",", "this_rtx", ",", "false", ")", ";", "if", "(", "vcall_offset", "!=", "0", ")", "{", "emit_move_insn", "(", "temp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "arm_split_constant", "(", "PLUS", ",", "Pmode", ",", "NULL_RTX", ",", "vcall_offset", ",", "temp", ",", "temp", ",", "false", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "temp", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "temp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "rtx", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "rtx_insn", "*", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ",", "NULL_RTX", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "MI", "thunk", "handling", "for", "TARGET_32BIT", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SIFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "MBB", ".", "erase", "(", "I", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "Align", ")", ";", "assert", "(", "isUInt", "<", "32", ">", "(", "Amount", ")", "&&", "\"exceeded stack address space size\"", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "SPReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "unsigned", "Op", "=", "IsDestroy", "?", "AMDGPU", "::", "S_SUB_U32", ":", "AMDGPU", "::", "S_ADD_U32", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Amount", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ";", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "llvm_unreachable", "(", "\"is this used?\"", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "0", "SI", "1", "0", "32", "\"exceeded stack address space size\"", "SI", "SI", "AMDGPU::S_SUB_U32", "AMDGPU::S_ADD_U32", "0", "\"is this used?\"" ]

[]

[ "<s>", "unsigned", "SparcRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "SP", "::", "I7", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "Sparc", "Sparc", "SP::I7" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "I", ")", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "TII", ".", "getFrameAdjustment", "(", "*", "I", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "auto", "InsertPos", "=", "skipDebugInstructionsForward", "(", "I", ",", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "isDestroy", "&&", "blockEndIsUnreachable", "(", "MBB", ",", "I", ")", ")", "return", "I", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "MF", ".", "needsFrameMoves", "(", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "if", "(", "!", "(", "F", ".", "hasMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDNode", "*", "Cpu0DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "MF", "->", "getInfo", "<", "Cpu0FunctionInfo", ">", "(", ")", "->", "getGlobalBaseReg", "(", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "rtx", "ix86_build_signbit_mask", "(", "enum", "machine_mode", "mode", ",", "bool", "vect", ",", "bool", "invert", ")", "{", "enum", "machine_mode", "vec_mode", ";", "HOST_WIDE_INT", "hi", ",", "lo", ";", "int", "shift", "=", "63", ";", "rtvec", "v", ";", "rtx", "mask", ";", "if", "(", "mode", "==", "SFmode", ")", "lo", "=", "0x80000000", ",", "hi", "=", "lo", "<", "0", ";", "else", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", ")", "lo", "=", "(", "HOST_WIDE_INT", ")", "1", "<<", "shift", ",", "hi", "=", "-", "1", ";", "else", "lo", "=", "0", ",", "hi", "=", "(", "HOST_WIDE_INT", ")", "1", "<<", "(", "shift", "-", "HOST_BITS_PER_WIDE_INT", ")", ";", "if", "(", "invert", ")", "lo", "=", "~", "lo", ",", "hi", "=", "~", "hi", ";", "mask", "=", "immed_double_const", "(", "lo", ",", "hi", ",", "mode", "==", "SFmode", "?", "SImode", ":", "DImode", ")", ";", "mask", "=", "gen_lowpart", "(", "mode", ",", "mask", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "{", "if", "(", "vect", ")", "v", "=", "gen_rtvec", "(", "4", ",", "mask", ",", "mask", ",", "mask", ",", "mask", ")", ";", "else", "v", "=", "gen_rtvec", "(", "4", ",", "mask", ",", "CONST0_RTX", "(", "SFmode", ")", ",", "CONST0_RTX", "(", "SFmode", ")", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ";", "vec_mode", "=", "V4SFmode", ";", "}", "else", "{", "if", "(", "vect", ")", "v", "=", "gen_rtvec", "(", "2", ",", "mask", ",", "mask", ")", ";", "else", "v", "=", "gen_rtvec", "(", "2", ",", "mask", ",", "CONST0_RTX", "(", "DFmode", ")", ")", ";", "vec_mode", "=", "V2DFmode", ";", "}", "return", "force_reg", "(", "vec_mode", ",", "gen_rtx_CONST_VECTOR", "(", "vec_mode", ",", "v", ")", ")", ";", "}", "</s>" ]

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

[ "i386", "63", "0x80000000", "0", "64", "1", "1", "0", "1", "4", "4", "2", "2" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "computeDefaultCPU", "(", "TT", ",", "CPU", ")", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveAArch64CodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "}", "if", "(", "this", "->", "Options", ".", "TLSSize", "==", "0", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "||", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Kernel", ")", "&&", "this", "->", "Options", ".", "TLSSize", ">", "32", ")", "this", "->", "Options", ".", "TLSSize", "=", "32", ";", "else", "if", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Tiny", "&&", "this", "->", "Options", ".", "TLSSize", ">", "24", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", "&&", "TT", ".", "getArch", "(", ")", "!=", "Triple", "::", "aarch64_32", "&&", "TT", ".", "getArchName", "(", ")", "!=", "\"arm64e\"", "&&", "!", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", ")", "{", "setGlobalISel", "(", "true", ")", ";", "setGlobalISelAbort", "(", "GlobalISelAbortMode", "::", "Disable", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "true", ")", ";", "setSupportsDebugEntryValues", "(", "true", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "0", "24", "32", "32", "24", "24", "\"arm64e\"" ]

[]

[ "<s>", "bool", "TPCTargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Call", ")", "return", "false", ";", "return", "TargetLowering", "::", "isProfitableToHoist", "(", "I", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "bool", "BPFAbstractMemberAccess", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Abstract Member Accesses **********\\n\"", ")", ";", "if", "(", "empty", "(", "M", ".", "debug_compile_units", "(", ")", ")", ")", "return", "false", ";", "return", "doTransformation", "(", "M", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "\"********** Abstract Member Accesses **********\\n\"" ]

[]

[ "<s>", "static", "rtx", "frv_expand_store_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "cookie", "=", "frv_io_address_cookie", "(", "op0", ")", ";", "op0", "=", "frv_volatile_memref", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ",", "op0", ")", ";", "convert_move", "(", "op0", ",", "force_reg", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ",", "op1", ")", ",", "1", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "copy_rtx", "(", "op0", ")", ",", "cookie", ",", "GEN_INT", "(", "FRV_IO_WRITE", ")", ")", ")", ";", "cfun", "->", "machine", "->", "has_membar_p", "=", "1", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Likewise", "__builtin_write", "*", "functions", "." ]

[ "frv", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "SetupMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "CurrentFnDescSym", "=", "getSymbol", "(", "&", "MF", ".", "getFunction", "(", ")", ")", ";", "MCSectionXCOFF", "*", "FnDescSec", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForFunctionDescriptor", "(", "CurrentFnDescSym", ")", ")", ";", "cast", "<", "MCSymbolXCOFF", ">", "(", "CurrentFnDescSym", ")", "->", "setContainingCsect", "(", "FnDescSec", ")", ";", "return", "AsmPrinter", "::", "SetupMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

[ "This", "should", "be", "called", "when", "a", "new", "MachineFunction", "is", "being", "processed", "from", "runOnMachineFunction", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "enum", "reg_class", "secondary_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "in", ")", "{", "int", "regno", ";", "if", "(", "TARGET_ELF", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "MACHOPIC_INDIRECT", ")", ")", "{", "if", "(", "class", "!=", "BASE_REGS", "&&", "(", "GET_CODE", "(", "in", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "in", ")", "==", "HIGH", "||", "GET_CODE", "(", "in", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "in", ")", "==", "CONST", ")", ")", "return", "BASE_REGS", ";", "}", "if", "(", "GET_CODE", "(", "in", ")", "==", "REG", ")", "{", "regno", "=", "REGNO", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "1", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "in", ")", "==", "SUBREG", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "1", ";", "}", "else", "regno", "=", "-", "1", ";", "if", "(", "class", "==", "GENERAL_REGS", "||", "class", "==", "BASE_REGS", "||", "(", "regno", ">=", "0", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "FP_REGNO_P", "(", "regno", ")", ")", "&&", "(", "class", "==", "FLOAT_REGS", "||", "class", "==", "NON_SPECIAL_REGS", ")", ")", "return", "NO_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "&&", "class", "==", "ALTIVEC_REGS", ")", "return", "NO_REGS", ";", "if", "(", "(", "class", "==", "CR_REGS", "||", "class", "==", "CR0_REGS", ")", "&&", "regno", ">=", "0", "&&", "CR_REGNO_P", "(", "regno", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "class", "of", "any", "secondary", "reload", "register", "that", "is", "needed", "to", "move", "IN", "into", "a", "register", "in", "class", "CLASS", "using", "mode", "MODE", ".", "Profiling", "has", "showed", "this", "routine", "and", "its", "descendants", "account", "for", "a", "significant", "amount", "of", "compile", "time", "(", "~7", "%", ")", ".", "So", "it", "has", "been", "optimized", "to", "reduce", "redundant", "computations", "and", "eliminate", "useless", "function", "calls", ".", "It", "might", "be", "worthwhile", "to", "try", "and", "make", "this", "a", "leaf", "function", "too", "." ]

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

[]

[ "<s>", "static", "int", "rs6000_compare_version_priority", "(", "tree", "decl1", ",", "tree", "decl2", ")", "{", "int", "priority1", "=", "rs6000_clone_priority", "(", "decl1", ")", ";", "int", "priority2", "=", "rs6000_clone_priority", "(", "decl2", ")", ";", "int", "ret", "=", "priority1", "-", "priority2", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_compare_version_priority (%s, %s) => %d\\n\"", ",", "get_decl_name", "(", "decl1", ")", ",", "get_decl_name", "(", "decl2", ")", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "This", "compares", "the", "priority", "of", "target", "features", "in", "function", "DECL1", "and", "DECL2", ".", "It", "returns", "positive", "value", "if", "DECL1", "is", "higher", "priority", ",", "negative", "value", "if", "DECL2", "is", "higher", "priority", "and", "0", "if", "they", "are", "the", "same", ".", "Note", ",", "priorities", "are", "ordered", "from", "lowest", "(", "CLONE_DEFAULT", ")", "to", "highest", "(", "currently", "CLONE_ISA_3_0", ")", "." ]

[ "rs6000", "\"rs6000_compare_version_priority (%s, %s) => %d\\n\"" ]

[]

[ "<s>", "bool", "AZPRPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAZPRISelDag", "(", "getAZPRTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AZPR", "AZPR", "AZPR", "AZPR" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "SPUHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ")", "{", "const", "SDNode", "*", "Node", "=", "SU", "->", "getNode", "(", ")", "->", "getFlaggedMachineNode", "(", ")", ";", "ScheduleHazardRecognizer", "::", "HazardType", "retval", "=", "NoHazard", ";", "bool", "mustBeOdd", "=", "false", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "case", "SPU", "::", "LQDv16i8", ":", "case", "SPU", "::", "LQDv8i16", ":", "case", "SPU", "::", "LQDv4i32", ":", "case", "SPU", "::", "LQDv4f32", ":", "case", "SPU", "::", "LQDv2f64", ":", "case", "SPU", "::", "LQDr128", ":", "case", "SPU", "::", "LQDr64", ":", "case", "SPU", "::", "LQDr32", ":", "case", "SPU", "::", "LQDr16", ":", "case", "SPU", "::", "LQAv16i8", ":", "case", "SPU", "::", "LQAv8i16", ":", "case", "SPU", "::", "LQAv4i32", ":", "case", "SPU", "::", "LQAv4f32", ":", "case", "SPU", "::", "LQAv2f64", ":", "case", "SPU", "::", "LQAr128", ":", "case", "SPU", "::", "LQAr64", ":", "case", "SPU", "::", "LQAr32", ":", "case", "SPU", "::", "LQXv4i32", ":", "case", "SPU", "::", "LQXr128", ":", "case", "SPU", "::", "LQXr64", ":", "case", "SPU", "::", "LQXr32", ":", "case", "SPU", "::", "LQXr16", ":", "case", "SPU", "::", "STQDv16i8", ":", "case", "SPU", "::", "STQDv8i16", ":", "case", "SPU", "::", "STQDv4i32", ":", "case", "SPU", "::", "STQDv4f32", ":", "case", "SPU", "::", "STQDv2f64", ":", "case", "SPU", "::", "STQDr128", ":", "case", "SPU", "::", "STQDr64", ":", "case", "SPU", "::", "STQDr32", ":", "case", "SPU", "::", "STQDr16", ":", "case", "SPU", "::", "STQDr8", ":", "case", "SPU", "::", "STQAv16i8", ":", "case", "SPU", "::", "STQAv8i16", ":", "case", "SPU", "::", "STQAv4i32", ":", "case", "SPU", "::", "STQAv4f32", ":", "case", "SPU", "::", "STQAv2f64", ":", "case", "SPU", "::", "STQAr128", ":", "case", "SPU", "::", "STQAr64", ":", "case", "SPU", "::", "STQAr32", ":", "case", "SPU", "::", "STQAr16", ":", "case", "SPU", "::", "STQAr8", ":", "case", "SPU", "::", "STQXv16i8", ":", "case", "SPU", "::", "STQXv8i16", ":", "case", "SPU", "::", "STQXv4i32", ":", "case", "SPU", "::", "STQXv4f32", ":", "case", "SPU", "::", "STQXv2f64", ":", "case", "SPU", "::", "STQXr128", ":", "case", "SPU", "::", "STQXr64", ":", "case", "SPU", "::", "STQXr32", ":", "case", "SPU", "::", "STQXr16", ":", "case", "SPU", "::", "STQXr8", ":", "case", "SPU", "::", "RET", ":", "mustBeOdd", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "mustBeOdd", "&&", "!", "EvenOdd", ")", "retval", "=", "Hazard", ";", "DOUT", "<<", "\"SPUHazardRecognizer EvenOdd \"", "<<", "EvenOdd", "<<", "\" Hazard \"", "<<", "retval", "<<", "\"\\n\"", ";", "EvenOdd", "^=", "1", ";", "return", "retval", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "CellSPU", "SPU", "SPU::LQDv16i8", "SPU::LQDv8i16", "SPU::LQDv4i32", "SPU::LQDv4f32", "SPU::LQDv2f64", "SPU::LQDr128", "SPU::LQDr64", "SPU::LQDr32", "SPU::LQDr16", "SPU::LQAv16i8", "SPU::LQAv8i16", "SPU::LQAv4i32", "SPU::LQAv4f32", "SPU::LQAv2f64", "SPU::LQAr128", "SPU::LQAr64", "SPU::LQAr32", "SPU::LQXv4i32", "SPU::LQXr128", "SPU::LQXr64", "SPU::LQXr32", "SPU::LQXr16", "SPU::STQDv16i8", "SPU::STQDv8i16", "SPU::STQDv4i32", "SPU::STQDv4f32", "SPU::STQDv2f64", "SPU::STQDr128", "SPU::STQDr64", "SPU::STQDr32", "SPU::STQDr16", "SPU::STQDr8", "SPU::STQAv16i8", "SPU::STQAv8i16", "SPU::STQAv4i32", "SPU::STQAv4f32", "SPU::STQAv2f64", "SPU::STQAr128", "SPU::STQAr64", "SPU::STQAr32", "SPU::STQAr16", "SPU::STQAr8", "SPU::STQXv16i8", "SPU::STQXv8i16", "SPU::STQXv4i32", "SPU::STQXv4f32", "SPU::STQXv2f64", "SPU::STQXr128", "SPU::STQXr64", "SPU::STQXr32", "SPU::STQXr16", "SPU::STQXr8", "SPU::RET", "\"SPUHazardRecognizer EvenOdd \"", "\" Hazard \"", "\"\\n\"", "1" ]

[]

[ "<s>", "RCPair", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'h'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "hGPRRegClass", ")", ";", "break", ";", "case", "'r'", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPRRegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPR_8RegClass", ")", ";", "break", ";", "case", "'t'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPR_VFP2RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPR_VFP2RegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "ARM", "::", "CPSR", ")", ",", "&", "ARM", "::", "CCRRegClass", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "0U", "ARM::hGPRRegClass", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPRRegClass", "64", "0U", "ARM::DPRRegClass", "128", "0U", "ARM::QPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPR_8RegClass", "64", "0U", "ARM::DPR_8RegClass", "128", "0U", "ARM::QPR_8RegClass", "MVT::Other", "MVT::f32", "MVT::i32", "0U", "ARM::SPRRegClass", "64", "0U", "ARM::DPR_VFP2RegClass", "128", "0U", "ARM::QPR_VFP2RegClass", "\"{cc}\"", "ARM::CPSR", "ARM::CCRRegClass" ]

[]

[ "<s>", "int", "ix86_expand_int_addcc", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "compare_op", ";", "rtx", "val", "=", "const0_rtx", ";", "bool", "fpcmp", "=", "false", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "operands", "[", "3", "]", "!=", "const1_rtx", "&&", "operands", "[", "3", "]", "!=", "constm1_rtx", ")", "return", "0", ";", "if", "(", "!", "ix86_expand_carry_flag_compare", "(", "code", ",", "ix86_compare_op0", ",", "ix86_compare_op1", ",", "&", "compare_op", ")", ")", "return", "0", ";", "code", "=", "GET_CODE", "(", "compare_op", ")", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "compare_op", ",", "0", ")", ")", "==", "CCFPmode", "||", "GET_MODE", "(", "XEXP", "(", "compare_op", ",", "0", ")", ")", "==", "CCFPUmode", ")", "{", "fpcmp", "=", "true", ";", "code", "=", "ix86_fp_compare_code_to_integer", "(", "code", ")", ";", "}", "if", "(", "code", "!=", "LTU", ")", "{", "val", "=", "constm1_rtx", ";", "if", "(", "fpcmp", ")", "PUT_CODE", "(", "compare_op", ",", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "compare_op", ")", ")", ")", ";", "else", "PUT_CODE", "(", "compare_op", ",", "reverse_condition", "(", "GET_CODE", "(", "compare_op", ")", ")", ")", ";", "}", "PUT_MODE", "(", "compare_op", ",", "mode", ")", ";", "if", "(", "(", "code", "==", "LTU", ")", "==", "(", "operands", "[", "3", "]", "==", "constm1_rtx", ")", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "QImode", ":", "emit_insn", "(", "gen_subqi3_carry", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_subhi3_carry", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_subsi3_carry", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "DImode", ":", "emit_insn", "(", "gen_subdi3_carry_rex64", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "QImode", ":", "emit_insn", "(", "gen_addqi3_carry", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_addhi3_carry", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_addsi3_carry", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "case", "DImode", ":", "emit_insn", "(", "gen_adddi3_carry_rex64", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "compare_op", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "1", ";", "}", "</s>" ]

[ "Expand", "conditional", "increment", "or", "decrement", "using", "adb/sbb", "instructions", ".", "The", "default", "case", "using", "setcc", "followed", "by", "the", "conditional", "move", "can", "be", "done", "by", "generic", "code", "." ]

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

[]

[ "<s>", "tree", "builtin_decl", "(", "unsigned", "int", "code", ",", "bool", ")", "{", "if", "(", "code", ">=", "vec_safe_length", "(", "registered_functions", ")", ")", "return", "error_mark_node", ";", "return", "(", "*", "registered_functions", ")", "[", "code", "]", "->", "decl", ";", "}", "</s>" ]

[ "Return", "the", "function", "decl", "with", "RVV", "function", "subcode", "CODE", ",", "or", "error_mark_node", "if", "no", "such", "function", "exists", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "int", "alpha_issue_rate", "(", ")", "{", "return", "(", "alpha_cpu", "==", "PROCESSOR_EV4", "?", "2", ":", "4", ")", ";", "}", "</s>" ]

[ "Function", "to", "initialize", "the", "issue", "rate", "used", "by", "the", "scheduler", "." ]

[ "alpha", "2", "4" ]

[]

[ "<s>", "TargetStackID", "::", "Value", "RISCVFrameLowering", "::", "getStackIDForScalableVectors", "(", ")", "const", "{", "return", "TargetStackID", "::", "ScalableVector", ";", "}", "</s>" ]

[ "Returns", "the", "StackID", "that", "scalable", "vectors", "should", "be", "associated", "with", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "EVT", "LM32TargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "LM32", "LM32", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "mips_save_reg_p", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "mips_cfun_call_saved_reg_p", "(", "regno", ")", ")", "{", "if", "(", "mips_cfun_might_clobber_call_saved_reg_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "MAX_FPRS_PER_FMT", "==", "2", "&&", "mips_cfun_might_clobber_call_saved_reg_p", "(", "regno", "+", "1", ")", ")", "return", "true", ";", "}", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", "&&", "crtl", "->", "calls_eh_return", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "must", "save", "REGNO", "." ]

[ "mips", "2", "1" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "&&", "\"WebAssembly should not have callee-saved registers\"", ")", ";", "auto", "*", "WFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ",", "*", "MFI", ")", ")", "return", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "SPAddr", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "unsigned", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "\"__stack_pointer\"", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "SPAddr", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ";", "auto", "*", "LoadMMO", "=", "new", "MachineMemOperand", "(", "MachinePointerInfo", "(", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "4", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "LOAD_I32", ")", ",", "StackSize", "?", "SPReg", ":", "(", "unsigned", ")", "WebAssembly", "::", "SP32", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SPAddr", ")", ".", "addImm", "(", "2", ")", ".", "addMemOperand", "(", "LoadMMO", ")", ";", "WFI", "->", "stackifyVReg", "(", "SPAddr", ")", ";", "if", "(", "StackSize", ")", "{", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "SUB_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "SPReg", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "WFI", "->", "stackifyVReg", "(", "OffsetReg", ")", ";", "WFI", "->", "stackifyVReg", "(", "SPReg", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "COPY_LOCAL_I32", ")", ",", "WebAssembly", "::", "FP32", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ";", "}", "if", "(", "StackSize", "&&", "needsSPWriteback", "(", "MF", ",", "*", "MFI", ")", ")", "{", "writeSPToMemory", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "InsertPt", ",", "DL", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"WebAssembly should not have callee-saved registers\"", "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::I32RegClass", "\"__stack_pointer\"", "WebAssembly::CONST_I32", "4", "4", "WebAssembly::LOAD_I32", "WebAssembly::SP32", "0", "2", "WebAssembly::I32RegClass", "WebAssembly::CONST_I32", "WebAssembly::SUB_I32", "WebAssembly::SP32", "WebAssembly::COPY_LOCAL_I32", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::SP32" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createPPCISelDag", "(", "getPPCTargetMachine", "(", ")", ")", ")", ";", "if", "(", "!", "DisableCTRLoops", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCCTRLoopsVerify", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MCSection", "*", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "Align", "&", "Alignment", ")", "const", "override", "{", "return", "TextSection", ";", "}", "</s>" ]

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

[ "SPIRV" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "FPReg", "=", "RI", ".", "getFrameRegister", "(", "MF", ")", ";", "bool", "is64Bit", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "bool", "isWin64", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetWin64", "(", ")", ";", "unsigned", "Opc", "=", "is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RegClass", "=", "CSI", "[", "i", "]", ".", "getRegClass", "(", ")", ";", "if", "(", "RegClass", "!=", "&", "X86", "::", "VR128RegClass", "&&", "!", "isWin64", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ";", "}", "else", "{", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RegClass", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86::POP64r", "X86::POP32r", "0", "X86::VR128RegClass" ]

[]

[ "<s>", "DEBUG_FUNCTION", "void", "rs6000_debug_print_mode", "(", "ssize_t", "m", ")", "{", "ssize_t", "rc", ";", "fprintf", "(", "stderr", ",", "\"Mode: %-5s\"", ",", "GET_MODE_NAME", "(", "m", ")", ")", ";", "for", "(", "rc", "=", "0", ";", "rc", "<", "N_RELOAD_REG", ";", "rc", "++", ")", "fprintf", "(", "stderr", ",", "\" %s: %s\"", ",", "reload_reg_map", "[", "rc", "]", ".", "name", ",", "rs6000_debug_addr_mask", "(", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "rc", "]", ",", "true", ")", ")", ";", "if", "(", "rs6000_vector_unit", "[", "m", "]", "!=", "VECTOR_NONE", "||", "rs6000_vector_mem", "[", "m", "]", "!=", "VECTOR_NONE", "||", "(", "reg_addr", "[", "m", "]", ".", "reload_store", "!=", "CODE_FOR_nothing", ")", "||", "(", "reg_addr", "[", "m", "]", ".", "reload_load", "!=", "CODE_FOR_nothing", ")", "||", "reg_addr", "[", "m", "]", ".", "scalar_in_vmx_p", ")", "{", "fprintf", "(", "stderr", ",", "\" Vector-arith=%-10s Vector-mem=%-10s Reload=%c%c Upper=%c\"", ",", "rs6000_debug_vector_unit", "(", "rs6000_vector_unit", "[", "m", "]", ")", ",", "rs6000_debug_vector_unit", "(", "rs6000_vector_mem", "[", "m", "]", ")", ",", "(", "reg_addr", "[", "m", "]", ".", "reload_store", "!=", "CODE_FOR_nothing", ")", "?", "'s'", ":", "'*'", ",", "(", "reg_addr", "[", "m", "]", ".", "reload_load", "!=", "CODE_FOR_nothing", ")", "?", "'l'", ":", "'*'", ",", "(", "reg_addr", "[", "m", "]", ".", "scalar_in_vmx_p", ")", "?", "'y'", ":", "'n'", ")", ";", "}", "fputs", "(", "\"\\n\"", ",", "stderr", ")", ";", "}", "</s>" ]

[ "Print", "the", "address", "masks", "in", "a", "human", "readble", "fashion", "." ]

[ "rs6000", "\"Mode: %-5s\"", "0", "\" %s: %s\"", "\" Vector-arith=%-10s Vector-mem=%-10s Reload=%c%c Upper=%c\"", "\"\\n\"" ]

[]

[ "<s>", "void", "function_expander", "::", "add_fixed_operand", "(", "rtx", "x", ")", "{", "m_ops", ".", "safe_grow", "(", "m_ops", ".", "length", "(", ")", "+", "1", ")", ";", "create_fixed_operand", "(", "&", "m_ops", ".", "last", "(", ")", ",", "x", ")", ";", "}", "</s>" ]

[ "Add", "an", "operand", "that", "must", "be", "X", ".", "The", "only", "way", "of", "legitimizing", "an", "invalid", "X", "is", "to", "reload", "the", "address", "of", "a", "MEM", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "void", "mips_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "if", "(", "TARGET_EMBEDDED_DATA", "&&", "TARGET_UNINIT_CONST_IN_RODATA", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "decl", ")", "&&", "(", "DECL_INITIAL", "(", "decl", ")", "==", "0", "||", "DECL_INITIAL", "(", "decl", ")", "==", "error_mark_node", ")", ")", "{", "if", "(", "TREE_PUBLIC", "(", "decl", ")", "&&", "DECL_NAME", "(", "decl", ")", ")", "targetm", ".", "asm_out", ".", "globalize_label", "(", "stream", ",", "name", ")", ";", "readonly_data_section", "(", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "mips_declare_object", "(", "stream", ",", "name", ",", "\"\"", ",", "\":\\n\\t.space\\t\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\"\\n\"", ",", "size", ")", ";", "}", "else", "mips_declare_common_object", "(", "stream", ",", "name", ",", "\"\\n\\t.comm\\t\"", ",", "size", ",", "align", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_ALIGNED_DECL_COMMON", ".", "This", "is", "usually", "the", "same", "as", "the", "elfos.h", "version", ",", "but", "we", "also", "need", "to", "handle", "-muninit-const-in-rodata", "." ]

[ "mips", "0", "\"\"", "\":\\n\\t.space\\t\"", "\"\\n\"", "\"\\n\\t.comm\\t\"" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "mips_shift_truncation_mask", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_LOONGSON_VECTORS", "&&", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "0", ";", "return", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHIFT_TRUNCATION_MASK", ".", "We", "want", "to", "keep", "the", "default", "behavior", "of", "TARGET_SHIFT_TRUNCATION_MASK", "for", "non-vector", "modes", "even", "when", "TARGET_LOONGSON_VECTORS", "is", "true", "." ]

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

[]

[ "<s>", "HOST_WIDE_INT", "alpha_vms_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", ")", "{", "HOST_WIDE_INT", "sa_size", "=", "cfun", "->", "machine", "->", "sa_size", ";", "if", "(", "alpha_procedure_type", "==", "PT_NULL", ")", "return", "0", ";", "{", "HOST_WIDE_INT", "offset", ";", "HOST_WIDE_INT", "pv_save_size", "=", "alpha_procedure_type", "==", "PT_STACK", "?", "8", ":", "0", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", ")", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "(", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", "+", "get_frame_size", "(", ")", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", "-", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "offset", "+=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "return", "offset", ";", "}", "}", "</s>" ]

[ "FROM", "is", "to", "be", "eliminated", "for", "TO", ".", "Return", "the", "offset", "so", "that", "TO+offset", "designates", "the", "same", "location", "as", "FROM", "." ]

[ "alpha", "0", "8", "0" ]

[]