Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "rtx", "frv_expand_binop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "call", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "call", ",", "1", ")", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "2", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "two", "operands", "." ]

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

[]

[ "<s>", "bool", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "bool", "Ret", "=", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "processFunctionAfterISel", "(", "MF", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "arm_output_fn_unwind", "(", "FILE", "*", "f", ",", "bool", "prologue", ")", "{", "if", "(", "!", "ARM_EABI_UNWIND_TABLES", ")", "return", ";", "if", "(", "prologue", ")", "fputs", "(", "\"\\t.fnstart\\n\"", ",", "f", ")", ";", "else", "fputs", "(", "\"\\t.fnend\\n\"", ",", "f", ")", ";", "}", "</s>" ]

[ "Output", "unwind", "directives", "for", "the", "start/end", "of", "a", "function", "." ]

[ "arm", "\"\\t.fnstart\\n\"", "\"\\t.fnend\\n\"" ]

[]

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

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

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

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Outs", ".", "size", "(", ")", "<=", "1", "&&", "\"WebAssembly can only return up to one value\"", ")", ";", "if", "(", "CallConv", "!=", "CallingConv", "::", "C", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "if", "(", "IsVarArg", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support varargs yet\"", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "RETURN", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1", "\"WebAssembly can only return up to one value\"", "\"WebAssembly doesn't support non-C calling conventions\"", "\"WebAssembly doesn't support varargs yet\"", "4", "1", "WebAssemblyISD::RETURN", "MVT::Other" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "s390_register_info_stdarg_gpr", "(", ")", "{", "int", "i", ";", "int", "min_gpr", ";", "int", "max_gpr", ";", "if", "(", "!", "cfun", "->", "stdarg", "||", "!", "cfun", "->", "va_list_gpr_size", "||", "crtl", "->", "args", ".", "info", ".", "gprs", ">=", "GP_ARG_NUM_REG", ")", "return", ";", "min_gpr", "=", "crtl", "->", "args", ".", "info", ".", "gprs", ";", "max_gpr", "=", "min_gpr", "+", "cfun", "->", "va_list_gpr_size", "-", "1", ";", "if", "(", "max_gpr", ">=", "GP_ARG_NUM_REG", ")", "max_gpr", "=", "GP_ARG_NUM_REG", "-", "1", ";", "min_gpr", "+=", "GPR2_REGNUM", ";", "max_gpr", "+=", "GPR2_REGNUM", ";", "if", "(", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "GPR6_REGNUM", ")", ")", "&&", "min_gpr", "<=", "GPR6_REGNUM", "&&", "max_gpr", ">=", "GPR6_REGNUM", ")", "{", "if", "(", "cfun_frame_layout", ".", "first_restore_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "first_restore_gpr", ">", "GPR6_REGNUM", ")", "cfun_frame_layout", ".", "first_restore_gpr", "=", "GPR6_REGNUM", ";", "if", "(", "cfun_frame_layout", ".", "last_restore_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "last_restore_gpr", "<", "GPR6_REGNUM", ")", "cfun_frame_layout", ".", "last_restore_gpr", "=", "GPR6_REGNUM", ";", "}", "if", "(", "cfun_frame_layout", ".", "first_save_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "first_save_gpr", ">", "min_gpr", ")", "cfun_frame_layout", ".", "first_save_gpr", "=", "min_gpr", ";", "if", "(", "cfun_frame_layout", ".", "last_save_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "last_save_gpr", "<", "max_gpr", ")", "cfun_frame_layout", ".", "last_save_gpr", "=", "max_gpr", ";", "for", "(", "i", "=", "min_gpr", ";", "i", "<=", "max_gpr", ";", "i", "++", ")", "cfun_gpr_save_slot", "(", "i", ")", "=", "SAVE_SLOT_STACK", ";", "}", "</s>" ]

[ "Reserve", "the", "GPR", "save", "slots", "for", "GPRs", "which", "need", "to", "be", "saved", "due", "to", "stdarg", ".", "This", "is", "a", "helper", "routine", "for", "s390_register_info", "." ]

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

[]

