Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "hasMFence", "(", ")", "const", "{", "return", "hasSSE2", "(", ")", "||", "is64Bit", "(", ")", ";", "}", "</s>" ]

[ "Use", "mfence", "if", "we", "have", "SSE2", "or", "we", "'re", "on", "x86-64", "(", "even", "if", "we", "asked", "for", "no-sse2", ")", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "const", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "==", "2", ")", "return", "true", ";", "if", "(", "NumElts", "==", "4", "&&", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "{", "return", "(", "isMOVLMask", "(", "Mask", ",", "VT", ")", "||", "isCommutedMOVLMask", "(", "Mask", ",", "VT", ",", "true", ")", "||", "isSHUFPMask", "(", "Mask", ",", "VT", ")", "||", "isCommutedSHUFPMask", "(", "Mask", ",", "VT", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Similar", "to", "isShuffleMaskLegal", "." ]

[ "X86", "X86", "2", "4", "128" ]

[]

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

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

[ "MINA32" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "preferIncOfAddToSubOfNot", "(", "EVT", "VT", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "VT", ".", "getScalarSizeInBits", "(", ")", "<=", "32", ";", "return", "true", ";", "}", "return", "VT", ".", "isScalarInteger", "(", ")", ";", "}", "</s>" ]

[ "These", "two", "forms", "are", "equivalent", ":", "sub", "y", ",", "(", "xor", "x", ",", "-1", ")", "add", "(", "add", "x", ",", "1", ")", ",", "y", "The", "variant", "with", "two", "add", "'s", "is", "IR-canonical", "." ]

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

[]

[ "<s>", "void", "BlackfinInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "inClass", "(", "BF", "::", "DPRegClass", ",", "DestReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "LOAD32fi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "D16RegClass", ",", "DestReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "LOAD16fi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "AnyCCRegClass", ",", "DestReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "LOAD8fi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Cannot load regclass from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::DPRegClass", "BF::LOAD32fi", "0", "BF::D16RegClass", "BF::LOAD16fi", "0", "BF::AnyCCRegClass", "BF::LOAD8fi", "0", "\"Cannot load regclass from stack slot\"" ]

[]

[ "<s>", "SDValue", "SICTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "SICCC", "SICCCInfo", "(", "CallConv", ",", "ABI", ".", "IsO32", "(", ")", ",", "CCInfo", ")", ";", "SICCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "SICFunctionInfo", "*", "SICFI", "=", "MF", ".", "getInfo", "<", "SICFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "SICFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "unsigned", "S", "=", "SIC", "::", "S", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "S", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "S", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SICISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "ISD::OutputArg", "16", "SIC", "SIC", "SIC", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "SIC", "SIC", "SIC", "SIC", "\"sret virtual register not created in the entry block\"", "SIC::S", "1", "0", "SICISD::Ret", "MVT::Other" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasCustomCheapAsMoveHandling", "(", ")", ")", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "unsigned", "Imm", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "return", "(", "Subtarget", ".", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "ExynosM1", "||", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "case", "AArch64", "::", "ADDWrs", ":", "case", "AArch64", "::", "ADDXrs", ":", "case", "AArch64", "::", "SUBWrs", ":", "case", "AArch64", "::", "SUBXrs", ":", "Imm", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "return", "(", "Subtarget", ".", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "ExynosM1", "&&", "AArch64_AM", "::", "getArithShiftValue", "(", "Imm", ")", "<", "4", ")", ";", "case", "AArch64", "::", "ANDWri", ":", "case", "AArch64", "::", "ANDXri", ":", "case", "AArch64", "::", "EORWri", ":", "case", "AArch64", "::", "EORXri", ":", "case", "AArch64", "::", "ORRWri", ":", "case", "AArch64", "::", "ORRXri", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrr", ":", "case", "AArch64", "::", "ANDXrr", ":", "case", "AArch64", "::", "BICWrr", ":", "case", "AArch64", "::", "BICXrr", ":", "case", "AArch64", "::", "EONWrr", ":", "case", "AArch64", "::", "EONXrr", ":", "case", "AArch64", "::", "EORWrr", ":", "case", "AArch64", "::", "EORXrr", ":", "case", "AArch64", "::", "ORNWrr", ":", "case", "AArch64", "::", "ORNXrr", ":", "case", "AArch64", "::", "ORRWrr", ":", "case", "AArch64", "::", "ORRXrr", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrs", ":", "case", "AArch64", "::", "ANDXrs", ":", "case", "AArch64", "::", "BICWrs", ":", "case", "AArch64", "::", "BICXrs", ":", "case", "AArch64", "::", "EONWrs", ":", "case", "AArch64", "::", "EONXrs", ":", "case", "AArch64", "::", "EORWrs", ":", "case", "AArch64", "::", "EORXrs", ":", "case", "AArch64", "::", "ORNWrs", ":", "case", "AArch64", "::", "ORNXrs", ":", "case", "AArch64", "::", "ORRWrs", ":", "case", "AArch64", "::", "ORRXrs", ":", "Imm", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "return", "(", "Subtarget", ".", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "ExynosM1", "&&", "AArch64_AM", "::", "getShiftValue", "(", "Imm", ")", "<", "4", "&&", "AArch64_AM", "::", "getShiftType", "(", "Imm", ")", "==", "AArch64_AM", "::", "LSL", ")", ";", "case", "AArch64", "::", "MOVi32imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "32", ")", ";", "case", "AArch64", "::", "MOVi64imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "64", ")", ";", "case", "AArch64", "::", "FMOVS0", ":", "case", "AArch64", "::", "FMOVD0", ":", "return", "Subtarget", ".", "hasZeroCycleZeroing", "(", ")", ";", "case", "TargetOpcode", "::", "COPY", ":", "return", "(", "Subtarget", ".", "hasZeroCycleZeroing", "(", ")", "&&", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode to check as cheap as a move!\"", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "AArch64", "AArch64", "AArch64::ADDWri", "AArch64::ADDXri", "AArch64::SUBWri", "AArch64::SUBXri", "AArch64", "3", "0", "AArch64::ADDWrs", "AArch64::ADDXrs", "AArch64::SUBWrs", "AArch64::SUBXrs", "3", "AArch64", "AArch64_AM::getArithShiftValue", "4", "AArch64::ANDWri", "AArch64::ANDXri", "AArch64::EORWri", "AArch64::EORXri", "AArch64::ORRWri", "AArch64::ORRXri", "AArch64::ANDWrr", "AArch64::ANDXrr", "AArch64::BICWrr", "AArch64::BICXrr", "AArch64::EONWrr", "AArch64::EONXrr", "AArch64::EORWrr", "AArch64::EORXrr", "AArch64::ORNWrr", "AArch64::ORNXrr", "AArch64::ORRWrr", "AArch64::ORRXrr", "AArch64::ANDWrs", "AArch64::ANDXrs", "AArch64::BICWrs", "AArch64::BICXrs", "AArch64::EONWrs", "AArch64::EONXrs", "AArch64::EORWrs", "AArch64::EORXrs", "AArch64::ORNWrs", "AArch64::ORNXrs", "AArch64::ORRWrs", "AArch64::ORRXrs", "3", "AArch64", "AArch64_AM::getShiftValue", "4", "AArch64_AM::getShiftType", "AArch64_AM::LSL", "AArch64::MOVi32imm", "32", "AArch64::MOVi64imm", "64", "AArch64::FMOVS0", "AArch64::FMOVD0", "1", "AArch64::WZR", "1", "AArch64::XZR", "\"Unknown opcode to check as cheap as a move!\"" ]

[]

[ "<s>", "bool", "JVMOffsetAllocator", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFN", ")", "{", "MF", "=", "&", "MFN", ";", "TII", "=", "static_cast", "<", "const", "JVMInstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "JVMRegisterInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n******** JVM Offset allocation ********\\n\"", ")", ";", "PerformAllocation", "(", "DT", "->", "getRootNode", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "JVM", "JVM", "JVM", "JVM", "\"\\n******** JVM Offset allocation ********\\n\"" ]

[]

[ "<s>", "static", "rtx", "sparc_function_arg_1", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "bool", "incoming", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "const", "int", "regbase", "=", "incoming", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ";", "int", "slotno", ",", "regno", ",", "padding", ";", "tree", "type", "=", "arg", ".", "type", ";", "machine_mode", "mode", "=", "arg", ".", "mode", ";", "enum", "mode_class", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "bool", "named", "=", "arg", ".", "named", ";", "slotno", "=", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "incoming", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "type", "&&", "VECTOR_INTEGER_TYPE_P", "(", "type", ")", ")", "mclass", "=", "MODE_FLOAT", ";", "if", "(", "TARGET_ARCH32", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_record_value", "(", "type", ",", "mode", ",", "slotno", ",", "named", ",", "regbase", ")", ";", "}", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "slotno", ",", "regno", ")", ";", "}", "else", "if", "(", "type", "&&", "VECTOR_TYPE_P", "(", "type", ")", "&&", "mode", "==", "BLKmode", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_vector_value", "(", "size", ",", "slotno", ",", "named", ",", "regno", ")", ";", "}", "else", "if", "(", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "SPARC_FP_REG_P", "(", "regno", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "cum", "->", "prototype_p", "||", "cum", "->", "libcall_p", ")", "return", "reg", ";", "else", "{", "rtx", "v0", ",", "v1", ";", "if", "(", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "<", "SPARC_INT_ARG_MAX", "*", "2", ")", "{", "int", "intreg", ";", "if", "(", "incoming", ")", "return", "reg", ";", "intreg", "=", "(", "SPARC_OUTGOING_INT_ARG_FIRST", "+", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "/", "2", ")", ";", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "intreg", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "else", "{", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "}", "}", "else", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "else_blk", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</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", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "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", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "INCOMING_P", "is", "false", "for", "TARGET_FUNCTION_ARG", ",", "true", "for", "TARGET_FUNCTION_INCOMING_ARG", "." ]

[ "sparc", "1", "0", "16", "16", "16", "2", "2", "2", "2", "16", "0" ]

[]

[ "<s>", "unsigned", "X86FrameLowering", "::", "getWinEHFuncletFrameSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "CSSize", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getCalleeSavedFrameSize", "(", ")", ";", "unsigned", "UsedSize", ";", "EHPersonality", "Personality", "=", "classifyEHPersonality", "(", "MF", ".", "getFunction", "(", ")", ".", "getPersonalityFn", "(", ")", ")", ";", "if", "(", "Personality", "==", "EHPersonality", "::", "CoreCLR", ")", "{", "UsedSize", "=", "getPSPSlotOffsetFromSP", "(", "MF", ")", "+", "SlotSize", ";", "}", "else", "{", "UsedSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getMaxCallFrameSize", "(", ")", ";", "}", "unsigned", "FrameSizeMinusRBP", "=", "alignTo", "(", "CSSize", "+", "UsedSize", ",", "getStackAlignment", "(", ")", ")", ";", "return", "FrameSizeMinusRBP", "-", "CSSize", ";", "}", "</s>" ]

[ "Funclets", "only", "need", "to", "account", "for", "space", "for", "the", "callee", "saved", "registers", ",", "as", "the", "locals", "are", "accounted", "for", "in", "the", "parent", "'s", "stack", "frame", "." ]

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

[]

[ "<s>", "static", "tree", "sparc_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "SPARC_BUILTIN_MAX", ")", "return", "error_mark_node", ";", "return", "sparc_builtins", "[", "code", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "hook", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "void", "cris_function_arg_advance", "(", "cumulative_args_t", "ca_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "ca", "->", "regs", "+=", "(", "3", "+", "CRIS_FUNCTION_ARG_SIZE", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "/", "4", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "cris", "3", "4" ]

[]

[ "<s>", "Register", "AArch64RegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", "->", "get", "(", "AArch64", "::", "ADDXri", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "Register", "BaseReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AArch64", "::", "GPR64spRegClass", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", "->", "getRegClass", "(", "MCID", ",", "0", ",", "this", ",", "MF", ")", ")", ";", "unsigned", "Shifter", "=", "AArch64_AM", "::", "getShifterImm", "(", "AArch64_AM", "::", "LSL", ",", "0", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ".", "addImm", "(", "Shifter", ")", ";", "return", "BaseReg", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::ADDXri", "AArch64::GPR64spRegClass", "0", "AArch64_AM::getShifterImm", "AArch64_AM::LSL", "0" ]

[]

[ "<s>", "void", "tool_cleanup", "(", "bool", "from_signal", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "ptx_cfile_name", ")", "maybe_unlink", "(", "ptx_cfile_name", ")", ";", "if", "(", "ptx_name", ")", "maybe_unlink", "(", "ptx_name", ")", ";", "if", "(", "omp_requires_file", ")", "maybe_unlink", "(", "omp_requires_file", ")", ";", "}", "</s>" ]

[ "Delete", "tempfiles", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "SubsumesPredicate", "(", "ArrayRef", "<", "MachineOperand", ">", "Pred1", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred2", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "performDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "performCMovFPCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "performADDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AssertZext", ":", "return", "performAssertZextCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "performSUBCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::SELECT", "MipsISD::CMovFP_F", "MipsISD::CMovFP_T", "ISD::AND", "ISD::OR", "ISD::ADD", "ISD::AssertZext", "ISD::SHL", "ISD::SUB" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BRCOND", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE" ]

[]

[ "<s>", "Sched", "::", "Preference", "PPCTargetLowering", "::", "getSchedulingPreference", "(", "SDNode", "*", "N", ")", "const", "{", "if", "(", "DisableILPPref", "||", "PPCSubTarget", ".", "enableMachineScheduler", "(", ")", ")", "return", "TargetLowering", "::", "getSchedulingPreference", "(", "N", ")", ";", "return", "Sched", "::", "ILP", ";", "}", "</s>" ]

[ "Some", "scheduler", ",", "e.g", "." ]

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

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", "AMDGPU::KILL", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", "&&", "AM", ".", "Scale", ")", "return", "false", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "Ty", "->", "getVectorIsScalable", "(", ")", ")", "return", "AM", ".", "HasBaseReg", "&&", "!", "AM", ".", "BaseOffs", "&&", "!", "AM", ".", "Scale", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "Ty", "->", "isSized", "(", ")", ")", "{", "uint64_t", "NumBits", "=", "DL", ".", "getTypeSizeInBits", "(", "Ty", ")", ";", "NumBytes", "=", "NumBits", "/", "8", ";", "if", "(", "!", "isPowerOf2_64", "(", "NumBits", ")", ")", "NumBytes", "=", "0", ";", "}", "if", "(", "!", "AM", ".", "Scale", ")", "{", "int64_t", "Offset", "=", "AM", ".", "BaseOffs", ";", "if", "(", "isInt", "<", "9", ">", "(", "Offset", ")", ")", "return", "true", ";", "unsigned", "shift", "=", "Log2_64", "(", "NumBytes", ")", ";", "if", "(", "NumBytes", "&&", "Offset", ">", "0", "&&", "(", "Offset", "/", "NumBytes", ")", "<=", "(", "1LL", "<<", "12", ")", "-", "1", "&&", "(", "Offset", ">>", "shift", ")", "<<", "shift", "==", "Offset", ")", "return", "true", ";", "return", "false", ";", "}", "return", "AM", ".", "Scale", "==", "1", "||", "(", "AM", ".", "Scale", ">", "0", "&&", "(", "uint64_t", ")", "AM", ".", "Scale", "==", "NumBytes", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "8", "0", "9", "0", "1LL", "12", "1", "1", "0" ]

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsConstantInSmallSection", "(", "const", "Constant", "*", "CN", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "return", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "useSmallSection", "(", ")", "&&", "LocalSData", "&&", "IsInSmallSection", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "CN", "->", "getType", "(", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "constant", "should", "be", "placed", "into", "small", "data", "section", "." ]

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

[]

[ "<s>", "void", "AVRFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "AVR", "::", "R29R28", ")", ";", "SavedRegs", ".", "set", "(", "AVR", "::", "R29", ")", ";", "SavedRegs", ".", "set", "(", "AVR", "::", "R28", ")", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::R29R28", "AVR::R29", "AVR::R28" ]

[]

[ "<s>", "static", "void", "aarch64_save_callee_saves", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "start_offset", ",", "unsigned", "start", ",", "unsigned", "limit", ",", "bool", "skip_wb", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "(", "*", "gen_mem_ref", ")", "(", "machine_mode", ",", "rtx", ")", "=", "(", "frame_pointer_needed", "?", "gen_frame_mem", ":", "gen_rtx_MEM", ")", ";", "unsigned", "regno", ";", "unsigned", "regno2", ";", "for", "(", "regno", "=", "aarch64_next_callee_save", "(", "start", ",", "limit", ")", ";", "regno", "<=", "limit", ";", "regno", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ")", "{", "rtx", "reg", ",", "mem", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "skip_wb", "&&", "(", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "||", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ")", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "mem", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "regno2", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ";", "if", "(", "regno2", "<=", "limit", "&&", "(", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "+", "UNITS_PER_WORD", ")", "==", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ")", ")", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "rtx", "mem2", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "mem2", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "insn", "=", "emit_insn", "(", "aarch64_gen_store_pair", "(", "mode", ",", "mem", ",", "reg", ",", "mem2", ",", "reg2", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", "=", "1", ";", "regno", "=", "regno2", ";", "}", "else", "insn", "=", "emit_move_insn", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "the", "callee-saved", "registers", "from", "register", "number", "START", "to", "LIMIT", "to", "the", "stack", "at", "the", "location", "starting", "at", "offset", "START_OFFSET", ",", "skipping", "any", "write-back", "candidates", "if", "SKIP_WB", "is", "true", "." ]

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

[]

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

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "LoongArch" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "IMMEDIATE", ":", "OS", "<<", "\"Imm: \"", "<<", "getImm", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "TOKEN", ":", "OS", "<<", "\"Token: \"", "<<", "getToken", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "REGISTER", ":", "OS", "<<", "\"Reg: %r\"", "<<", "getReg", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "MEMORY_IMM", ":", "OS", "<<", "\"MemImm: \"", "<<", "*", "getMemOffset", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "MEMORY_REG_IMM", ":", "OS", "<<", "\"MemRegImm: \"", "<<", "getMemBaseReg", "(", ")", "<<", "\"+\"", "<<", "*", "getMemOffset", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "MEMORY_REG_REG", ":", "assert", "(", "getMemOffset", "(", ")", "==", "nullptr", ")", ";", "OS", "<<", "\"MemRegReg: \"", "<<", "getMemBaseReg", "(", ")", "<<", "\"+\"", "<<", "\"%r\"", "<<", "getMemOffsetReg", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "Lanai", "\"Imm: \"", "\"\\n\"", "\"Token: \"", "\"\\n\"", "\"Reg: %r\"", "\"\\n\"", "\"MemImm: \"", "\"\\n\"", "\"MemRegImm: \"", "\"+\"", "\"\\n\"", "\"MemRegReg: \"", "\"+\"", "\"%r\"", "\"\\n\"" ]

[]

[ "<s>", "static", "inline", "bool", "offset_4bit_signed_scaled_p", "(", "machine_mode", "mode", ",", "poly_int64", "offset", ")", "{", "HOST_WIDE_INT", "multiple", ";", "return", "(", "constant_multiple_p", "(", "offset", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "&", "multiple", ")", "&&", "IN_RANGE", "(", "multiple", ",", "-", "8", ",", "7", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "a", "signed", "4-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

[ "aarch64", "8", "7" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "int_log2", "(", "HOST_WIDE_INT", "power", ")", "{", "HOST_WIDE_INT", "shift", "=", "0", ";", "while", "(", "(", "(", "(", "HOST_WIDE_INT", ")", "1", "<<", "shift", ")", "&", "power", ")", "==", "0", ")", "{", "gcc_assert", "(", "shift", "<=", "31", ")", ";", "shift", "++", ";", "}", "return", "shift", ";", "}", "</s>" ]

[ "Obtain", "the", "shift", "from", "the", "POWER", "of", "two", "." ]

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

[]

[ "<s>", "static", "void", "i386_solaris_elf_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", ")", "{", "if", "(", "TARGET_64BIT", "&&", "strcmp", "(", "name", ",", "\".eh_frame\"", ")", "==", "0", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s,\\\"%s\\\",@unwind\\n\"", ",", "name", ",", "flags", "&", "SECTION_WRITE", "?", "\"aw\"", ":", "\"a\"", ")", ";", "return", ";", "}", "if", "(", "HAVE_COMDAT_GROUP", "&&", "flags", "&", "SECTION_LINKONCE", ")", "{", "solaris_elf_asm_comdat_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "default_elf_asm_named_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "}", "</s>" ]

[ "Solaris", "named-section", "hook", ".", "Parameters", "are", "as", "for", "named_section_real", "." ]

[ "i386", "\".eh_frame\"", "0", "\"\\t.section\\t%s,\\\"%s\\\",@unwind\\n\"", "\"aw\"", "\"a\"" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMipsModuleISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createMips16ISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createMipsSEISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "mmix_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "TARGET_ABI_GNU", ")", "{", "static", "const", "int", "gnu_abi_reg_alloc_order", "[", "]", "=", "MMIX_GNU_ABI_REG_ALLOC_ORDER", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "reg_alloc_order", "[", "i", "]", "=", "gnu_abi_reg_alloc_order", "[", "i", "]", ";", "for", "(", "i", "=", "15", ";", "i", "<=", "30", ";", "i", "++", ")", "call_used_regs", "[", "i", "]", "=", "0", ";", "for", "(", "i", "=", "MMIX_RESERVED_GNU_ARG_0_REGNUM", ";", "i", "<", "MMIX_RESERVED_GNU_ARG_0_REGNUM", "+", "MMIX_MAX_ARGS_IN_REGS", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "0", ";", "}", "if", "(", "!", "TARGET_TOPLEVEL_SYMBOLS", ")", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "reg_names", "[", "i", "]", "[", "0", "]", "==", "':'", ")", "reg_names", "[", "i", "]", "++", ";", "}", "</s>" ]

[ "CONDITIONAL_REGISTER_USAGE", "." ]

[ "mmix", "0", "15", "30", "0", "0", "0", "0" ]

[]

[ "<s>", "SDNode", "*", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "nullptr", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "SelectAdd", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "SelectSelect", "(", "N", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "SelectTruncate", "(", "N", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "SelectMul", "(", "N", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "SelectZeroExtend", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::ADD", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::SELECT", "ISD::TRUNCATE", "ISD::MUL", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "void", "CJGDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "dl", "(", "Node", ")", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "assert", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "CJG", "::", "ADDri", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "CJG", "::", "ADDri", ",", "dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "CJG", "CJG", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "CJG::ADDri", "MVT::i32", "0", "MVT::i32", "CJG::ADDri", "MVT::i32", "0", "MVT::i32" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SPU nop/lnop Filler\"", ";", "}", "</s>" ]

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

[ "CellSPU", "\"SPU nop/lnop Filler\"" ]

[]

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

[ "Check", "whether", "the", "target", "can", "fold", "a", "load", "that", "feeds", "a", "subreg", "operand", "(", "or", "a", "subreg", "operand", "that", "feeds", "a", "store", ")", "." ]

[ "Z80old" ]

[]

[ "<s>", "int", "SystemZHazardRecognizer", "::", "groupingCost", "(", "SUnit", "*", "SU", ")", "const", "{", "const", "MCSchedClassDesc", "*", "SC", "=", "DAG", "->", "getSchedClass", "(", "SU", ")", ";", "if", "(", "!", "SC", "->", "isValid", "(", ")", ")", "return", "0", ";", "if", "(", "SC", "->", "BeginGroup", ")", "{", "if", "(", "CurrGroupSize", ")", "return", "3", "-", "CurrGroupSize", ";", "return", "-", "1", ";", "}", "if", "(", "SC", "->", "EndGroup", ")", "{", "unsigned", "resultingGroupSize", "=", "(", "CurrGroupSize", "+", "getNumDecoderSlots", "(", "SU", ")", ")", ";", "if", "(", "resultingGroupSize", "<", "3", ")", "return", "(", "3", "-", "resultingGroupSize", ")", ";", "return", "-", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "decoder", "grouping", "for", "SU", "." ]

[ "SystemZ", "SystemZ", "0", "3", "1", "3", "3", "1", "0" ]

[]

[ "<s>", "bool", "AArch64DeadRegisterDefinitions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64DeadRegisterDefinitions *****\\n\"", ")", ";", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processMachineBasicBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "OrderedBlks", ".", "clear", "(", ")", ";", "Visited", ".", "clear", "(", ")", ";", "FuncRep", "=", "&", "MF", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"LoopInfo:\\n\"", ";", "PrintLoopinfo", "(", "*", "MLI", ")", ";", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "DEBUG", "(", "MDT", "->", "print", "(", "dbgs", "(", ")", ",", "(", "const", "llvm", "::", "Module", "*", ")", "nullptr", ")", ";", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "DEBUG", "(", "PDT", "->", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "prepare", "(", ")", ";", "run", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "\"LoopInfo:\\n\"" ]

[]

[ "<s>", "int", "RISCVTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "bool", "Takes12BitImm", "=", "false", ";", "unsigned", "ImmArgIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "GetElementPtr", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "Mul", ":", "Takes12BitImm", "=", "true", ";", "break", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "Takes12BitImm", "=", "true", ";", "ImmArgIdx", "=", "1", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Takes12BitImm", ")", "{", "if", "(", "Instruction", "::", "isCommutative", "(", "Opcode", ")", "||", "Idx", "==", "ImmArgIdx", ")", "{", "if", "(", "Imm", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "getTLI", "(", ")", "->", "isLegalAddImmediate", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "return", "TTI", "::", "TCC_Free", ";", "}", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "return", "TTI", "::", "TCC_Free", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "0U", "1", "64" ]

[]

[ "<s>", "void", "MipsInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Mips", "::", "NOP", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "Mips", "Mips", "Mips::NOP" ]

[]

[ "<s>", "bool", "WebAssemblyOptimizeLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"OptimizeLiveIntervals expects liveness\"", ")", ";", "SmallVector", "<", "LiveInterval", "*", ",", "4", ">", "SplitLIs", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "Register", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MRI", ".", "reg_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "LIS", ".", "splitSeparateComponents", "(", "LIS", ".", "getInterval", "(", "Reg", ")", ",", "SplitLIs", ")", ";", "if", "(", "Reg", "==", "TRI", ".", "getFrameRegister", "(", "MF", ")", "&&", "SplitLIs", ".", "size", "(", ")", ">", "0", ")", "{", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "setFrameBaseVreg", "(", "SplitLIs", ".", "back", "(", ")", "->", "reg", "(", ")", ")", ";", "}", "SplitLIs", ".", "clear", "(", ")", ";", "}", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_early_inc_range", "(", "MF", ".", "front", "(", ")", ")", ")", "{", "if", "(", "MI", ".", "isImplicitDef", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "{", "LiveInterval", "&", "LI", "=", "LIS", ".", "getInterval", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "LIS", ".", "removeVRegDefAt", "(", "LI", ",", "LIS", ".", "getInstructionIndex", "(", "MI", ")", ".", "getRegSlot", "(", ")", ")", ";", "LIS", ".", "RemoveMachineInstrFromMaps", "(", "MI", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "\"OptimizeLiveIntervals expects liveness\"", "4", "0", "WebAssembly", "0", "WebAssembly", "0", "0" ]

[]

[ "<s>", "int", "nds32_can_use_bitci_p", "(", "int", "ival", ")", "{", "return", "(", "TARGET_ISA_V3", "&&", "(", "ival", "<", "0", ")", "&&", "satisfies_constraint_Iu15", "(", "gen_int_mode", "(", "~", "ival", ",", "SImode", ")", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "check", "if", "'bitci", "'", "instruction", "can", "be", "used", "with", "IVAL", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "int", "h8300_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "h8300_current_function_interrupt_function_p", "(", ")", "&&", "!", "regs_ever_live", "[", "new_reg", "]", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "." ]

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

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "getRegForGEPIndex", "(", "const", "Value", "*", "Idx", ")", "{", "unsigned", "IdxN", "=", "getRegForValue", "(", "Idx", ")", ";", "if", "(", "IdxN", "==", "0", ")", "return", "0", ";", "MVT", "PtrVT", "=", "TLI", ".", "getPointerTy", "(", "DL", ")", ";", "EVT", "IdxVT", "=", "EVT", "::", "getEVT", "(", "Idx", "->", "getType", "(", ")", ",", "false", ")", ";", "if", "(", "IdxVT", ".", "bitsLT", "(", "PtrVT", ")", ")", "{", "IdxN", "=", "emitIntExt", "(", "IdxVT", ".", "getSimpleVT", "(", ")", ",", "IdxN", ",", "PtrVT", ",", "false", ")", ";", "}", "else", "if", "(", "IdxVT", ".", "bitsGT", "(", "PtrVT", ")", ")", "llvm_unreachable", "(", "\"AArch64 FastISel doesn't support types larger than i64\"", ")", ";", "return", "IdxN", ";", "}", "</s>" ]

[ "This", "is", "a", "wrapper", "around", "getRegForValue", "that", "also", "takes", "care", "of", "truncating", "or", "sign-extending", "the", "given", "getelementptr", "index", "value", "." ]

[ "AArch64", "AArch64", "0", "0", "\"AArch64 FastISel doesn't support types larger than i64\"" ]

[]

[ "<s>", "const", "TargetFrameLowering", "::", "SpillSlot", "*", "AMDGPUFrameLowering", "::", "getCalleeSavedSpillSlots", "(", "unsigned", "&", "NumEntries", ")", "const", "{", "NumEntries", "=", "0", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "getCalleeSavedSpillSlots", "-", "This", "method", "returns", "a", "pointer", "to", "an", "array", "of", "pairs", ",", "that", "contains", "an", "entry", "for", "each", "callee", "saved", "register", "that", "must", "be", "spilled", "to", "a", "particular", "stack", "location", "if", "it", "is", "spilled", "." ]

[ "R600", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "PTXFrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

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

[ "PTX", "PTX" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "(", "4", "-", "i", "-", "1", ")", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "Sparc", "0", "4", "4", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "HexagonRegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

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

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "AMDGPURegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "const", "ValueMapping", "*", ",", "8", ">", "OpdsMapping", "(", "MI", ".", "getNumOperands", "(", ")", ")", ";", "bool", "IsComplete", "=", "true", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "IsComplete", "=", "false", ";", "break", ";", "case", "AMDGPU", "::", "G_CONSTANT", ":", "{", "unsigned", "Size", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", ";", "OpdsMapping", "[", "0", "]", "=", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "Size", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "G_GEP", ":", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Size", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", ";", "OpdsMapping", "[", "i", "]", "=", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "SGPRRegBankID", ",", "Size", ")", ";", "}", "break", ";", "}", "case", "AMDGPU", "::", "G_STORE", ":", "{", "assert", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", ")", ";", "unsigned", "Size", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", ";", "const", "ValueMapping", "*", "ValMapping", "=", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "Size", ")", ";", "const", "ValueMapping", "*", "PtrMapping", "=", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "64", ")", ";", "OpdsMapping", "[", "0", "]", "=", "ValMapping", ";", "OpdsMapping", "[", "1", "]", "=", "PtrMapping", ";", "break", ";", "}", "case", "AMDGPU", "::", "G_LOAD", ":", "return", "getInstrMappingForLoad", "(", "MI", ")", ";", "}", "if", "(", "!", "IsComplete", ")", "{", "unsigned", "BankID", "=", "AMDGPU", "::", "SGPRRegBankID", ";", "unsigned", "Size", "=", "0", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MI", ".", "getNumOperands", "(", ")", ";", "++", "Idx", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "Idx", ")", ".", "isReg", "(", ")", ")", "Size", "=", "getSizeInBits", "(", "MI", ".", "getOperand", "(", "Idx", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "*", "TRI", ")", ";", "OpdsMapping", ".", "push_back", "(", "AMDGPU", "::", "getValueMapping", "(", "BankID", ",", "Size", ")", ")", ";", "}", "}", "return", "getInstructionMapping", "(", "1", ",", "1", ",", "getOperandsMapping", "(", "OpdsMapping", ")", ",", "MI", ".", "getNumOperands", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "8", "AMDGPU::G_CONSTANT", "0", "0", "AMDGPU::getValueMapping", "AMDGPU::SGPRRegBankID", "AMDGPU::G_GEP", "0", "AMDGPU::getValueMapping", "AMDGPU::SGPRRegBankID", "AMDGPU::G_STORE", "0", "0", "AMDGPU::getValueMapping", "AMDGPU::VGPRRegBankID", "AMDGPU::getValueMapping", "AMDGPU::VGPRRegBankID", "64", "0", "1", "AMDGPU::G_LOAD", "AMDGPU::SGPRRegBankID", "0", "0", "AMDGPU::getValueMapping", "1", "1" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"RegScavenger required for long branching\"", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "\"new block should be inserted for expanding unconditional branch\"", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "1", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "RISCVSubtarget", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "BrOffset", ")", ")", "report_fatal_error", "(", "\"Branch offsets outside of the signed 32-bit range not supported\"", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "unsigned", "PseudoOpcode", ";", "if", "(", "RISCVABI", "::", "isCheriPureCapABI", "(", "ST", ".", "getTargetABI", "(", ")", ")", ")", "{", "RC", "=", "&", "RISCV", "::", "GPCRRegClass", ";", "PseudoOpcode", "=", "RISCV", "::", "PseudoCJump", ";", "}", "else", "{", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "PseudoOpcode", "=", "RISCV", "::", "PseudoJump", ";", "}", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "auto", "II", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "PseudoOpcode", ")", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addMBB", "(", "&", "DestBB", ",", "RISCVII", "::", "MO_CALL", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "unsigned", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "*", "RC", ",", "MI", ".", "getIterator", "(", ")", ",", "false", ",", "0", ")", ";", "MRI", ".", "replaceRegWith", "(", "ScratchReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "return", "8", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "RISCV", "RISCV", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "RISCV", "RISCV", "32", "\"Branch offsets outside of the signed 32-bit range not supported\"", "RISCVABI::isCheriPureCapABI", "RISCV::GPCRRegClass", "RISCV::PseudoCJump", "RISCV::GPRRegClass", "RISCV::PseudoJump", "RISCVII::MO_CALL", "0", "8" ]

[]

[ "<s>", "int", "direct_return", "(", "void", ")", "{", "return", "(", "TARGET_ABI_OSF", "&&", "reload_completed", "&&", "alpha_sa_size", "(", ")", "==", "0", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "crtl", "->", "outgoing_args_size", "==", "0", "&&", "crtl", "->", "args", ".", "pretend_args_size", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "." ]

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "AVRRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "return", "&", "AVR", "::", "DREGSRegClass", ";", "}", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "return", "&", "AVR", "::", "GPR8RegClass", ";", "}", "llvm_unreachable", "(", "\"Invalid register size\"", ")", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "AVR", "AVR", "MVT::i16", "AVR::DREGSRegClass", "MVT::i8", "AVR::GPR8RegClass", "\"Invalid register size\"" ]

[]

[ "<s>", "void", "PIC16RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "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", ")", "." ]

[ "PIC16", "PIC16" ]

[]

[ "<s>", "bool", "MSP430TargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "N", ")", ";", "if", "(", "LD", "->", "getExtensionType", "(", ")", "!=", "ISD", "::", "NON_EXTLOAD", ")", "return", "false", ";", "EVT", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "return", "false", ";", "if", "(", "ConstantSDNode", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "{", "uint64_t", "RHSC", "=", "RHS", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i16", "&&", "RHSC", "!=", "2", ")", "||", "(", "VT", "==", "MVT", "::", "i8", "&&", "RHSC", "!=", "1", ")", ")", "return", "false", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "SDLoc", "(", "N", ")", ",", "VT", ")", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "MSP430", "MSP430", "ISD::MemIndexedMode", "ISD::NON_EXTLOAD", "MVT::i8", "MVT::i16", "ISD::ADD", "1", "MVT::i16", "2", "MVT::i8", "1", "0", "ISD::POST_INC" ]

[]

[ "<s>", "static", "rtx", "nvptx_static_chain", "(", "const_tree", "fndecl", ",", "bool", "incoming_p", ")", "{", "if", "(", "!", "DECL_STATIC_CHAIN", "(", "fndecl", ")", ")", "return", "NULL", ";", "if", "(", "incoming_p", ")", "return", "gen_rtx_REG", "(", "Pmode", ",", "STATIC_CHAIN_REGNUM", ")", ";", "else", "return", "gen_rtx_REG", "(", "Pmode", ",", "OUTGOING_STATIC_CHAIN_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_STATIC_CHAIN", "." ]

[ "nvptx" ]

[]

[ "<s>", "unsigned", "getByValTypeAlignment", "(", "Type", "*", "Ty", ",", "const", "DataLayout", "&", "DL", ")", "const", "override", "{", "return", "4", ";", "}", "</s>" ]

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

[ "Patmos", "4" ]

[]

[ "<s>", "bool", "rs6000_split_128bit_ok_p", "(", "rtx", "operands", "[", "]", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "false", ";", "if", "(", "!", "gpr_or_gpr_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "if", "(", "quad_load_store_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "128-bit", "move", "needs", "to", "be", "split", "." ]

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

[]

[ "<s>", "static", "void", "nds32_asm_function_epilogue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "fprintf", "(", "file", ",", "\"\\t! END EPILOGUE\\n\"", ")", ";", "}", "</s>" ]

[ "The", "content", "produced", "from", "this", "function", "will", "be", "placed", "after", "epilogue", "body", "." ]

[ "nds32", "\"\\t! END EPILOGUE\\n\"" ]

[]

[ "<s>", "static", "void", "visium_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "cumulative_args_t", "local_args_so_far", ";", "CUMULATIVE_ARGS", "local_copy", ";", "CUMULATIVE_ARGS", "*", "locargs", ";", "int", "gp_saved", ",", "fp_saved", ",", "size", ";", "local_args_so_far", ".", "p", "=", "&", "local_copy", ";", "locargs", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "local_args_so_far", ".", "magic", "=", "CUMULATIVE_ARGS_MAGIC", ";", "local_copy", ".", "grcount", "=", "locargs", "->", "grcount", ";", "local_copy", ".", "frcount", "=", "locargs", "->", "frcount", ";", "local_copy", ".", "stack_words", "=", "locargs", "->", "stack_words", ";", "TARGET_FUNCTION_ARG_ADVANCE", "(", "local_args_so_far", ",", "arg", ")", ";", "locargs", "=", "get_cumulative_args", "(", "local_args_so_far", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_GP_REGISTERS", "-", "locargs", "->", "grcount", ";", "fp_saved", "=", "(", "TARGET_FPU", "?", "MAX_ARGS_IN_FP_REGISTERS", "-", "locargs", "->", "frcount", ":", "0", ")", ";", "size", "=", "(", "gp_saved", "*", "UNITS_PER_WORD", ")", "+", "(", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ";", "if", "(", "!", "no_rtl", "&&", "size", ">", "0", ")", "{", "rtx", "ptr", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "size", ")", ")", ";", "if", "(", "gp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "ptr", ",", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "locargs", "->", "grcount", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "fp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "gcc_assert", "(", "UNITS_PER_WORD", "==", "UNITS_PER_HWFPVALUE", ")", ";", "move_block_from_reg", "(", "locargs", "->", "frcount", "+", "FP_ARG_FIRST", ",", "mem", ",", "fp_saved", ")", ";", "}", "}", "visium_reg_parm_save_area_size", "=", "size", ";", "}", "</s>" ]

[ "Store", "the", "anonymous", "register", "arguments", "into", "the", "stack", "so", "that", "all", "the", "arguments", "appear", "to", "have", "been", "passed", "consecutively", "on", "the", "stack", "." ]

[ "visium", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "HexagonMCInst", "::", "getUnits", "(", "const", "HexagonTargetMachine", "*", "TM", ")", "const", "{", "const", "HexagonInstrInfo", "*", "QII", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrItineraryData", "(", ")", ";", "const", "InstrStage", "*", "IS", "=", "II", "->", "beginStage", "(", "QII", "->", "get", "(", "this", "->", "getOpcode", "(", ")", ")", ".", "getSchedClass", "(", ")", ")", ";", "return", "(", "IS", "->", "getUnits", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "choice", "of", "FUs", "." ]

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "(", "MI", "->", "getOperand", "(", "4", ")", ".", "isCPI", "(", ")", "||", "(", "MI", "->", "getOperand", "(", "4", ")", ".", "isGlobal", "(", ")", "&&", "isGVStub", "(", "MI", "->", "getOperand", "(", "4", ")", ".", "getGlobal", "(", ")", ",", "TM", ")", ")", ")", ")", "{", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", ")", "return", "true", ";", "if", "(", "!", "ReMatPICStubLoad", "&&", "MI", "->", "getOperand", "(", "4", ")", ".", "isGlobal", "(", ")", ")", "return", "false", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isPICBase", "=", "false", ";", "for", "(", "MachineRegisterInfo", "::", "def_iterator", "I", "=", "MRI", ".", "def_begin", "(", "BaseReg", ")", ",", "E", "=", "MRI", ".", "def_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "DefMI", "=", "I", ".", "getOperand", "(", ")", ".", "getParent", "(", ")", ";", "if", "(", "DefMI", "->", "getOpcode", "(", ")", "!=", "X86", "::", "MOVPC32r", ")", "return", "false", ";", "assert", "(", "!", "isPICBase", "&&", "\"More than one PIC base?\"", ")", ";", "isPICBase", "=", "true", ";", "}", "return", "isPICBase", ";", "}", "return", "false", ";", "}", "case", "X86", "::", "LEA32r", ":", "case", "X86", "::", "LEA64r", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "!", "MI", "->", "getOperand", "(", "4", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp64m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MOVAPSrm", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "1", "2", "3", "3", "0", "4", "4", "4", "1", "0", "4", "X86::MOVPC32r", "\"More than one PIC base?\"", "X86::LEA32r", "X86::LEA64r", "2", "3", "3", "0", "4", "1", "1", "0" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TargetTriple", "(", "TT", ")", ",", "DL", "(", "computeDataLayout", "(", "TargetTriple", ")", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "TSInfo", "(", "DL", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ")", ",", "FrameLowering", "(", "TargetFrameLowering", "::", "StackGrowsDown", ",", "getStackAlignment", "(", ")", ",", "is64Bit", "(", ")", "?", "-", "8", ":", "-", "4", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "is64Bit", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "isTargetELF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "TVMTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerStore", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR", ":", "return", "LowerBR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TargetFrameIndex", ":", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "TVM", "TVM", "ISD::GlobalAddress", "ISD::LOAD", "ISD::STORE", "ISD::ExternalSymbol", "ISD::BR", "ISD::BRCOND", "ISD::TargetFrameIndex", "ISD::FrameIndex", "ISD::CopyToReg", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN", "\"unimplemented operand\"" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnablePromoteConstant", ")", "addPass", "(", "createAArch64PromoteConstantPass", "(", ")", ")", ";", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "{", "bool", "OnlyOptimizeForSize", "=", "(", "TM", "->", "getOptLevel", "(", ")", "<", "CodeGenOpt", "::", "Aggressive", ")", "&&", "(", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", ";", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "4095", ",", "OnlyOptimizeForSize", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAddressTypePromotion", ")", "addPass", "(", "createAArch64AddressTypePromotionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "output_v8plus_shift", "(", "rtx", "*", "operands", ",", "rtx", "insn", ",", "const", "char", "*", "opcode", ")", "{", "static", "char", "asm_code", "[", "60", "]", ";", "if", "(", "which_alternative", "!=", "2", ")", "operands", "[", "3", "]", "=", "operands", "[", "0", "]", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "operands", "[", "2", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "&", "0x3f", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "{", "output_asm_insn", "(", "\"mov\\t%1, %3\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"sllx\\t%H1, 32, %3\"", ",", "operands", ")", ";", "if", "(", "sparc_check_64", "(", "operands", "[", "1", "]", ",", "insn", ")", "<=", "0", ")", "output_asm_insn", "(", "\"srl\\t%L1, 0, %L1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"or\\t%L1, %3, %3\"", ",", "operands", ")", ";", "}", "strcpy", "(", "asm_code", ",", "opcode", ")", ";", "if", "(", "which_alternative", "!=", "2", ")", "return", "strcat", "(", "asm_code", ",", "\"\\t%0, %2, %L0\\n\\tsrlx\\t%L0, 32, %H0\"", ")", ";", "else", "return", "strcat", "(", "asm_code", ",", "\"\\t%3, %2, %3\\n\\tsrlx\\t%3, 32, %H0\\n\\tmov\\t%3, %L0\"", ")", ";", "}", "</s>" ]

[ "Returns", "assembly", "code", "to", "perform", "a", "DImode", "shift", "using", "a", "64-bit", "global", "or", "out", "register", "on", "SPARC-V8+", "." ]

[ "sparc", "60", "2", "3", "0", "2", "2", "2", "0x3f", "1", "\"mov\\t%1, %3\"", "\"sllx\\t%H1, 32, %3\"", "1", "0", "\"srl\\t%L1, 0, %L1\"", "\"or\\t%L1, %3, %3\"", "2", "\"\\t%0, %2, %L0\\n\\tsrlx\\t%L0, 32, %H0\"", "\"\\t%3, %2, %3\\n\\tsrlx\\t%3, 32, %H0\\n\\tmov\\t%3, %L0\"" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ";", "}", "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", "0", "X86::GR64RegClass", "X86::GR32RegClass", "X86::POP64r", "X86::POP32r", "0", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "bool", "m68k_matches_q_p", "(", "rtx", "x", ")", "{", "struct", "m68k_address", "address", ";", "return", "(", "m68k_legitimate_mem_p", "(", "x", ",", "&", "address", ")", "&&", "address", ".", "code", "==", "UNKNOWN", "&&", "address", ".", "base", "&&", "!", "address", ".", "offset", "&&", "!", "address", ".", "index", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "matches", "the", "'", "Q", "'", "constraint", ".", "It", "must", "be", "a", "memory", "with", "a", "base", "address", "and", "no", "constant", "offset", "or", "index", "." ]

[ "m68k" ]

[]

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

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

[ "OR1K" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", ";", "bool", "CRSpilled", "=", "false", ";", "MachineInstrBuilder", "CRMIB", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsCRField", "=", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "CRSpilled", "&&", "IsCRField", ")", "{", "CRMIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "continue", ";", "}", "if", "(", "IsCRField", ")", "{", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "FuncInfo", "->", "addMustSaveCR", "(", "Reg", ")", ";", "}", "else", "{", "CRSpilled", "=", "true", ";", "FuncInfo", "->", "setSpillsCR", "(", ")", ";", "CRMIB", "=", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "PPC", "::", "R12", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "CRMIB", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "addFrameReference", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "PPC", "::", "R12", ",", "getKillRegState", "(", "true", ")", ")", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ")", ";", "}", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0", "PPC::CR2", "PPC::CR4", "PPC", "PPC", "PPC", "PPC::MFCR", "PPC::R12", "PPC::STW", "PPC::R12" ]

[]

[ "<s>", "static", "void", "microblaze_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "arg_number", "++", ";", "switch", "(", "mode", ")", "{", "case", "VOIDmode", ":", "break", ";", "default", ":", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", ";", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "BLKmode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "int_size_in_bytes", "(", "type", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "SFmode", ":", "cum", "->", "arg_words", "++", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "1", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "DFmode", ":", "cum", "->", "arg_words", "+=", "2", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "2", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "DImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "2", ";", "break", ";", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "TImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "++", ";", "break", ";", "}", "}", "</s>" ]

[ "Advance", "the", "argument", "to", "the", "next", "argument", "position", "." ]

[ "microblaze", "1", "1", "1", "1", "2", "1", "1", "2", "2", "2", "2", "1", "2", "1", "2", "1" ]

[]

[ "<s>", "void", "alpha_emit_xfloating_cvt", "(", "enum", "rtx_code", "orig_code", ",", "rtx", "operands", "[", "]", ")", "{", "int", "noperands", "=", "1", ",", "mode", ";", "rtx", "out_operands", "[", "2", "]", ";", "rtx", "func", ";", "enum", "rtx_code", "code", "=", "orig_code", ";", "if", "(", "code", "==", "UNSIGNED_FIX", ")", "code", "=", "FIX", ";", "func", "=", "alpha_lookup_xfloating_lib_func", "(", "code", ")", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "1", "]", ";", "switch", "(", "code", ")", "{", "case", "FIX", ":", "mode", "=", "alpha_compute_xfloating_mode_arg", "(", "code", ",", "ALPHA_FPRM_CHOP", ")", ";", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "mode", ")", ";", "noperands", "=", "2", ";", "break", ";", "case", "FLOAT_TRUNCATE", ":", "mode", "=", "alpha_compute_xfloating_mode_arg", "(", "code", ",", "alpha_fprm", ")", ";", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "mode", ")", ";", "noperands", "=", "2", ";", "break", ";", "default", ":", "break", ";", "}", "alpha_emit_xfloating_libcall", "(", "func", ",", "operands", "[", "0", "]", ",", "out_operands", ",", "noperands", ",", "gen_rtx_fmt_e", "(", "orig_code", ",", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "X_floating", "library", "function", "call", "for", "a", "conversion", "." ]

[ "alpha", "1", "2", "0", "1", "1", "2", "1", "2", "0", "0", "1" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALLReg", ":", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "case", "RISCV", "::", "PseudoLLA", ":", "case", "RISCV", "::", "PseudoLA", ":", "case", "RISCV", "::", "PseudoLA_TLS_IE", ":", "case", "RISCV", "::", "PseudoLA_TLS_GD", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "RISCV", "RISCV", "0", "RISCV::PseudoCALLReg", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "RISCV::PseudoLLA", "RISCV::PseudoLA", "RISCV::PseudoLA_TLS_IE", "RISCV::PseudoLA_TLS_GD", "8", "RISCV", "0" ]

[]

[ "<s>", "static", "int", "visium_register_move_cost", "(", "enum", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "const", "int", "numwords", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ")", "?", "1", ":", "2", ";", "if", "(", "from", "==", "MDB", "||", "to", "==", "MDB", ")", "return", "4", ";", "else", "if", "(", "from", "==", "MDC", "||", "to", "==", "MDC", "||", "(", "from", "==", "FP_REGS", ")", "!=", "(", "to", "==", "FP_REGS", ")", ")", "return", "4", "*", "numwords", ";", "else", "return", "2", "*", "numwords", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "of", "mode", "MODE", "from", "a", "register", "in", "class", "FROM", "to", "one", "in", "class", "TO", ".", "A", "value", "of", "2", "is", "the", "default", ";", "other", "values", "are", "interpreted", "relative", "to", "that", "." ]

[ "visium", "1", "2", "4", "4", "2" ]

[]

[ "<s>", "static", "bool", "mips_valid_lo_sum_p", "(", "enum", "mips_symbol_type", "symbol_type", ",", "machine_mode", "mode", ")", "{", "if", "(", "mips_symbol_insns", "(", "symbol_type", ",", "mode", ")", "==", "0", ")", "return", "false", ";", "if", "(", "mips_lo_relocs", "[", "symbol_type", "]", "==", "NULL", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "LO_SUM", "can", "address", "a", "value", "of", "mode", "MODE", "when", "the", "LO_SUM", "symbol", "has", "type", "SYMBOL_TYPE", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "rtx", "rs6000_emit_stack_reset", "(", "rs6000_stack_t", "*", "info", ",", "rtx", "frame_reg_rtx", ",", "HOST_WIDE_INT", "frame_off", ",", "unsigned", "updt_regno", ")", "{", "if", "(", "frame_off", "==", "0", "&&", "REGNO", "(", "frame_reg_rtx", ")", "==", "updt_regno", ")", "return", "NULL_RTX", ";", "rtx", "updt_reg_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "updt_regno", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "(", "TARGET_SPE_ABI", "&&", "info", "->", "spe_64bit_regs_used", "!=", "0", "&&", "info", "->", "first_gp_reg_save", "!=", "32", ")", ")", "return", "emit_insn", "(", "gen_stack_restore_tie", "(", "updt_reg_rtx", ",", "frame_reg_rtx", ",", "GEN_INT", "(", "frame_off", ")", ")", ")", ";", "if", "(", "frame_off", "!=", "0", ")", "return", "emit_insn", "(", "gen_add3_insn", "(", "updt_reg_rtx", ",", "frame_reg_rtx", ",", "GEN_INT", "(", "frame_off", ")", ")", ")", ";", "else", "return", "emit_move_insn", "(", "updt_reg_rtx", ",", "frame_reg_rtx", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Emit", "a", "sequence", "of", "insns", ",", "including", "a", "stack", "tie", "if", "needed", ",", "for", "resetting", "the", "stack", "pointer", ".", "If", "UPDT_REGNO", "is", "not", "1", ",", "then", "do", "n't", "reset", "the", "stack", "pointer", ",", "but", "move", "the", "base", "of", "the", "frame", "into", "reg", "UPDT_REGNO", "for", "use", "by", "out-of-line", "register", "restore", "routines", "." ]

[ "powerpcspe", "0", "0", "32", "0" ]

[]

[ "<s>", "const", "DLXTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "machine_mode", "m", "=", "(", "machine_mode", ")", "i", ";", "switch", "(", "GET_MODE_CLASS", "(", "m", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "4", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "S_MODE", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "D_MODE", ")", ";", "else", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "V_MODE", ")", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CC_ZNmode", "||", "i", "==", "(", "int", ")", "CC_Zmode", "||", "i", "==", "(", "int", ")", "CC_Cmode", "||", "i", "==", "CC_FP_GTmode", "||", "i", "==", "CC_FP_GEmode", "||", "i", "==", "CC_FP_ORDmode", "||", "i", "==", "CC_FPUmode", "||", "i", "==", "CC_FPU_UNEQmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Initialize", "the", "arc_mode_class", "array", "." ]

[ "arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "arc_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "machine", "->", "fn_type", "=", "ARC_FUNCTION_UNKNOWN", ";", "machine", "->", "force_short_suffix", "=", "-", "1", ";", "return", "machine", ";", "}", "</s>" ]

[ "The", "usual", ";", "we", "set", "up", "our", "machine_function", "data", "." ]

[ "arc", "1" ]

[]

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

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "inline", "built_in_function", "complex_multiply_builtin_code", "(", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "IN_RANGE", "(", "mode", ",", "MIN_MODE_COMPLEX_FLOAT", ",", "MAX_MODE_COMPLEX_FLOAT", ")", ")", ";", "int", "func", "=", "BUILT_IN_COMPLEX_MUL_MIN", "+", "mode", "-", "MIN_MODE_COMPLEX_FLOAT", ";", "return", "(", "built_in_function", ")", "func", ";", "}", "</s>" ]

[ "Internal", "function", "to", "return", "the", "built-in", "function", "id", "for", "the", "complex", "multiply", "operation", "for", "a", "given", "mode", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "pdp11_output_labelref", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ")", "{", "if", "(", "!", "TARGET_DEC_ASM", ")", "fputs", "(", "USER_LABEL_PREFIX", ",", "file", ")", ";", "fputs", "(", "name", ",", "file", ")", ";", "}", "</s>" ]

[ "This", "emits", "a", "(", "user", ")", "label", ",", "which", "gets", "a", "``", "_", "''", "prefix", "except", "for", "DEC", "assembler", "output", "." ]

[ "pdp11" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "tilegx_emit_cc_test", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "cmp_mode", ",", "bool", "eq_ne_only", ")", "{", "enum", "rtx_code", "branch_code", ";", "rtx", "temp", ";", "if", "(", "cmp_mode", "==", "SFmode", "||", "cmp_mode", "==", "DFmode", ")", "{", "temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "tilegx_emit_setcc_internal", "(", "temp", ",", "code", ",", "op0", ",", "op1", ",", "cmp_mode", ")", ";", "return", "gen_rtx_fmt_ee", "(", "NE", ",", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "if", "(", "op1", "==", "const0_rtx", "&&", "(", "code", "==", "EQ", "||", "code", "==", "NE", "||", "(", "!", "eq_ne_only", "&&", "signed_compare_p", "(", "code", ")", ")", ")", ")", "{", "op0", "=", "force_reg", "(", "cmp_mode", ",", "op0", ")", ";", "return", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "op0", ",", "const0_rtx", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "branch_code", "=", "NE", ";", "break", ";", "case", "NE", ":", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "code", "=", "reverse_condition", "(", "code", ")", ";", "branch_code", "=", "EQ", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "CONST_INT_P", "(", "op1", ")", "&&", "(", "!", "satisfies_constraint_I", "(", "op1", ")", "||", "code", "==", "LEU", ")", ")", "{", "HOST_WIDE_INT", "n", "=", "INTVAL", "(", "op1", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "if", "(", "n", "!=", "-", "128", "&&", "add_operand", "(", "GEN_INT", "(", "-", "n", ")", ",", "DImode", ")", "&&", "!", "(", "symbolic_operand", "(", "op0", ",", "VOIDmode", ")", "||", "(", "REG_P", "(", "op0", ")", "&&", "REG_POINTER", "(", "op0", ")", ")", ")", ")", "{", "if", "(", "GET_MODE", "(", "op0", ")", "!=", "DImode", ")", "{", "rtx", "temp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_extendsidi2", "(", "temp2", ",", "op0", ")", ")", ";", "op0", "=", "temp2", ";", "}", "else", "{", "op0", "=", "force_reg", "(", "DImode", ",", "op0", ")", ";", "}", "temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_PLUS", "(", "DImode", ",", "op0", ",", "GEN_INT", "(", "-", "n", ")", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "reverse_condition", "(", "branch_code", ")", ",", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "break", ";", "case", "LEU", ":", "if", "(", "n", "==", "-", "1", ")", "break", ";", "case", "LTU", ":", "{", "int", "first", "=", "exact_log2", "(", "code", "==", "LTU", "?", "n", ":", "n", "+", "1", ")", ";", "if", "(", "first", "!=", "-", "1", ")", "{", "op0", "=", "force_reg", "(", "cmp_mode", ",", "op0", ")", ";", "temp", "=", "gen_reg_rtx", "(", "cmp_mode", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_ASHIFTRT", "(", "cmp_mode", ",", "op0", ",", "GEN_INT", "(", "first", ")", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "reverse_condition", "(", "branch_code", ")", ",", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "}", "break", ";", "default", ":", "break", ";", "}", "}", "temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "tilegx_emit_setcc_internal", "(", "temp", ",", "code", ",", "op0", ",", "op1", ",", "cmp_mode", ")", ";", "return", "gen_rtx_fmt_ee", "(", "branch_code", ",", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "comparison", "for", "a", "DImode", "conditional", "branch", "." ]

[ "tilegx", "128", "1", "1", "1" ]

[]

[ "<s>", "static", "tree", "avr_handle_progmem_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "TYPE_DECL", ")", "{", "tree", "type", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "tree", "attr", "=", "tree_cons", "(", "name", ",", "args", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "tree", "newtype", "=", "build_type_attribute_variant", "(", "type", ",", "attr", ")", ";", "TYPE_MAIN_VARIANT", "(", "newtype", ")", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "TREE_TYPE", "(", "*", "node", ")", "=", "newtype", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_STATIC", "(", "*", "node", ")", "||", "DECL_EXTERNAL", "(", "*", "node", ")", ")", "{", "if", "(", "DECL_INITIAL", "(", "*", "node", ")", "==", "NULL_TREE", "&&", "!", "DECL_EXTERNAL", "(", "*", "node", ")", ")", "{", "warning", "(", "0", ",", "\"only initialized variables can be placed into \"", "\"program memory area\"", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "else", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute ignored\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "progmem", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "avr", "0", "\"only initialized variables can be placed into \"", "\"program memory area\"", "\"%qs attribute ignored\"" ]

[]

[ "<s>", "static", "bool", "aarch64_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "R0_REGNUM", "||", "regno", "==", "R1_REGNUM", ")", "return", "true", ";", "if", "(", "regno", ">=", "V0_REGNUM", "&&", "regno", "<", "V0_REGNUM", "+", "HA_MAX_NUM_FLDS", ")", "return", "!", "TARGET_GENERAL_REGS_ONLY", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "TARGET_FUNCTION_VALUE_REGNO_P", ".", "Return", "true", "if", "REGNO", "is", "the", "number", "of", "a", "hard", "register", "in", "which", "the", "values", "of", "called", "function", "may", "come", "back", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "TVMTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM doesn't support non-C calling conventions\"", ")", ";", "if", "(", "IsVarArg", ")", "fail", "(", "DL", ",", "DAG", ",", "\"VarArg is not supported yet\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "TVM", "::", "ARGUMENTS", ")", ";", "auto", "*", "FI", "=", "MF", ".", "getInfo", "<", "TVMFunctionInfo", ">", "(", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"TVM hasn't implemented cons regs last arguments\"", ")", ";", "InVals", ".", "push_back", "(", "In", ".", "Used", "?", "DAG", ".", "getNode", "(", "TVMISD", "::", "ARGUMENT", ",", "DL", ",", "In", ".", "VT", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i257", ")", ")", ":", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ")", ";", "FI", "->", "addParam", "(", "In", ".", "VT", ")", ";", "}", "return", "SaveC0", "(", "Chain", ",", "DL", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "ISD::InputArg", "\"TVM doesn't support non-C calling conventions\"", "\"VarArg is not supported yet\"", "TVM::ARGUMENTS", "TVM", "ISD::InputArg", "\"TVM hasn't implemented inalloca arguments\"", "\"TVM hasn't implemented nest arguments\"", "\"TVM hasn't implemented cons regs arguments\"", "\"TVM hasn't implemented cons regs last arguments\"", "TVMISD::ARGUMENT", "MVT::i257" ]

[]

[ "<s>", "rtx", "aarch64_simd_expand_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", "==", "AARCH64_SIMD_BUILTIN_LANE_CHECK", ")", "{", "rtx", "totalsize", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "rtx", "elementsize", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "totalsize", ")", "&&", "CONST_INT_P", "(", "elementsize", ")", "&&", "UINTVAL", "(", "elementsize", ")", "!=", "0", "&&", "UINTVAL", "(", "totalsize", ")", "!=", "0", ")", "{", "rtx", "lane_idx", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "lane_idx", ")", ")", "aarch64_simd_lane_bounds", "(", "lane_idx", ",", "0", ",", "UINTVAL", "(", "totalsize", ")", "/", "UINTVAL", "(", "elementsize", ")", ",", "exp", ")", ";", "else", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"lane index must be a constant immediate\"", ")", ";", "}", "else", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"total size and element size must be a nonzero \"", "\"constant immediate\"", ")", ";", "return", "const0_rtx", ";", "}", "aarch64_simd_builtin_datum", "*", "d", "=", "&", "aarch64_simd_builtin_data", "[", "fcode", "-", "AARCH64_SIMD_PATTERN_START", "]", ";", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_simd_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "+", "1", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "int", "is_void", "=", "0", ";", "int", "k", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "1", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "1", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_index", ")", "args", "[", "k", "]", "=", "SIMD_ARG_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_pair_index", ")", "args", "[", "k", "]", "=", "SIMD_ARG_LANE_PAIR_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_quadtup_index", ")", "args", "[", "k", "]", "=", "SIMD_ARG_LANE_QUADTUP_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_struct_load_store_lane_index", ")", "args", "[", "k", "]", "=", "SIMD_ARG_STRUCT_LOAD_STORE_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_immediate", ")", "args", "[", "k", "]", "=", "SIMD_ARG_CONSTANT", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_maybe_immediate", ")", "{", "rtx", "arg", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "(", "expr_args_k", ")", ")", ")", ";", "bool", "op_const_int_p", "=", "(", "CONST_INT_P", "(", "arg", ")", "&&", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "predicate", ")", "(", "arg", ",", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "mode", ")", ")", ";", "args", "[", "k", "]", "=", "op_const_int_p", "?", "SIMD_ARG_CONSTANT", ":", "SIMD_ARG_COPY_TO_REG", ";", "}", "else", "args", "[", "k", "]", "=", "SIMD_ARG_COPY_TO_REG", ";", "}", "args", "[", "k", "]", "=", "SIMD_ARG_STOP", ";", "return", "aarch64_simd_expand_args", "(", "target", ",", "icode", ",", "!", "is_void", ",", "exp", ",", "&", "args", "[", "1", "]", ",", "d", "->", "mode", ")", ";", "}", "</s>" ]

[ "Expand", "an", "AArch64", "AdvSIMD", "builtin", "(", "intrinsic", ")", "." ]

[ "aarch64", "0", "1", "0", "0", "2", "0", "\"lane index must be a constant immediate\"", "\"total size and element size must be a nonzero \"", "\"constant immediate\"", "1", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "MCRegisterInfo", "&", ",", "const", "Triple", "&", "TT", ")", "{", "if", "(", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "return", "new", "WebAssemblyMCAsmInfoELF", "(", "TT", ")", ";", "return", "new", "WebAssemblyMCAsmInfo", "(", "TT", ")", ";", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"rvex VLIW Packetizer\"", ";", "}", "</s>" ]

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

[ "rvex", "\"rvex VLIW Packetizer\"" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "Mask", ",", "int", "&", "Value", ")", "const", "{", "assert", "(", "MI", ".", "isCompare", "(", ")", "&&", "\"Caller should have checked for a comparison\"", ")", ";", "if", "(", "MI", ".", "getNumExplicitOperands", "(", ")", "==", "2", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "{", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "Value", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Mask", "=", "~", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Caller should have checked for a comparison\"", "2", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "virtual", "const", "AMDGPUInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "InstrInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TargetMachine", "&", "Target", "=", "const_cast", "<", "TargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "assert", "(", "(", "Target", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "Target", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "JTI", "=", "static_cast", "<", "ARMJITInfo", "*", ">", "(", "Target", ".", "getJITInfo", "(", ")", ")", ";", "II", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Target", ".", "getInstrInfo", "(", ")", ")", ";", "TD", "=", "Target", ".", "getDataLayout", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "IsThumb", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "0", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "static", "int", "getMemScale", "(", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode has unknown scale!\"", ")", ";", "case", "AArch64", "::", "LDRBBui", ":", "case", "AArch64", "::", "LDURBBi", ":", "case", "AArch64", "::", "LDRSBWui", ":", "case", "AArch64", "::", "LDURSBWi", ":", "case", "AArch64", "::", "STRBBui", ":", "case", "AArch64", "::", "STURBBi", ":", "return", "1", ";", "case", "AArch64", "::", "LDRHHui", ":", "case", "AArch64", "::", "LDURHHi", ":", "case", "AArch64", "::", "LDRSHWui", ":", "case", "AArch64", "::", "LDURSHWi", ":", "case", "AArch64", "::", "STRHHui", ":", "case", "AArch64", "::", "STURHHi", ":", "return", "2", ";", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDURSi", ":", "case", "AArch64", "::", "LDRSWui", ":", "case", "AArch64", "::", "LDURSWi", ":", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDURWi", ":", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STURSi", ":", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STURWi", ":", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "LDPSWi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "STPWi", ":", "return", "4", ";", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDURDi", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDURXi", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STURDi", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STURXi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "STPXi", ":", "return", "8", ";", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "STPQi", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Scaling", "factor", "for", "(", "scaled", "or", "unscaled", ")", "load", "or", "store", "." ]

[ "AArch64", "\"Opcode has unknown scale!\"", "AArch64::LDRBBui", "AArch64::LDURBBi", "AArch64::LDRSBWui", "AArch64::LDURSBWi", "AArch64::STRBBui", "AArch64::STURBBi", "1", "AArch64::LDRHHui", "AArch64::LDURHHi", "AArch64::LDRSHWui", "AArch64::LDURSHWi", "AArch64::STRHHui", "AArch64::STURHHi", "2", "AArch64::LDRSui", "AArch64::LDURSi", "AArch64::LDRSWui", "AArch64::LDURSWi", "AArch64::LDRWui", "AArch64::LDURWi", "AArch64::STRSui", "AArch64::STURSi", "AArch64::STRWui", "AArch64::STURWi", "AArch64::LDPSi", "AArch64::LDPSWi", "AArch64::LDPWi", "AArch64::STPSi", "AArch64::STPWi", "4", "AArch64::LDRDui", "AArch64::LDURDi", "AArch64::LDRXui", "AArch64::LDURXi", "AArch64::STRDui", "AArch64::STURDi", "AArch64::STRXui", "AArch64::STURXi", "AArch64::LDPDi", "AArch64::LDPXi", "AArch64::STPDi", "AArch64::STPXi", "8", "AArch64::LDRQui", "AArch64::LDURQi", "AArch64::STRQui", "AArch64::STURQi", "AArch64::LDPQi", "AArch64::STPQi", "16" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "XCoreFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "LLVM_DEBUG", "(", "MI", ".", "print", "(", "errs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "StackSize", ";", "Register", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "assert", "(", "Offset", "%", "4", "==", "0", "&&", "\"Misaligned stack offset\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "Offset", "/=", "4", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "XCore", "::", "GRRegsRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "isImmUs", "(", "Offset", ")", ")", "InsertFPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ")", ";", "else", "InsertFPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ",", "RS", ")", ";", "}", "else", "{", "if", "(", "isImmU16", "(", "Offset", ")", ")", "InsertSPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ")", ";", "else", "InsertSPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ",", "RS", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "0", "\"Unexpected\"", "XCore", "XCore", "XCore", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "1", "1", "1", "0", "4", "0", "\"Misaligned stack offset\"", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "4", "0", "XCore::GRRegsRegClass", "\"Unexpected register operand\"" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "lowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", "||", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewOp0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_W_X_RV64", ",", "DL", ",", "MVT", "::", "f32", ",", "NewOp0", ")", ";", "return", "FPConv", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::GlobalTLSAddress", "ISD::SELECT", "ISD::BUILD_VECTOR", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::BITCAST", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "MVT::i32", "ISD::ANY_EXTEND", "MVT::i64", "RISCVISD::FMV_W_X_RV64", "MVT::f32" ]

[]

[ "<s>", "void", "SHUXIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "4", ",", "-", "4", ",", "true", ")", ";", "(", "void", ")", "FrameIdx", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectIndexBegin", "(", ")", "&&", "\"Slot for FP register must be last in order to be found!\"", ")", ";", "}", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "4", "4", "\"Slot for FP register must be last in order to be found!\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "bool", "Is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_X86", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "(", "CopyVT", "==", "MVT", "::", "f32", "||", "CopyVT", "==", "MVT", "::", "f64", ")", "&&", "(", "(", "Is64Bit", "||", "Ins", "[", "i", "]", ".", "Flags", ".", "isInReg", "(", ")", ")", "&&", "!", "Subtarget", "->", "hasXMM", "(", ")", ")", ")", "{", "report_fatal_error", "(", "\"SSE register return with SSE disabled\"", ")", ";", "}", "SDValue", "Val", ";", "if", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "ST0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "ST1", ")", "{", "if", "(", "isScalarFPTypeInSSEReg", "(", "VA", ".", "getValVT", "(", ")", ")", ")", "CopyVT", "=", "MVT", "::", "f80", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "InFlag", "}", ";", "Chain", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "X86", "::", "FpPOP_RETVAL", ",", "dl", ",", "CopyVT", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ",", "Ops", ",", "2", ")", ",", "1", ")", ";", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "CopyVT", "!=", "VA", ".", "getValVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ")", ")", ";", "}", "else", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "}", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::InputArg", "16", "X86", "0", "MVT::f32", "MVT::f64", "\"SSE register return with SSE disabled\"", "X86::ST0", "X86::ST1", "MVT::f80", "X86::FpPOP_RETVAL", "MVT::Other", "MVT::Glue", "2", "1", "0", "ISD::FP_ROUND", "1", "1", "0", "2" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "CPURegsRegisterClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "FGR32RegisterClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "if", "(", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", "&&", "(", "!", "Subtarget", "->", "isFP64bit", "(", ")", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "AFGR64RegisterClass", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "0", "0U", "Mips::CPURegsRegisterClass", "MVT::f32", "0U", "Mips::FGR32RegisterClass", "MVT::f64", "0U", "Mips::AFGR64RegisterClass" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "assert", "(", "!", "MO", ".", "getSubReg", "(", ")", "&&", "\"Subregs should be eliminated!\"", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetARMGVSymbol", "(", "MO", ".", "getGlobal", "(", ")", ",", "MO", ".", "getTargetFlags", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "if", "(", "Subtarget", "->", "genExecuteOnly", "(", ")", ")", "llvm_unreachable", "(", "\"execute-only should not generate constant pools\"", ")", ";", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "APFloat", "Val", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "bool", "ignored", ";", "Val", ".", "convert", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "APFloat", "::", "rmTowardZero", ",", "&", "ignored", ")", ";", "MCOp", "=", "MCOperand", "::", "createFPImm", "(", "Val", ".", "convertToDouble", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "ARM", "ARM", "\"unknown operand type\"", "\"Subregs should be eliminated!\"", "ARM", "\"execute-only should not generate constant pools\"" ]

[]

[ "<s>", "void", "IA64RegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "IA64", "::", "RET", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "unsigned", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "MOV", ")", ",", "IA64", "::", "r12", ")", ".", "addReg", "(", "IA64", "::", "r5", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "LD8", ")", ",", "IA64", "::", "r5", ")", ".", "addReg", "(", "IA64", "::", "r5", ")", ";", "}", "if", "(", "NumBytes", "!=", "0", ")", "{", "if", "(", "NumBytes", "<=", "8191", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "ADDIMM22", ")", ",", "IA64", "::", "r12", ")", ".", "addReg", "(", "IA64", "::", "r12", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "MOVLIMM64", ")", ",", "IA64", "::", "r22", ")", ".", "addImm", "(", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "IA64", "::", "ADD", ")", ",", "IA64", "::", "r12", ")", ".", "addReg", "(", "IA64", "::", "r12", ")", ".", "addReg", "(", "IA64", "::", "r22", ")", ";", "}", "}", "}", "</s>" ]

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

[ "IA64", "IA64", "IA64::RET", "\"Can only insert epilog into returning blocks\"", "IA64::MOV", "IA64::r12", "IA64::r5", "IA64::LD8", "IA64::r5", "IA64::r5", "0", "8191", "IA64::ADDIMM22", "IA64::r12", "IA64::r12", "IA64::MOVLIMM64", "IA64::r22", "IA64::ADD", "IA64::r12", "IA64::r12", "IA64::r22" ]

[]