[ "<s>", "unsigned", "X86FrameLowering", "::", "getWinEHFuncletFrameSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "CSSize", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getCalleeSavedFrameSize", "(", ")", ";", "unsigned", "MaxCallSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "FrameSizeMinusRBP", "=", "RoundUpToAlignment", "(", "CSSize", "+", "MaxCallSize", ",", "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>", "unsigned", "int", "rs6000_special_round_type_align", "(", "tree", "type", ",", "unsigned", "int", "computed", ",", "unsigned", "int", "specified", ")", "{", "unsigned", "int", "align", "=", "MAX", "(", "computed", ",", "specified", ")", ";", "if", "(", "TYPE_PACKED", "(", "type", ")", "||", "align", ">=", "64", ")", "return", "align", ";", "do", "{", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", "||", "DECL_FIELD_ABI_IGNORED", "(", "field", ")", ")", ")", "field", "=", "DECL_CHAIN", "(", "field", ")", ";", "if", "(", "!", "field", ")", "break", ";", "if", "(", "DECL_PACKED", "(", "field", ")", ")", "return", "align", ";", "type", "=", "TREE_TYPE", "(", "field", ")", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "}", "while", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "type", "!=", "error_mark_node", "&&", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "||", "TYPE_MODE", "(", "type", ")", "==", "DCmode", ")", ")", "align", "=", "MAX", "(", "align", ",", "64", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Darwin", ",", "AIX", "increases", "natural", "record", "alignment", "to", "doubleword", "if", "the", "first", "field", "is", "an", "FP", "double", "while", "the", "FP", "fields", "remain", "word", "aligned", "." ]

[ "rs6000", "64", "64" ]

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"requiresRegisterScavenging failed\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "XCore", "::", "GRRegsRegClass", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "unsigned", "Size", "=", "TRI", ".", "getSpillSize", "(", "RC", ")", ";", "Align", "Alignment", "=", "TRI", ".", "getSpillAlign", "(", "RC", ")", ";", "if", "(", "XFI", "->", "isLargeFrame", "(", "MF", ")", "||", "hasFP", "(", "MF", ")", ")", "RS", "->", "addScavengingFrameIndex", "(", "MFI", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "false", ")", ")", ";", "if", "(", "XFI", "->", "isLargeFrame", "(", "MF", ")", "&&", "!", "hasFP", "(", "MF", ")", ")", "RS", "->", "addScavengingFrameIndex", "(", "MFI", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "false", ")", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\"requiresRegisterScavenging failed\"", "XCore::GRRegsRegClass", "XCore", "XCore" ]

[]

[ "<s>", "InstructionCost", "RISCVTTIImpl", "::", "getRegUsageForType", "(", "Type", "*", "Ty", ")", "{", "TypeSize", "Size", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", ")", "{", "if", "(", "Size", ".", "isScalable", "(", ")", "&&", "ST", "->", "hasVInstructions", "(", ")", ")", "return", "divideCeil", "(", "Size", ".", "getKnownMinValue", "(", ")", ",", "RISCV", "::", "RVVBitsPerBlock", ")", ";", "if", "(", "ST", "->", "useRVVForFixedLengthVectors", "(", ")", ")", "return", "divideCeil", "(", "Size", ",", "ST", "->", "getMinRVVVectorSizeInBits", "(", ")", ")", ";", "}", "return", "BaseT", "::", "getRegUsageForType", "(", "Ty", ")", ";", "}", "</s>" ]

[ "Returns", "the", "estimated", "number", "of", "registers", "required", "to", "represent", "Ty", "." ]

[ "RISCV", "RISCV", "RISCV::RVVBitsPerBlock" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SparcTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "SP", "::", "IntRegsRegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "0", "0U", "SP::IntRegsRegisterClass" ]

[]

[ "<s>", "unsigned", "PatmosInstrInfo", "::", "getIssueWidth", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "return", "PST", ".", "getSchedModel", "(", ")", "->", "IssueWidth", ";", "return", "PST", ".", "getIssueWidth", "(", "MI", "->", "getDesc", "(", ")", ".", "SchedClass", ")", ";", "}", "</s>" ]

[ "Maximum", "number", "of", "micro-ops", "that", "may", "be", "scheduled", "per", "cycle", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "void", "aarch64_asm_output_pool_epilogue", "(", "FILE", "*", "f", ",", "const", "char", "*", ",", "tree", ",", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "(", "offset", "&", "3", ")", "&&", "aarch64_can_use_per_function_literal_pools_p", "(", ")", ")", "ASM_OUTPUT_ALIGN", "(", "f", ",", "2", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_POOL_EPILOGUE", "." ]

[ "aarch64", "3", "2" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "GPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tcGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "rGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "GPRnopcRegClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "DestReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_rGPRRegClass", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_0", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_1", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::tGPRRegClass", "ARM::tcGPRRegClass", "ARM::rGPRRegClass", "ARM::GPRnopcRegClass", "ARM::t2LDRi12", "0", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_rGPRRegClass", "ARM::t2LDRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "ARM" ]

[]

[ "<s>", "BitVector", "Z80RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "auto", "vec", "=", "BitVector", "(", "getNumRegs", "(", ")", ")", ";", "vec", ".", "set", "(", "Z80", "::", "SP", ")", ";", "vec", ".", "set", "(", "Z80", "::", "flags", ")", ";", "return", "vec", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80::SP", "Z80::flags" ]

[]

[ "<s>", "bool", "AMDGPUInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "const", "{", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCOPY", "(", "I", ")", ";", "return", "true", ";", "}", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "return", "selectG_ADD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTTOPTR", ":", "case", "TargetOpcode", "::", "G_BITCAST", ":", "return", "selectCOPY", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "selectG_CONSTANT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectG_EXTRACT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "selectG_GEP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "return", "selectG_IMPLICIT_DEF", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectG_INSERT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC", ":", "return", "selectG_INTRINSIC", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ":", "return", "selectG_INTRINSIC_W_SIDE_EFFECTS", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ICMP", ":", "return", "selectG_ICMP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "if", "(", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ")", "return", "true", ";", "return", "selectG_LOAD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_SELECT", ":", "return", "selectG_SELECT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "selectG_STORE", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_TRUNC", ":", "return", "selectG_TRUNC", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_SEXT", ":", "case", "TargetOpcode", "::", "G_ZEXT", ":", "case", "TargetOpcode", "::", "G_ANYEXT", ":", "if", "(", "selectG_SZA_EXT", "(", "I", ")", ")", "{", "I", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

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

[]

[ "<s>", "static", "bool", "mips_use_debug_exception_return_p", "(", "tree", "type", ")", "{", "return", "lookup_attribute", "(", "\"use_debug_exception_return\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", "!=", "NULL", ";", "}", "</s>" ]

[ "Check", "if", "the", "attribute", "to", "use", "debug", "exception", "return", "is", "set", "for", "a", "function", "." ]

[ "mips", "\"use_debug_exception_return\"" ]

[]

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

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

[ "SNES", "MVT::i8" ]

[]

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

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

[ "MINA32", "MINA32" ]

[]

[ "<s>", "static", "inline", "MemOpKey", "getEmptyKey", "(", ")", "{", "return", "MemOpKey", "(", "PtrInfo", "::", "getEmptyKey", "(", ")", ",", "PtrInfo", "::", "getEmptyKey", "(", ")", ",", "PtrInfo", "::", "getEmptyKey", "(", ")", ",", "PtrInfo", "::", "getEmptyKey", "(", ")", ",", "PtrInfo", "::", "getEmptyKey", "(", ")", ")", ";", "}", "</s>" ]

[ "Empty", "key", ":", "no", "key", "should", "be", "generated", "that", "has", "no", "DILocalVariable", "." ]

[ "X86" ]

[]

[ "<s>", "void", "avr_log_set_avr_log", "(", "void", ")", "{", "bool", "all", "=", "TARGET_ALL_DEBUG", "!=", "0", ";", "if", "(", "all", ")", "avr_log_details", "=", "\"all\"", ";", "if", "(", "all", "||", "avr_log_details", ")", "{", "char", "*", "str", "=", "(", "char", "*", ")", "alloca", "(", "3", "+", "strlen", "(", "avr_log_details", ")", ")", ";", "bool", "info", ";", "str", "[", "0", "]", "=", "','", ";", "strcat", "(", "stpcpy", "(", "str", "+", "1", ",", "avr_log_details", ")", ",", "\",\"", ")", ";", "all", "|=", "NULL", "!=", "strstr", "(", "str", ",", "\",all,\"", ")", ";", "info", "=", "NULL", "!=", "strstr", "(", "str", ",", "\",?,\"", ")", ";", "if", "(", "info", ")", "fprintf", "(", "stderr", ",", "\"\\n-mlog=\"", ")", ";", "do", "{", "\\", "avr_log", ".", "S", "=", "(", "all", "||", "NULL", "!=", "strstr", "(", "str", ",", "\",\"", "#", "S", "\",\"", ")", ")", ";", "\\", "if", "(", "info", ")", "\\", "fprintf", "(", "stderr", ",", "#", "S", "\",\"", ")", ";", "\\", "}", "while", "(", "0", ")", "SET_DUMP_DETAIL", "(", "address_cost", ")", ";", "SET_DUMP_DETAIL", "(", "builtin", ")", ";", "SET_DUMP_DETAIL", "(", "constraints", ")", ";", "SET_DUMP_DETAIL", "(", "legitimate_address_p", ")", ";", "SET_DUMP_DETAIL", "(", "legitimize_address", ")", ";", "SET_DUMP_DETAIL", "(", "legitimize_reload_address", ")", ";", "SET_DUMP_DETAIL", "(", "progmem", ")", ";", "SET_DUMP_DETAIL", "(", "rtx_costs", ")", ";", "if", "(", "info", ")", "fprintf", "(", "stderr", ",", "\"?\\n\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Called", "from", "avr.cc", ":", "avr_option_override", "(", ")", ".", "Parse", "argument", "of", "-mlog=", "and", "set", "respective", "fields", "in", "avr_log", "." ]

[ "avr", "0", "\"all\"", "3", "0", "1", "\",\"", "\",all,\"", "\",?,\"", "\"\\n-mlog=\"", "\",\"", "\",\"", "\",\"", "0", "\"?\\n\\n\"" ]

[]

[ "<s>", "static", "tree", "resolve_vec_mul", "(", "resolution", "*", "res", ",", "tree", "*", "args", ",", "tree", "*", "types", ",", "location_t", "loc", ")", "{", "if", "(", "TREE_CODE", "(", "types", "[", "0", "]", ")", "!=", "VECTOR_TYPE", "||", "!", "lang_hooks", ".", "types_compatible_p", "(", "types", "[", "0", "]", ",", "types", "[", "1", "]", ")", ")", "{", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "switch", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "types", "[", "0", "]", ")", ")", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "*", "res", "=", "resolved", ";", "return", "fold_build2_loc", "(", "loc", ",", "MULT_EXPR", ",", "types", "[", "0", "]", ",", "args", "[", "0", "]", ",", "fold_convert", "(", "types", "[", "0", "]", ",", "args", "[", "1", "]", ")", ")", ";", "case", "E_SFmode", ":", "{", "*", "res", "=", "resolved", ";", "tree", "call", "=", "rs6000_builtin_decls", "[", "RS6000_BIF_XVMULSP", "]", ";", "return", "build_call_expr", "(", "call", ",", "2", ",", "args", "[", "0", "]", ",", "args", "[", "1", "]", ")", ";", "}", "case", "E_DFmode", ":", "{", "*", "res", "=", "resolved", ";", "tree", "call", "=", "rs6000_builtin_decls", "[", "RS6000_BIF_XVMULDP", "]", ";", "return", "build_call_expr", "(", "call", ",", "2", ",", "args", "[", "0", "]", ",", "args", "[", "1", "]", ")", ";", "}", "default", ":", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "}", "</s>" ]

[ "Resolve", "an", "overloaded", "vec_mul", "call", "and", "return", "a", "tree", "expression", "for", "the", "resolved", "call", "if", "successful", ".", "ARGS", "contains", "the", "arguments", "to", "the", "call", ".", "TYPES", "contains", "their", "types", ".", "RES", "must", "be", "set", "to", "indicate", "the", "status", "of", "the", "resolution", "attempt", ".", "LOC", "contains", "statement", "location", "information", "." ]

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "DataLayoutPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "StackProtector", ">", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ")", "{", "printInstruction", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "MI", "->", "getDesc", "(", ")", ".", "mayStore", "(", ")", "&&", "hasStoreToStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "MipsModuleDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"In MipsModuleDAGToDAGISel::runMachineFunction\\n\"", ")", ";", "TM", ".", "resetSubtarget", "(", "&", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"In MipsModuleDAGToDAGISel::runMachineFunction\\n\"" ]

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "AllValues", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "HexagonTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "STORE", ")", "return", "TargetLowering", "::", "LowerOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "Hexagon", "Hexagon", "ISD::STORE" ]

[]

[ "<s>", "bool", "AArch64PromoteConstant", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "LocalChange", "=", "false", ";", "SmallPtrSet", "<", "Constant", "*", ",", "8", ">", "AlreadyChecked", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "&", "F", ")", ")", "{", "for", "(", "Value", "*", "Op", ":", "I", ".", "operand_values", "(", ")", ")", "{", "Constant", "*", "Cst", "=", "dyn_cast", "<", "Constant", ">", "(", "Op", ")", ";", "if", "(", "Cst", "&&", "!", "isa", "<", "GlobalValue", ">", "(", "Cst", ")", "&&", "!", "isa", "<", "ConstantExpr", ">", "(", "Cst", ")", "&&", "AlreadyChecked", ".", "insert", "(", "Cst", ")", ".", "second", ")", "LocalChange", "|=", "promoteConstant", "(", "Cst", ")", ";", "}", "}", "return", "LocalChange", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "csky_label_mentioned_p", "(", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "csky_label_mentioned_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "csky_label_mentioned_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "references", "a", "LABEL_REF", "." ]

[ "csky", "1", "0", "1", "0" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "TargetMachine", "&", "TM", ",", "const", "Module", "&", "M", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ")", ":", "MipsArchVersion", "(", "Mips1", ")", ",", "MipsABI", "(", "O32", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasABICall", "(", "true", ")", ",", "HasAbsoluteCall", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasMulDivAdd", "(", "false", ")", ",", "HasMinMax", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", "{", "std", "::", "string", "CPU", "=", "\"mips1\"", ";", "MipsArchVersion", "=", "Mips1", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "const", "std", "::", "string", "&", "TT", "=", "M", ".", "getTargetTriple", "(", ")", ";", "SSectionThreshold", "=", "SSThreshold", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "if", "(", "TT", ".", "find", "(", "\"mipsallegrex\"", ")", "!=", "std", "::", "string", "::", "npos", "||", "TT", ".", "find", "(", "\"psp\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "MipsABI", "=", "EABI", ";", "IsSingleFloat", "=", "true", ";", "MipsArchVersion", "=", "Mips2", ";", "HasVFPU", "=", "true", ";", "HasSEInReg", "=", "true", ";", "HasBitCount", "=", "true", ";", "HasSwap", "=", "true", ";", "HasCondMov", "=", "true", ";", "}", "if", "(", "NotABICall", "||", "isABI_EABI", "(", ")", "||", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", ")", "HasABICall", "=", "false", ";", "if", "(", "HasABICall", "&&", "AbsoluteCall", ")", "HasAbsoluteCall", "=", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips1\"", "Mips", "Mips", "\"linux\"", "\"mipsallegrex\"", "\"psp\"", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "bool", "isUnknown", "(", ")", "const", "{", "return", "State", "==", "Unknown", ";", "}", "</s>" ]

[ "Tests", "if", "this", "MemDepResult", "represents", "a", "query", "which", "can", "not", "and/or", "will", "not", "be", "computed", "." ]

[ "RISCV" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "if", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "{", "auto", "*", "Assembler", "=", "getTargetStreamer", "(", ")", ".", "getStreamer", "(", ")", ".", "getAssemblerPtr", "(", ")", ";", "if", "(", "Assembler", "!=", "nullptr", ")", "{", "RISCVAsmBackend", "&", "MAB", "=", "static_cast", "<", "RISCVAsmBackend", "&", ">", "(", "Assembler", "->", "getBackend", "(", ")", ")", ";", "MAB", ".", "setForceRelocs", "(", ")", ";", "}", "}", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "unsigned", "OperandIdx", "=", "1", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "++", "OperandIdx", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV::FeatureRelax", "RISCV", "RISCV", "RISCV", "1", "\"unexpected token\"" ]

[]

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

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

[ "AArch64", "0" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addInstSelector", "(", ")", "{", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "&", "SIFixSGPRCopiesID", ")", ";", "addPass", "(", "createSILowerI1CopiesPass", "(", ")", ")", ";", "addPass", "(", "createSIFixupVectorISelPass", "(", ")", ")", ";", "addPass", "(", "createSIAddIMGInitPass", "(", ")", ")", ";", "addPass", "(", "&", "UnreachableMachineBlockElimID", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "h8300_constant_length", "(", "rtx", "constant", ")", "{", "if", "(", "GET_CODE", "(", "constant", ")", "==", "CONST_INT", "&&", "IN_RANGE", "(", "INTVAL", "(", "constant", ")", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "return", "2", ";", "if", "(", "Pmode", "==", "HImode", "||", "h8300_tiny_constant_address_p", "(", "constant", ")", ")", "return", "2", ";", "return", "4", ";", "}", "</s>" ]

[ "Return", "the", "size", "of", "the", "given", "address", "or", "displacement", "constant", "." ]

[ "h8300", "0x8000", "0x7fff", "2", "2", "4" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "emitFunctionStart", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "printInstruction", "(", "II", ")", ";", "++", "EmittedInsts", ";", "}", "O", "<<", "'\\n'", ";", "}", "emitFunctionEnd", "(", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"\\n\\n\"" ]

[]

[ "<s>", "static", "void", "mips_output_cplocal", "(", "void", ")", "{", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", "&&", "cfun", "->", "machine", "->", "global_pointer", ">", "0", "&&", "cfun", "->", "machine", "->", "global_pointer", "!=", "GLOBAL_POINTER_REGNUM", ")", "output_asm_insn", "(", "\".cplocal %+\"", ",", "0", ")", ";", "}", "</s>" ]

[ "If", "we", "'re", "generating", "n32", "or", "n64", "abicalls", ",", "and", "the", "current", "function", "does", "not", "use", "$", "28", "as", "its", "global", "pointer", ",", "emit", "a", "cplocal", "directive", ".", "Use", "pic_offset_table_rtx", "as", "the", "argument", "to", "the", "directive", "." ]

[ "mips", "0", "\".cplocal %+\"", "0" ]

[]

[ "<s>", "static", "bool", "microblaze_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_COMPLEX_FLOAT", ")", "==", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_COMPLEX_FLOAT", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "microblaze" ]

[]

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

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

[ "MOS", "MOS" ]

[]

[ "<s>", "AtomicOrdering", "getOrdering", "(", ")", "const", "{", "return", "Ordering", ";", "}", "</s>" ]

[ "Returns", "the", "ordering", "constraint", "of", "this", "store", "instruction", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "int", "loongarch_split_const_insns", "(", "rtx", "x", ")", "{", "unsigned", "int", "low", ",", "high", ";", "low", "=", "loongarch_const_insns", "(", "loongarch_subword", "(", "x", ",", "false", ")", ")", ";", "high", "=", "loongarch_const_insns", "(", "loongarch_subword", "(", "x", ",", "true", ")", ")", ";", "gcc_assert", "(", "low", ">", "0", "&&", "high", ">", "0", ")", ";", "return", "low", "+", "high", ";", "}", "</s>" ]

[ "X", "is", "a", "doubleword", "constant", "that", "can", "be", "handled", "by", "splitting", "it", "into", "two", "words", "and", "loading", "each", "word", "separately", ".", "Return", "the", "number", "of", "instructions", "required", "to", "do", "this", "." ]

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

[]

[ "<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", ";", "unsigned", "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>", "static", "tree", "arc_handle_aux_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "VAR_DECL", ")", "{", "error", "(", "\"%qE attribute only applies to variables\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "args", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "NON_LVALUE_EXPR", ")", "TREE_VALUE", "(", "args", ")", "=", "TREE_OPERAND", "(", "TREE_VALUE", "(", "args", ")", ",", "0", ")", ";", "tree", "arg", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute allows only an integer \"", "\"constant argument\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "VAR_DECL", ")", "{", "tree", "fntype", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "if", "(", "fntype", "&&", "TREE_CODE", "(", "fntype", ")", "==", "POINTER_TYPE", ")", "{", "tree", "attrs", "=", "tree_cons", "(", "get_identifier", "(", "\"aux\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ";", "TYPE_ATTRIBUTES", "(", "fntype", ")", "=", "attrs", ";", "}", "}", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "aux", "attribute", ".", "The", "auxiliary", "registers", "are", "addressed", "using", "special", "instructions", "lr", "and", "sr", ".", "The", "attribute", "'aux", "'", "indicates", "if", "a", "variable", "refers", "to", "the", "aux-regs", "and", "what", "is", "the", "register", "number", "desired", "." ]

[ "arc", "\"%qE attribute only applies to variables\"", "0", "\"%qE attribute allows only an integer \"", "\"constant argument\"", "\"aux\"" ]

[]

[ "<s>", "void", "TGSIMCInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "os", ",", "unsigned", "reg", ")", "const", "{", "os", "<<", "getRegisterName", "(", "reg", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI" ]

[]

[ "<s>", "static", "void", "emit_csky_regs_pop", "(", "unsigned", "long", "mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CSKY_NGPR_REGS", ";", "i", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "12", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", "+", "1", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "ret_rtx", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CSKY_NGPR_REGS", ";", "i", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "num_regs", ")", ";", "rtx", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "1", ")", "=", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "tmp", ")", ",", "UNSPEC_PUSHPOP_MULT", ")", ")", ";", "break", ";", "}", "for", "(", "j", "=", "2", ",", "i", "++", ";", "j", "<", "(", "num_regs", "+", "1", ")", ";", "i", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "j", "++", ";", "}", "par", "=", "emit_jump_insn", "(", "par", ")", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "pattern", "that", "we", "will", "recognize", "as", "a", "pop_multi", ".", "SAVED_REGS_MASK", "shows", "which", "registers", "need", "to", "be", "restored", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", "." ]

[ "csky", "0", "0", "1", "12", "1", "0", "0", "0", "1", "4", "0", "1", "1", "2", "1", "1", "0" ]

[]

[ "<s>", "bool", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ")", "const", "override", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "ARM", "32" ]

[]

[ "<s>", "void", "ia64_expand_vecint_cmov", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "bool", "negate", ";", "rtx", "cmp", ",", "x", ",", "ot", ",", "of", ";", "cmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "negate", "=", "ia64_expand_vecint_compare", "(", "code", ",", "mode", ",", "cmp", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ")", ";", "ot", "=", "operands", "[", "1", "+", "negate", "]", ";", "of", "=", "operands", "[", "2", "-", "negate", "]", ";", "if", "(", "ot", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "if", "(", "of", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "ot", ")", ";", "return", ";", "}", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "cmp", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "x", ",", "of", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "x", ")", ")", ";", "}", "else", "if", "(", "of", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "x", "=", "gen_rtx_AND", "(", "mode", ",", "cmp", ",", "ot", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "x", ")", ")", ";", "}", "else", "{", "rtx", "t", ",", "f", ";", "t", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "cmp", ",", "operands", "[", "1", "+", "negate", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "t", ",", "x", ")", ")", ";", "f", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "cmp", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "x", ",", "operands", "[", "2", "-", "negate", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "f", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_IOR", "(", "mode", ",", "t", ",", "f", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "x", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "an", "integral", "vector", "conditional", "move", "." ]

[ "ia64", "0", "3", "4", "5", "1", "2", "0", "0", "0", "1", "2", "0" ]

[]

[ "<s>", "bool", "ARCInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", ")", "&&", "\"Invalid ARC branch condition!\"", ")", ";", "Cond", "[", "2", "]", ".", "setImm", "(", "getOppositeBranchCondition", "(", "(", "ARCCC", "::", "CondCode", ")", "Cond", "[", "2", "]", ".", "getImm", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "ARC", "ARC", "3", "\"Invalid ARC branch condition!\"", "2", "ARCCC::CondCode", "2" ]

[]

[ "<s>", "bool", "WebAssembly", "::", "isCatch", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "CATCH_I32", ":", "case", "WebAssembly", "::", "CATCH_I64", ":", "case", "WebAssembly", "::", "CATCH_ALL", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "'true", "'", "if", "the", "clause", "and", "index", "Idx", "is", "a", "catch", "clause", "." ]

[ "WebAssembly", "WebAssembly::isCatch", "WebAssembly::CATCH_I32", "WebAssembly::CATCH_I64", "WebAssembly::CATCH_ALL" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred", ")", "const", "{", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "!=", "-", "1", ")", "{", "MachineOperand", "&", "PMO", "=", "MI", "->", "getOperand", "(", "PIdx", ")", ";", "PMO", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "1", "2" ]

[]

[ "<s>", "static", "void", "expand_block_set_2", "(", "rtx", "dst", ",", "rtx", "dst_reg", ",", "rtx", "value_rtx", ",", "rtx", "bytes_rtx", ")", "{", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "bytes_rtx", ")", ";", "unsigned", "int", "rem", "=", "bytes", "%", "2", ";", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "1", ")", ";", "emit_library_call", "(", "wrd_memset_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "GEN_INT", "(", "bytes", ">>", "1", ")", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "if", "(", "rem", "==", "0", ")", "return", ";", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "dst_reg", ")", ";", "bytes", "-=", "rem", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "convert_to_mode", "(", "QImode", ",", "value_rtx", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "set", "BYTES_RTX", "bytes", "of", "DST", "with", "address", "DST_REG", "to", "VALUE_RTX", "in", "2-byte", "chunks", "." ]

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

[]

[ "<s>", "inline", "static", "void", "aarch64_print_hint_for_core", "(", "const", "char", "*", "str", ")", "{", "aarch64_print_hint_for_core_or_arch", "(", "str", ",", "false", ")", ";", "}", "</s>" ]

[ "Print", "a", "hint", "with", "a", "suggestion", "for", "a", "core", "name", "that", "most", "closely", "resembles", "what", "the", "user", "passed", "in", "STR", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isTruncateFree", "(", "EVT", "SrcVT", ",", "EVT", "DstVT", ")", "const", "{", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", "||", "!", "SrcVT", ".", "isInteger", "(", ")", "||", "!", "DstVT", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "SrcBits", "=", "SrcVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "DestBits", "=", "DstVT", ".", "getSizeInBits", "(", ")", ";", "return", "(", "SrcBits", "==", "64", "&&", "DestBits", "==", "32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

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

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "XCoreISD", "::", "RETSP", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i32", ")", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "XCoreISD", "::", "RETSP", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::OutputArg", "16", "XCore", "0", "0", "\"Can only return in registers!\"", "1", "XCoreISD::RETSP", "MVT::Other", "0", "MVT::i32", "XCoreISD::RETSP", "MVT::Other", "0", "MVT::i32" ]

[]

[ "<s>", "const", "char", "*", "Cpu0TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Cpu0ISD", "::", "JmpLink", ":", "return", "\"Cpu0ISD::JmpLink\"", ";", "case", "Cpu0ISD", "::", "TailCall", ":", "return", "\"Cpu0ISD::TailCall\"", ";", "case", "Cpu0ISD", "::", "Hi", ":", "return", "\"Cpu0ISD::Hi\"", ";", "case", "Cpu0ISD", "::", "Lo", ":", "return", "\"Cpu0ISD::Lo\"", ";", "case", "Cpu0ISD", "::", "GPRel", ":", "return", "\"Cpu0ISD::GPRel\"", ";", "case", "Cpu0ISD", "::", "Ret", ":", "return", "\"Cpu0ISD::Ret\"", ";", "case", "Cpu0ISD", "::", "EH_RETURN", ":", "return", "\"Cpu0ISD::EH_RETURN\"", ";", "case", "Cpu0ISD", "::", "DivRem", ":", "return", "\"Cpu0ISD::DivRem\"", ";", "case", "Cpu0ISD", "::", "DivRemU", ":", "return", "\"Cpu0ISD::DivRemU\"", ";", "case", "Cpu0ISD", "::", "Wrapper", ":", "return", "\"Cpu0ISD::Wrapper\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0ISD::JmpLink", "\"Cpu0ISD::JmpLink\"", "Cpu0ISD::TailCall", "\"Cpu0ISD::TailCall\"", "Cpu0ISD::Hi", "\"Cpu0ISD::Hi\"", "Cpu0ISD::Lo", "\"Cpu0ISD::Lo\"", "Cpu0ISD::GPRel", "\"Cpu0ISD::GPRel\"", "Cpu0ISD::Ret", "\"Cpu0ISD::Ret\"", "Cpu0ISD::EH_RETURN", "\"Cpu0ISD::EH_RETURN\"", "Cpu0ISD::DivRem", "\"Cpu0ISD::DivRem\"", "Cpu0ISD::DivRemU", "\"Cpu0ISD::DivRemU\"", "Cpu0ISD::Wrapper", "\"Cpu0ISD::Wrapper\"" ]

[]

[ "<s>", "static", "int", "shcompact_byref", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "unsigned", "HOST_WIDE_INT", "size", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "cum", "->", "arg_count", "[", "SH_ARG_INT", "]", "<", "NPARM_REGS", "(", "SImode", ")", "&&", "(", "!", "named", "||", "GET_SH_ARG_CLASS", "(", "mode", ")", "==", "SH_ARG_INT", "||", "(", "GET_SH_ARG_CLASS", "(", "mode", ")", "==", "SH_ARG_FLOAT", "&&", "cum", "->", "arg_count", "[", "SH_ARG_FLOAT", "]", ">=", "NPARM_REGS", "(", "SFmode", ")", ")", ")", "&&", "size", ">", "4", "&&", "!", "SHCOMPACT_FORCE_ON_STACK", "(", "mode", ",", "type", ")", "&&", "!", "SH5_WOULD_BE_PARTIAL_NREGS", "(", "*", "cum", ",", "mode", ",", "type", ",", "named", ")", ")", "return", "size", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Whether", "an", "argument", "must", "be", "passed", "by", "reference", ".", "On", "SHcompact", ",", "we", "pretend", "arguments", "wider", "than", "32-bits", "that", "would", "have", "been", "passed", "in", "registers", "are", "passed", "by", "reference", ",", "so", "that", "an", "SHmedia", "trampoline", "loads", "them", "into", "the", "full", "64-bits", "registers", "." ]

[ "sh", "4", "0" ]

[]

[ "<s>", "machine_mode", "select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "case", "UNLT", ":", "case", "UNLE", ":", "case", "UNGT", ":", "case", "UNGE", ":", "case", "UNEQ", ":", "return", "CCFPmode", ";", "case", "LT", ":", "case", "LE", ":", "case", "GT", ":", "case", "GE", ":", "case", "LTGT", ":", "return", "CCFPEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "GET_CODE", "(", "x", ")", "==", "MINUS", "||", "GET_CODE", "(", "x", ")", "==", "NEG", "||", "GET_CODE", "(", "x", ")", "==", "ASHIFT", ")", "&&", "y", "==", "const0_rtx", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCXNZmode", ";", "else", "return", "CCNZmode", ";", "}", "else", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "NOT", "&&", "y", "==", "constm1_rtx", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCXCmode", ";", "else", "return", "CCCmode", ";", "}", "if", "(", "!", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "{", "if", "(", "GET_CODE", "(", "y", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_ADDV", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_SUBV", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_NEGV", ")", ")", "return", "CCVmode", ";", "else", "return", "CCCmode", ";", "}", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "return", "CCXmode", ";", "else", "return", "CCmode", ";", "}", "}", "</s>" ]

[ "Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "first", "operand", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", ".", "For", "floating-point", ",", "CCFP", "[", "E", "]", "mode", "is", "used", ".", "CC_NOOVmode", "should", "be", "used", "when", "the", "first", "operand", "is", "a", "PLUS", ",", "MINUS", ",", "NEG", ",", "or", "ASHIFT", ".", "CCmode", "should", "be", "used", "when", "no", "special", "processing", "is", "needed", "." ]

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

[]

[ "<s>", "static", "void", "sh_function_arg_advance", "(", "cumulative_args_t", "ca_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "if", "(", "ca", "->", "force_mem", ")", "ca", "->", "force_mem", "=", "false", ";", "if", "(", "(", "TARGET_HITACHI", "||", "ca", "->", "renesas_abi", ")", "&&", "TARGET_FPU_DOUBLE", ")", "{", "if", "(", "mode", "==", "SFmode", "&&", "ca", "->", "free_single_fp_reg", ")", "{", "ca", "->", "free_single_fp_reg", "=", "0", ";", "return", ";", "}", "if", "(", "mode", "==", "DFmode", "&&", "sh_round_reg", "(", "*", "ca", ",", "DFmode", ")", "!=", "sh_round_reg", "(", "*", "ca", ",", "SFmode", ")", ")", "{", "ca", "->", "free_single_fp_reg", "=", "(", "sh_round_reg", "(", "*", "ca", ",", "SFmode", ")", "+", "BASE_ARG_REG", "(", "mode", ")", ")", ";", "}", "}", "if", "(", "!", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A", ")", "||", "ca", "->", "renesas_abi", ")", "||", "sh_pass_in_reg_p", "(", "*", "ca", ",", "mode", ",", "type", ")", ")", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "get_sh_arg_class", "(", "mode", ")", "]", "=", "(", "sh_round_reg", "(", "*", "ca", ",", "mode", ")", "+", "(", "mode", "==", "BLKmode", "?", "CEIL", "(", "int_size_in_bytes", "(", "type", ")", ",", "UNITS_PER_WORD", ")", ":", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "sh", "0" ]

[]

[ "<s>", "void", "arc_expand_prologue", "(", "void", ")", "{", "int", "size", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "unsigned", "int", "frame_size_to_allocate", ";", "int", "first_offset", "=", "0", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "if", "(", "ARC_NAKED_P", "(", "fn_type", ")", ")", "{", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "0", ";", "return", ";", "}", "size", "=", "arc_compute_frame_size", "(", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "frame_size_to_allocate", "=", "size", ";", "gcc_assert", "(", "!", "(", "size", "==", "0", "&&", "gmask", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "!=", "0", ")", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "<=", "32", ")", ";", "frame_stack_add", "(", "-", "(", "HOST_WIDE_INT", ")", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ";", "}", "if", "(", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "arc_dwarf_emit_irq_save_regs", "(", ")", ";", "}", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", ")", "{", "rtx", "ra", "=", "gen_rtx_REG", "(", "SImode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "ra", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", "{", "first_offset", "=", "-", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "arc_save_restore", "(", "stack_pointer_rtx", ",", "gmask", ",", "0", ",", "&", "first_offset", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "}", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "millicode_end_reg", ">", "0", "&&", "arc_must_save_return_addr", "(", "cfun", ")", ")", "{", "HOST_WIDE_INT", "tmp", "=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ")", ")", ";", "}", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ")", "{", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "UNITS_PER_WORD", "+", "first_offset", ")", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "first_offset", "=", "0", ";", "}", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "{", "frame_move", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "frame_size_to_allocate", "-=", "first_offset", ";", "if", "(", "frame_size_to_allocate", ">", "0", ")", "{", "frame_stack_add", "(", "(", "HOST_WIDE_INT", ")", "0", "-", "frame_size_to_allocate", ")", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "emit_insn", "(", "gen_stack_tie", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", "." ]

[ "arc", "0", "0", "0", "0", "32", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "m32r_legitimate_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "!", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "&&", "UINTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ">", "32767", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "We", "do", "n't", "allow", "(", "plus", "symbol", "large-constant", ")", "as", "the", "relocations", "ca", "n't", "describe", "it", ".", "INTVAL", ">", "32767", "handles", "both", "16-bit", "and", "24-bit", "relocations", ".", "We", "allow", "all", "CONST_DOUBLE", "'s", "as", "the", "md", "file", "patterns", "will", "force", "the", "constant", "to", "memory", "if", "they", "ca", "n't", "handle", "them", "." ]

[ "m32r", "0", "0", "0", "0", "0", "0", "1", "0", "1", "32767" ]

[]

[ "<s>", "static", "machine_mode", "ix86_cc_modes_compatible", "(", "machine_mode", "m1", ",", "machine_mode", "m2", ")", "{", "if", "(", "m1", "==", "m2", ")", "return", "m1", ";", "if", "(", "GET_MODE_CLASS", "(", "m1", ")", "!=", "MODE_CC", "||", "GET_MODE_CLASS", "(", "m2", ")", "!=", "MODE_CC", ")", "return", "VOIDmode", ";", "if", "(", "(", "m1", "==", "CCGCmode", "&&", "m2", "==", "CCGOCmode", ")", "||", "(", "m1", "==", "CCGOCmode", "&&", "m2", "==", "CCGCmode", ")", ")", "return", "CCGCmode", ";", "if", "(", "m1", "==", "CCZmode", "&&", "(", "m2", "==", "CCGCmode", "||", "m2", "==", "CCGOCmode", ")", ")", "return", "m2", ";", "else", "if", "(", "m2", "==", "CCZmode", "&&", "(", "m1", "==", "CCGCmode", "||", "m1", "==", "CCGOCmode", ")", ")", "return", "m1", ";", "switch", "(", "m1", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "CCmode", ":", "case", "CCGCmode", ":", "case", "CCGOCmode", ":", "case", "CCNOmode", ":", "case", "CCAmode", ":", "case", "CCCmode", ":", "case", "CCOmode", ":", "case", "CCSmode", ":", "case", "CCZmode", ":", "switch", "(", "m2", ")", "{", "default", ":", "return", "VOIDmode", ";", "case", "CCmode", ":", "case", "CCGCmode", ":", "case", "CCGOCmode", ":", "case", "CCNOmode", ":", "case", "CCAmode", ":", "case", "CCCmode", ":", "case", "CCOmode", ":", "case", "CCSmode", ":", "case", "CCZmode", ":", "return", "CCmode", ";", "}", "case", "CCFPmode", ":", "case", "CCFPUmode", ":", "return", "VOIDmode", ";", "}", "}", "</s>" ]

[ "If", "two", "condition", "code", "modes", "are", "compatible", ",", "return", "a", "condition", "code", "mode", "which", "is", "compatible", "with", "both", ".", "Otherwise", ",", "return", "VOIDmode", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "return", "useMachineScheduler", "(", ")", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "SPIRVMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ",", "const", "MachineFunction", "*", "CurMF", ",", "SPIRV", "::", "ModuleAnalysisInfo", "*", "MAI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getMF", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "MI", "->", "print", "(", "errs", "(", ")", ")", ";", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "Register", "FuncReg", "=", "MAI", "->", "getFuncReg", "(", "MO", ".", "getGlobal", "(", ")", "->", "getGlobalIdentifier", "(", ")", ")", ";", "assert", "(", "FuncReg", ".", "isValid", "(", ")", "&&", "\"Cannot find function Id\"", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "FuncReg", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MAI", "->", "getOrCreateMBBRegister", "(", "*", "MO", ".", "getMBB", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "{", "Register", "NewReg", "=", "MAI", "->", "getRegisterAlias", "(", "MF", ",", "MO", ".", "getReg", "(", ")", ")", ";", "bool", "IsOldReg", "=", "!", "CurMF", "||", "!", "NewReg", ".", "isValid", "(", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "IsOldReg", "?", "MO", ".", "getReg", "(", ")", ":", "NewReg", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "SPIRV", "::", "OpExtInst", "&&", "i", "==", "2", ")", "{", "Register", "Reg", "=", "MAI", "->", "getExtInstSetReg", "(", "MO", ".", "getImm", "(", ")", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "Reg", ")", ";", "}", "else", "{", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "MCOp", "=", "MCOperand", "::", "createDFPImm", "(", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ".", "convertToFloat", "(", ")", ")", ";", "break", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "SPIRV", "SPIRV", "SPIRV::ModuleAnalysisInfo", "0", "\"unknown operand type\"", "\"Cannot find function Id\"", "SPIRV::OpExtInst", "2" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "--", "MI", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "MI", ";", "}", "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", "(", ")", "." ]

[ "X86", "X86", "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "int", "shift_insns_rtx", "(", "rtx", "insn", ")", "{", "rtx", "set_src", "=", "SET_SRC", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", ";", "int", "shift_count", "=", "INTVAL", "(", "XEXP", "(", "set_src", ",", "1", ")", ")", ";", "enum", "rtx_code", "shift_code", "=", "GET_CODE", "(", "set_src", ")", ";", "switch", "(", "shift_code", ")", "{", "case", "ASHIFTRT", ":", "return", "ashiftrt_insns", "[", "shift_count", "]", ";", "case", "LSHIFTRT", ":", "case", "ASHIFT", ":", "return", "shift_insns", "[", "shift_count", "]", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "used", "in", "length", "attributes", "in", "sh.md", "to", "help", "compute", "the", "length", "of", "arbitrary", "constant", "shift", "instructions", "." ]

[ "sh", "0", "0", "1" ]

[]

[ "<s>", "void", "Cpu0MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Cpu0", "::", "NOP", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "(", "TSFlags", "&", "Cpu0II", "::", "FrmMask", ")", "==", "Cpu0II", "::", "Pseudo", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in encodeInstruction()\"", ")", ";", "int", "Size", "=", "4", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0::NOP", "\"unimplemented opcode in encodeInstruction()\"", "Cpu0II::FrmMask", "Cpu0II::Pseudo", "\"Pseudo opcode found in encodeInstruction()\"", "4" ]

[]

[ "<s>", "static", "bool", "nvptx_pass_by_reference", "(", "cumulative_args_t", "ARG_UNUSED", "(", "cum", ")", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "ARG_UNUSED", "(", "named", ")", ")", "{", "return", "pass_in_memory", "(", "mode", ",", "type", ",", "false", ")", ";", "}", "</s>" ]

[ "Types", "with", "a", "mode", "other", "than", "those", "supported", "by", "the", "machine", "are", "passed", "by", "reference", "in", "memory", "." ]

[ "nvptx" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_call_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "call_op", ")", "{", "bool", "direct_p", "=", "constant_call_address_operand", "(", "call_op", ",", "VOIDmode", ")", ";", "bool", "seh_nop_p", "=", "false", ";", "const", "char", "*", "xasm", ";", "if", "(", "SIBLING_CALL_P", "(", "insn", ")", ")", "{", "if", "(", "direct_p", ")", "{", "if", "(", "ix86_nopic_noplt_attribute_p", "(", "call_op", ")", ")", "xasm", "=", "\"%!jmp\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "else", "xasm", "=", "\"%!jmp\\t%P0\"", ";", "}", "else", "if", "(", "TARGET_SEH", ")", "xasm", "=", "\"%!rex.W jmp\\t%A0\"", ";", "else", "xasm", "=", "\"%!jmp\\t%A0\"", ";", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "return", "\"\"", ";", "}", "if", "(", "TARGET_SEH", ")", "{", "rtx_insn", "*", "i", ";", "for", "(", "i", "=", "NEXT_INSN", "(", "insn", ")", ";", "i", ";", "i", "=", "NEXT_INSN", "(", "i", ")", ")", "{", "if", "(", "INSN_P", "(", "i", ")", ")", "break", ";", "if", "(", "NOTE_P", "(", "i", ")", "&&", "NOTE_KIND", "(", "i", ")", "==", "NOTE_INSN_EPILOGUE_BEG", "&&", "!", "flag_non_call_exceptions", "&&", "!", "can_throw_internal", "(", "insn", ")", ")", "{", "seh_nop_p", "=", "true", ";", "break", ";", "}", "}", "if", "(", "i", "==", "NULL", ")", "seh_nop_p", "=", "true", ";", "}", "if", "(", "direct_p", ")", "{", "if", "(", "ix86_nopic_noplt_attribute_p", "(", "call_op", ")", ")", "xasm", "=", "\"%!call\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "else", "xasm", "=", "\"%!call\\t%P0\"", ";", "}", "else", "xasm", "=", "\"%!call\\t%A0\"", ";", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "if", "(", "seh_nop_p", ")", "return", "\"nop\"", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "for", "a", "call", "instruction", "." ]

[ "i386", "\"%!jmp\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"%!jmp\\t%P0\"", "\"%!rex.W jmp\\t%A0\"", "\"%!jmp\\t%A0\"", "\"\"", "\"%!call\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"%!call\\t%P0\"", "\"%!call\\t%A0\"", "\"nop\"", "\"\"" ]

[]

[ "<s>", "void", "init", "(", ")", "{", "memset", "(", "this", ",", "0", ",", "sizeof", "*", "this", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "machine", "model", "for", "instruction", "scheduling", "." ]

[ "Hexagon", "0" ]

[]

[ "<s>", "void", "J2FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", "*", "4", ";", "auto", "&", "TTI", "=", "*", "static_cast", "<", "const", "J2Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "StackSize", "==", "0", ")", "return", ";", "auto", "it", "=", "MBB", ".", "begin", "(", ")", ";", "it", "=", "std", "::", "next", "(", "it", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "DebugLoc", "DL", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "it", ",", "DL", ",", "TTI", ".", "get", "(", "J2", "::", "MOV32rr", ")", ",", "J2", "::", "R14", ")", ".", "addReg", "(", "J2", "::", "R15", ")", ";", "if", "(", "isInt", "<", "8", ">", "(", "-", "StackSize", ")", ")", "BuildMI", "(", "MBB", ",", "it", ",", "DL", ",", "TTI", ".", "get", "(", "J2", "::", "ADDri", ")", ",", "J2", "::", "R15", ")", ".", "addReg", "(", "J2", "::", "R15", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "else", "{", "llvm_unreachable", "(", "\"Not implemented yet\"", ")", ";", "}", "}", "</s>" ]

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

[ "J2", "J2", "4", "J2", "0", "J2::MOV32rr", "J2::R14", "J2::R15", "8", "J2::ADDri", "J2::R15", "J2::R15", "\"Not implemented yet\"" ]

[]

[ "<s>", "AArch64TargetLowering", "::", "ConstraintType", "AArch64TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'z'", ":", "return", "C_Other", ";", "case", "'x'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "}", "}", "else", "if", "(", "Constraint", ".", "size", "(", ")", "==", "3", "&&", "Constraint", "[", "0", "]", "==", "'U'", "&&", "Constraint", "[", "1", "]", "==", "'p'", "&&", "(", "Constraint", "[", "2", "]", "==", "'l'", "||", "Constraint", "[", "2", "]", "==", "'a'", ")", ")", "{", "return", "C_RegisterClass", ";", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "UPTFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\">> FrameLowering::emitEpilogue <<\\n\"", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "{", "return", ";", "}", "unsigned", "StackReg", "=", "UPT", "::", "SP", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "UPT", "::", "ADDR", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "UPT", "::", "ADDI", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>" ]

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

[ "UPT", "UPT", "\">> FrameLowering::emitEpilogue <<\\n\"", "UPT::SP", "UPT::ADDR", "UPT::ADDI" ]

[]

[ "<s>", "static", "tree", "ix86_get_function_versions_dispatcher", "(", "void", "*", "decl", ")", "{", "tree", "fn", "=", "(", "tree", ")", "decl", ";", "struct", "cgraph_node", "*", "node", "=", "NULL", ";", "struct", "cgraph_node", "*", "default_node", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "node_v", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "first_v", "=", "NULL", ";", "tree", "dispatch_decl", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "default_version_info", "=", "NULL", ";", "gcc_assert", "(", "fn", "!=", "NULL", "&&", "DECL_FUNCTION_VERSIONED", "(", "fn", ")", ")", ";", "node", "=", "cgraph_node", "::", "get", "(", "fn", ")", ";", "gcc_assert", "(", "node", "!=", "NULL", ")", ";", "node_v", "=", "node", "->", "function_version", "(", ")", ";", "gcc_assert", "(", "node_v", "!=", "NULL", ")", ";", "if", "(", "node_v", "->", "dispatcher_resolver", "!=", "NULL", ")", "return", "node_v", "->", "dispatcher_resolver", ";", "first_v", "=", "node_v", ";", "while", "(", "first_v", "->", "prev", "!=", "NULL", ")", "first_v", "=", "first_v", "->", "prev", ";", "default_version_info", "=", "first_v", ";", "while", "(", "default_version_info", "!=", "NULL", ")", "{", "if", "(", "is_function_default_version", "(", "default_version_info", "->", "this_node", "->", "decl", ")", ")", "break", ";", "default_version_info", "=", "default_version_info", "->", "next", ";", "}", "if", "(", "default_version_info", "==", "NULL", ")", "return", "NULL", ";", "if", "(", "first_v", "!=", "default_version_info", ")", "{", "default_version_info", "->", "prev", "->", "next", "=", "default_version_info", "->", "next", ";", "if", "(", "default_version_info", "->", "next", ")", "default_version_info", "->", "next", "->", "prev", "=", "default_version_info", "->", "prev", ";", "first_v", "->", "prev", "=", "default_version_info", ";", "default_version_info", "->", "next", "=", "first_v", ";", "default_version_info", "->", "prev", "=", "NULL", ";", "}", "default_node", "=", "default_version_info", "->", "this_node", ";", "if", "(", "targetm", ".", "has_ifunc_p", "(", ")", ")", "{", "struct", "cgraph_function_version_info", "*", "it_v", "=", "NULL", ";", "struct", "cgraph_node", "*", "dispatcher_node", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "dispatcher_version_info", "=", "NULL", ";", "dispatch_decl", "=", "make_dispatcher_decl", "(", "default_node", "->", "decl", ")", ";", "dispatcher_node", "=", "cgraph_node", "::", "get_create", "(", "dispatch_decl", ")", ";", "gcc_assert", "(", "dispatcher_node", "!=", "NULL", ")", ";", "dispatcher_node", "->", "dispatcher_function", "=", "1", ";", "dispatcher_version_info", "=", "dispatcher_node", "->", "insert_new_function_version", "(", ")", ";", "dispatcher_version_info", "->", "next", "=", "default_version_info", ";", "dispatcher_node", "->", "definition", "=", "1", ";", "it_v", "=", "default_version_info", ";", "while", "(", "it_v", "!=", "NULL", ")", "{", "it_v", "->", "dispatcher_resolver", "=", "dispatch_decl", ";", "it_v", "=", "it_v", "->", "next", ";", "}", "}", "else", "{", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "default_node", "->", "decl", ")", ",", "\"multiversioning needs ifunc which is not supported \"", "\"on this target\"", ")", ";", "}", "return", "dispatch_decl", ";", "}", "</s>" ]

[ "Make", "a", "dispatcher", "declaration", "for", "the", "multi-versioned", "function", "DECL", ".", "Calls", "to", "DECL", "function", "will", "be", "replaced", "with", "calls", "to", "the", "dispatcher", "by", "the", "front-end", ".", "Returns", "the", "decl", "of", "the", "dispatcher", "function", "." ]

[ "i386", "1", "1", "\"multiversioning needs ifunc which is not supported \"", "\"on this target\"" ]

[]

[ "<s>", "static", "bool", "general_scalar_to_vector_candidate_p", "(", "rtx_insn", "*", "insn", ",", "enum", "machine_mode", "mode", ")", "{", "rtx", "def_set", "=", "pseudo_reg_set", "(", "insn", ")", ";", "if", "(", "!", "def_set", ")", "return", "false", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "def_set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "COMPARE", ")", "return", "convertible_comparison_p", "(", "insn", ",", "mode", ")", ";", "if", "(", "(", "GET_MODE", "(", "src", ")", "!=", "mode", "&&", "!", "CONST_INT_P", "(", "src", ")", ")", "||", "GET_MODE", "(", "dst", ")", "!=", "mode", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "dst", ")", "&&", "!", "MEM_P", "(", "dst", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "src", ")", ")", "{", "case", "ASHIFTRT", ":", "if", "(", "!", "TARGET_AVX512VL", ")", "return", "false", ";", "case", "ASHIFT", ":", "case", "LSHIFTRT", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", ",", "0", ",", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "1", ")", ")", "return", "false", ";", "break", ";", "case", "SMAX", ":", "case", "SMIN", ":", "case", "UMAX", ":", "case", "UMIN", ":", "if", "(", "(", "mode", "==", "DImode", "&&", "!", "TARGET_AVX512VL", ")", "||", "(", "mode", "==", "SImode", "&&", "!", "TARGET_SSE4_1", ")", ")", "return", "false", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "PLUS", ":", "case", "MINUS", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "mode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "AND", "||", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "NOT", ")", "break", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "case", "NOT", ":", "break", ";", "case", "NEG", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "ABS", ")", "break", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "case", "ABS", ":", "if", "(", "(", "mode", "==", "DImode", "&&", "!", "TARGET_AVX512VL", ")", "||", "(", "mode", "==", "SImode", "&&", "!", "TARGET_SSSE3", ")", ")", "return", "false", ";", "break", ";", "case", "REG", ":", "return", "true", ";", "case", "MEM", ":", "case", "CONST_INT", ":", "return", "REG_P", "(", "dst", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "mode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "general", "version", "of", "scalar_to_vector_candidate_p", "." ]

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

[]

[ "<s>", "void", "FISCMCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "FISC", "FISC" ]

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "C", ")", "{", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "C", ")", ")", "return", "0", ";", "assert", "(", "C", "->", "isStaticAlloca", "(", ")", "&&", "\"dynamic alloca in the static alloca map?\"", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "C", ",", "AM", ")", ")", "return", "0", ";", "unsigned", "Opc", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "X86", "::", "LEA64r", ":", "X86", "::", "LEA32r", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "TLI", ".", "getPointerTy", "(", ")", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "addFullAddress", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ",", "AM", ")", ";", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "X86", "X86", "0", "\"dynamic alloca in the static alloca map?\"", "X86", "X86", "0", "X86::LEA64r", "X86::LEA32r" ]

[]

[ "<s>", "const", "char", "*", "emit_fusion_p9_store", "(", "rtx", "mem", ",", "rtx", "reg", ",", "rtx", "tmp_reg", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "hi", ";", "rtx", "lo", ";", "rtx", "addr", ";", "const", "char", "*", "store_string", ";", "int", "r", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #1\"", ",", "reg", ")", ";", "r", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "store_string", "=", "\"stfs\"", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "store_string", "=", "\"stfd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "r", ")", "&&", "TARGET_P9_DFORM_SCALAR", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "store_string", "=", "\"stxssp\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "store_string", "=", "\"stxsd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "INT_REGNO_P", "(", "r", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "store_string", "=", "\"stb\"", ";", "break", ";", "case", "E_HImode", ":", "store_string", "=", "\"sth\"", ";", "break", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "store_string", "=", "\"stw\"", ";", "break", ";", "case", "E_DImode", ":", "case", "E_DFmode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "gcc_unreachable", "(", ")", ";", "store_string", "=", "\"std\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #2\"", ",", "reg", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store not MEM\"", ",", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "hi", ",", "&", "lo", ")", ";", "emit_fusion_addis", "(", "tmp_reg", ",", "hi", ",", "\"power9 store fusion\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "emit_fusion_load_store", "(", "reg", ",", "tmp_reg", ",", "lo", ",", "store_string", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "store", "using", "extended", "fusion", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]

[ "powerpcspe", "0", "\"emit_fusion_p9_store, bad reg #1\"", "\"stfs\"", "\"stfd\"", "\"stxssp\"", "\"stxsd\"", "\"stb\"", "\"sth\"", "\"stw\"", "\"std\"", "\"emit_fusion_p9_store, bad reg #2\"", "\"emit_fusion_p9_store not MEM\"", "0", "\"power9 store fusion\"", "\"\"" ]

[]

[ "<s>", "static", "int", "s390_sched_variable_issue", "(", "FILE", "*", "file", ",", "int", "verbose", ",", "rtx_insn", "*", "insn", ",", "int", "more", ")", "{", "last_scheduled_insn", "=", "insn", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2827_ZEC12", "&&", "reload_completed", "&&", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "{", "unsigned", "int", "mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "s390_sched_state", "=", "S390_SCHED_STATE_CRACKED", ";", "else", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "s390_sched_state", "=", "S390_SCHED_STATE_NORMAL", ";", "else", "{", "switch", "(", "s390_sched_state", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "S390_SCHED_STATE_NORMAL", ":", "if", "(", "s390_sched_state", "==", "S390_SCHED_STATE_NORMAL", ")", "s390_sched_state", "=", "1", ";", "else", "s390_sched_state", "++", ";", "break", ";", "case", "S390_SCHED_STATE_CRACKED", ":", "s390_sched_state", "=", "S390_SCHED_STATE_NORMAL", ";", "break", ";", "}", "}", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "i", ";", "unsigned", "unit_mask", ",", "m", "=", "1", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "gcc_assert", "(", "units", "<=", "MAX_SCHED_UNITS", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "last_scheduled_unit_distance", "[", "i", "]", "=", "0", ";", "else", "if", "(", "last_scheduled_unit_distance", "[", "i", "]", "<", "MAX_SCHED_MIX_DISTANCE", ")", "last_scheduled_unit_distance", "[", "i", "]", "++", ";", "}", "if", "(", "verbose", ">", "5", ")", "{", "unsigned", "int", "sched_mask", ";", "sched_mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: insn %d: \"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_CRACKED", ",", "cracked", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_EXPANDED", ",", "expanded", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_ENDGROUP", ",", "endgroup", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_GROUPALONE", ",", "groupalone", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "unsigned", "int", "unit_mask", ",", "m", "=", "1", ";", "int", "units", ",", "j", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "fprintf", "(", "file", ",", "\"(units:\"", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "units", ";", "j", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "fprintf", "(", "file", ",", "\" %d\"", ",", "j", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "fprintf", "(", "file", ",", "\" sched state: %d\\n\"", ",", "s390_sched_state", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "j", ";", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: units unused for: \"", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "units", ";", "j", "++", ")", "fprintf", "(", "file", ",", "\"%d:%d \"", ",", "j", ",", "last_scheduled_unit_distance", "[", "j", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "}", "}", "}", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", ")", "return", "more", "-", "1", ";", "else", "return", "more", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "via", "hook", "TARGET_SCHED_VARIABLE_ISSUE", "after", "the", "scheduler", "has", "issued", "INSN", ".", "It", "stores", "the", "last", "issued", "insn", "into", "last_scheduled_insn", "in", "order", "to", "make", "it", "available", "for", "s390_sched_reorder", "." ]

[ "s390", "0", "0", "0", "0", "0", "0", "1", "2", "1", "1", "0", "1", "0", "5", "\";;\\t\\tBACKEND: insn %d: \"", "1", "\"(units:\"", "0", "1", "\" %d\"", "\")\"", "\" sched state: %d\\n\"", "\";;\\t\\tBACKEND: units unused for: \"", "0", "\"%d:%d \"", "\"\\n\"", "1" ]

[]

[ "<s>", "void", "print", "(", "const", "TargetRegisterInfo", "*", "TRI", "=", "nullptr", ")", "const", "{", "dbgs", "(", ")", "<<", "printReg", "(", "Reg", ",", "TRI", ",", "SubReg", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM64 Conditional Compares\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 Conditional Compares\"" ]

[]

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

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

[ "CJG", "CJG" ]

[]

[ "<s>", "static", "rtx", "nvptx_expand_shuffle", "(", "tree", "exp", ",", "rtx", "target", ",", "machine_mode", "mode", ",", "int", "ignore", ")", "{", "if", "(", "ignore", ")", "return", "target", ";", "rtx", "src", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "REG_P", "(", "src", ")", ")", "src", "=", "copy_to_mode_reg", "(", "mode", ",", "src", ")", ";", "rtx", "idx", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ",", "NULL_RTX", ",", "SImode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "op", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ",", "NULL_RTX", ",", "SImode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "REG_P", "(", "idx", ")", "&&", "GET_CODE", "(", "idx", ")", "!=", "CONST_INT", ")", "idx", "=", "copy_to_mode_reg", "(", "SImode", ",", "idx", ")", ";", "rtx", "pat", "=", "nvptx_gen_shuffle", "(", "target", ",", "src", ",", "idx", ",", "(", "nvptx_shuffle_kind", ")", "INTVAL", "(", "op", ")", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expander", "for", "the", "shuffle", "builtins", "." ]

[ "nvptx", "0", "1", "2" ]

[]

[ "<s>", "enum", "direction", "function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "upward", ";", "return", "DEFAULT_FUNCTION_ARG_PADDING", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Handle", "the", "FUNCTION_ARG_PADDING", "macro", ".", "For", "the", "64", "bit", "ABI", "structs", "are", "always", "stored", "left", "shifted", "in", "their", "argument", "slot", "." ]

[ "sparc" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "return", "CSR_NaCl_SaveList", ";", "const", "MCPhysReg", "*", "RegList", "=", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "if", "(", "!", "MF", ")", "return", "RegList", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", "->", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "return", "RegList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"" ]

[]

[ "<s>", "void", "rs6000_expand_interleave", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "bool", "highp", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "unsigned", "i", ",", "high", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "rtx", "perm", "[", "16", "]", ";", "high", "=", "(", "highp", "?", "0", ":", "nelt", "/", "2", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", "/", "2", ";", "i", "++", ")", "{", "perm", "[", "i", "*", "2", "]", "=", "GEN_INT", "(", "i", "+", "high", ")", ";", "perm", "[", "i", "*", "2", "+", "1", "]", "=", "GEN_INT", "(", "i", "+", "nelt", "+", "high", ")", ";", "}", "rs6000_do_expand_vec_perm", "(", "target", ",", "op0", ",", "op1", ",", "vmode", ",", "nelt", ",", "perm", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "interleave", "operation", "." ]

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

[]

[ "<s>", "const", "uint16_t", "*", "Z80RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "Z80", "::", "BC", ",", "Z80", "::", "DE", ",", "Z80", "::", "IX", ",", "Z80", "::", "IY", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "Z80", "Z80", "Z80::BC", "Z80::DE", "Z80::IX", "Z80::IY", "0" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "assert", "(", "Expr", "&&", "\"Expr shouldn't be null!\"", ")", ";", "int64_t", "Imm", "=", "0", ";", "RISCVMCExpr", "::", "VariantKind", "VK", ";", "bool", "IsConstant", "=", "evaluateConstantImm", "(", "Expr", ",", "Imm", ",", "VK", ")", ";", "if", "(", "IsConstant", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

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

[ "RISCV", "\"Expr shouldn't be null!\"", "0", "RISCV" ]

[]

[ "<s>", "SDValue", "TeeRISCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_TeeRISC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "TeeRISC", "::", "R1", ",", "MVT", "::", "i32", ")", ")", ";", "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", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "TeeRISC_ISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC", "ISD::OutputArg", "16", "TeeRISC", "4", "1", "TeeRISC::R1", "MVT::i32", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "0", "TeeRISC_ISD::RET", "MVT::Other", "0" ]

[]

[ "<s>", "static", "enum", "flt_eval_method", "riscv_excess_precision", "(", "enum", "excess_precision_type", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "EXCESS_PRECISION_TYPE_FAST", ":", "case", "EXCESS_PRECISION_TYPE_STANDARD", ":", "return", "(", "(", "TARGET_ZFH", "||", "TARGET_ZHINX", ")", "?", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16", ":", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ")", ";", "case", "EXCESS_PRECISION_TYPE_IMPLICIT", ":", "case", "EXCESS_PRECISION_TYPE_FLOAT16", ":", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "FLT_EVAL_METHOD_UNPREDICTABLE", ";", "}", "</s>" ]

[ "Set", "the", "value", "of", "FLT_EVAL_METHOD", ".", "ISO/IEC", "TS", "18661-3", "defines", "two", "values", "that", "we", "'d", "like", "to", "make", "use", "of", ":", "0", ":", "evaluate", "all", "operations", "and", "constants", ",", "whose", "semantic", "type", "has", "at", "most", "the", "range", "and", "precision", "of", "type", "float", ",", "to", "the", "range", "and", "precision", "of", "float", ";", "evaluate", "all", "other", "operations", "and", "constants", "to", "the", "range", "and", "precision", "of", "the", "semantic", "type", ";", "N", ",", "where", "_FloatN", "is", "a", "supported", "interchange", "floating", "type", "evaluate", "all", "operations", "and", "constants", ",", "whose", "semantic", "type", "has", "at", "most", "the", "range", "and", "precision", "of", "_FloatN", "type", ",", "to", "the", "range", "and", "precision", "of", "the", "_FloatN", "type", ";", "evaluate", "all", "other", "operations", "and", "constants", "to", "the", "range", "and", "precision", "of", "the", "semantic", "type", ";", "If", "we", "have", "the", "zfh/zhinx", "extensions", "then", "we", "support", "_Float16", "in", "native", "precision", ",", "so", "we", "should", "set", "this", "to", "16", "." ]

[ "riscv" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "restoreWin32EHStackPointers", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "DebugLoc", "DL", ",", "bool", "RestoreSP", ")", "const", "{", "assert", "(", "STI", ".", "isTargetWindowsMSVC", "(", ")", "&&", "\"funclets only supported in MSVC env\"", ")", ";", "assert", "(", "STI", ".", "isTargetWin32", "(", ")", "&&", "\"EBP/ESI restoration only required on win32\"", ")", ";", "assert", "(", "STI", ".", "is32Bit", "(", ")", "&&", "!", "Uses64BitFramePtr", "&&", "\"restoring EBP/ESI on non-32-bit target\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "FramePtr", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "BasePtr", "=", "TRI", "->", "getBaseRegister", "(", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "WinEHFuncInfo", "&", "FuncInfo", "=", "MMI", ".", "getWinEHFuncInfo", "(", "Fn", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "FuncInfo", ".", "EHRegNodeFrameIndex", ";", "int", "EHRegSize", "=", "MFI", "->", "getObjectSize", "(", "FI", ")", ";", "if", "(", "RestoreSP", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "X86", "::", "ESP", ")", ",", "X86", "::", "EBP", ",", "true", ",", "-", "EHRegSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "unsigned", "UsedReg", ";", "int", "EHRegOffset", "=", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "UsedReg", ")", ";", "int", "EndOffset", "=", "-", "EHRegOffset", "-", "EHRegSize", ";", "FuncInfo", ".", "EHRegNodeEndOffset", "=", "EndOffset", ";", "if", "(", "UsedReg", "==", "FramePtr", ")", "{", "unsigned", "ADDri", "=", "getADDriOpcode", "(", "false", ",", "EndOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "ADDri", ")", ",", "FramePtr", ")", ".", "addReg", "(", "FramePtr", ")", ".", "addImm", "(", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "assert", "(", "EndOffset", ">=", "0", "&&", "\"end of registration object above normal EBP position!\"", ")", ";", "}", "else", "if", "(", "UsedReg", "==", "BasePtr", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "LEA32r", ")", ",", "BasePtr", ")", ",", "FramePtr", ",", "false", ",", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "assert", "(", "X86FI", "->", "getHasSEHFramePtrSave", "(", ")", ")", ";", "int", "Offset", "=", "getFrameIndexReference", "(", "MF", ",", "X86FI", "->", "getSEHFramePtrSaveIndex", "(", ")", ",", "UsedReg", ")", ";", "assert", "(", "UsedReg", "==", "BasePtr", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "FramePtr", ")", ",", "UsedReg", ",", "true", ",", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"", ")", ";", "}", "return", "MBBI", ";", "}", "</s>" ]

[ "Sets", "up", "EBP", "and", "optionally", "ESI", "based", "on", "the", "incoming", "EBP", "value", "." ]

[ "X86", "X86", "\"funclets only supported in MSVC env\"", "\"EBP/ESI restoration only required on win32\"", "\"restoring EBP/ESI on non-32-bit target\"", "X86", "X86", "X86", "X86::MOV32rm", "X86::ESP", "X86::EBP", "3", "0", "\"end of registration object above normal EBP position!\"", "X86::LEA32r", "X86", "X86", "X86::MOV32rm", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"" ]

[]

[ "<s>", "static", "void", "mips_macc_chains_record", "(", "rtx", "insn", ")", "{", "if", "(", "get_attr_may_clobber_hilo", "(", "insn", ")", ")", "mips_macc_chains_last_hilo", "=", "insn", ";", "}", "</s>" ]

[ "A", "TUNE_MACC_CHAINS", "helper", "function", ".", "Record", "that", "instruction", "INSN", "has", "been", "scheduled", ",", "updating", "mips_macc_chains_last_hilo", "appropriately", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "Module", "::", "GlobalListType", "&", "global_list", "=", "M", ".", "getGlobalList", "(", ")", ";", "int", "i", ",", "n", "=", "global_list", ".", "size", "(", ")", ";", "GlobalVariable", "*", "*", "gv_array", "=", "new", "GlobalVariable", "*", "[", "n", "]", ";", "i", "=", "0", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "global_list", ".", "begin", "(", ")", ",", "E", "=", "global_list", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "gv_array", "[", "i", "++", "]", "=", "&", "*", "I", ";", "while", "(", "!", "global_list", ".", "empty", "(", ")", ")", "global_list", ".", "remove", "(", "global_list", ".", "begin", "(", ")", ")", ";", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "global_list", ".", "insert", "(", "global_list", ".", "end", "(", ")", ",", "gv_array", "[", "i", "]", ")", ";", "delete", "[", "]", "gv_array", ";", "return", "ret", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "NVPTX", "NVPTX", "0", "0" ]

[]

[ "<s>", "int", "rs6000_trampoline_size", "(", "void", ")", "{", "int", "ret", "=", "0", ";", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ABI_AIX", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "12", ":", "24", ";", "break", ";", "case", "ABI_ELFv2", ":", "gcc_assert", "(", "!", "TARGET_32BIT", ")", ";", "ret", "=", "32", ";", "break", ";", "case", "ABI_DARWIN", ":", "case", "ABI_V4", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "40", ":", "48", ";", "break", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Length", "in", "units", "of", "the", "trampoline", "for", "entering", "a", "nested", "function", "." ]

[ "rs6000", "0", "12", "24", "32", "40", "48" ]

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "uint64_t", "TSFlags", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ";", "if", "(", "(", "getForcedEncodingSize", "(", ")", "==", "32", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "getForcedEncodingSize", "(", ")", "==", "64", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "isForcedDPP", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "DPP", ")", ")", "||", "(", "isForcedSDWA", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", ")", ")", "return", "Match_InvalidOperand", ";", "if", "(", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOPAsmPrefer32Bit", ")", "&&", "getForcedEncodingSize", "(", ")", "!=", "64", ")", "return", "Match_PreferE32", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_sdwa_vi", "||", "Inst", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_sdwa_vi", ")", "{", "auto", "OpNum", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Inst", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "dst_sel", ")", ";", "const", "auto", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "Op", ".", "isImm", "(", ")", "||", "Op", ".", "getImm", "(", ")", "!=", "AMDGPU", "::", "SDWA", "::", "SdwaSel", "::", "DWORD", ")", "{", "return", "Match_InvalidOperand", ";", "}", "}", "if", "(", "TSFlags", "&", "SIInstrFlags", "::", "FLAT", ")", "{", "auto", "Opcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "auto", "OpNum", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "const", "auto", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "hasFlatOffsets", "(", ")", "&&", "Op", ".", "getImm", "(", ")", "!=", "0", ")", "return", "Match_InvalidOperand", ";", "if", "(", "isGFX10", "(", ")", ")", "{", "if", "(", "TSFlags", "&", "SIInstrFlags", "::", "IsNonFlatSeg", ")", "{", "if", "(", "!", "isInt", "<", "12", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "return", "Match_InvalidOperand", ";", "}", "else", "{", "if", "(", "!", "isUInt", "<", "11", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "return", "Match_InvalidOperand", ";", "}", "}", "}", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "AMDGPU", "AMDGPU", "32", "SIInstrFlags::VOP3", "64", "SIInstrFlags::VOP3", "SIInstrFlags::DPP", "SIInstrFlags::SDWA", "SIInstrFlags::VOP3", "SIInstrFlags::VOPAsmPrefer32Bit", "64", "AMDGPU::V_MAC_F32_sdwa_vi", "AMDGPU::V_MAC_F16_sdwa_vi", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::SDWA", "SIInstrFlags::FLAT", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "SIInstrFlags::IsNonFlatSeg", "12", "11" ]

[]

[ "<s>", "PPCTargetLowering", "::", "ConstraintType", "PPCTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'b'", ":", "case", "'r'", ":", "case", "'f'", ":", "case", "'v'", ":", "case", "'y'", ":", "return", "C_RegisterClass", ";", "case", "'Z'", ":", "return", "C_Memory", ";", "}", "}", "else", "if", "(", "Constraint", "==", "\"wc\"", ")", "{", "return", "C_RegisterClass", ";", "}", "else", "if", "(", "Constraint", "==", "\"wa\"", "||", "Constraint", "==", "\"wd\"", "||", "Constraint", "==", "\"wf\"", "||", "Constraint", "==", "\"ws\"", ")", "{", "return", "C_RegisterClass", ";", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "1", "0", "\"wc\"", "\"wa\"", "\"wd\"", "\"wf\"", "\"ws\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "TM", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_440", "||", "Directive", "==", "PPC", "::", "DIR_A2", "||", "Directive", "==", "PPC", "::", "DIR_E500mc", "||", "Directive", "==", "PPC", "::", "DIR_E5500", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "PPCScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "TM", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "PPC" ]

[]

[ "<s>", "static", "ArrayRef", "<", "MCPhysReg", ">", "getAllSGPR128", "(", "const", "GCNSubtarget", "&", "ST", ",", "const", "MachineFunction", "&", "MF", ")", "{", "return", "makeArrayRef", "(", "AMDGPU", "::", "SGPR_128RegClass", ".", "begin", "(", ")", ",", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", "/", "4", ")", ";", "}", "</s>" ]

[ "Return", "all", "SGPR128", "which", "satisfy", "the", "waves", "per", "execution", "unit", "requirement", "of", "the", "subtarget", "." ]

[ "AMDGPU", "AMDGPU::SGPR_128RegClass", "4" ]

[]

[ "<s>", "void", "s390_reload_symref_address", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "tomem", ")", "{", "if", "(", "CONST_INT_P", "(", "mem", ")", "||", "GET_CODE", "(", "mem", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "mem", ")", "==", "CONST", ")", "mem", "=", "force_const_mem", "(", "GET_MODE", "(", "reg", ")", ",", "mem", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "if", "(", "!", "tomem", "&&", "REGNO", "(", "reg", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_REG_CLASS", "(", "REGNO", "(", "reg", ")", ")", "==", "ADDR_REGS", "&&", "GET_MODE", "(", "reg", ")", "==", "GET_MODE", "(", "scratch", ")", ")", "scratch", "=", "reg", ";", "s390_reload_larl_operand", "(", "scratch", ",", "XEXP", "(", "mem", ",", "0", ")", ",", "scratch", ")", ";", "if", "(", "tomem", ")", "emit_move_insn", "(", "replace_equiv_address", "(", "mem", ",", "scratch", ")", ",", "reg", ")", ";", "else", "emit_move_insn", "(", "reg", ",", "replace_equiv_address", "(", "mem", ",", "scratch", ")", ")", ";", "}", "</s>" ]

[ "Generate", "what", "is", "necessary", "to", "move", "between", "REG", "and", "MEM", "using", "SCRATCH", ".", "The", "direction", "is", "given", "by", "TOMEM", "." ]

[ "s390", "0" ]

[]