Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "aapcs_layout_arg", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "int", "nregs", ",", "nregs2", ";", "int", "ncrn", ";", "if", "(", "pcum", "->", "aapcs_arg_processed", ")", "return", ";", "pcum", "->", "aapcs_arg_processed", "=", "true", ";", "if", "(", "!", "named", ")", "return", ";", "if", "(", "pcum", "->", "pcs_variant", "!=", "ARM_PCS_AAPCS", ")", "{", "int", "slot", "=", "aapcs_select_call_coproc", "(", "pcum", ",", "mode", ",", "type", ")", ";", "pcum", "->", "aapcs_cprc_slot", "=", "slot", ";", "if", "(", "slot", ">=", "0", ")", "{", "if", "(", "!", "pcum", "->", "aapcs_cprc_failed", "[", "slot", "]", ")", "{", "if", "(", "aapcs_cp_arg_layout", "[", "slot", "]", ".", "allocate", "(", "pcum", ",", "mode", ",", "type", ")", ")", "return", ";", "pcum", "->", "aapcs_cprc_failed", "[", "slot", "]", "=", "true", ";", "pcum", "->", "can_split", "=", "false", ";", "}", "gcc_assert", "(", "pcum", "->", "can_split", "==", "false", ")", ";", "return", ";", "}", "}", "ncrn", "=", "pcum", "->", "aapcs_ncrn", ";", "if", "(", "(", "ncrn", "&", "1", ")", "&&", "arm_needs_doubleword_align", "(", "mode", ",", "type", ")", ")", "ncrn", "++", ";", "nregs", "=", "ARM_NUM_REGS2", "(", "mode", ",", "type", ")", ";", "gcc_assert", "(", "nregs", ">=", "0", ")", ";", "nregs2", "=", "nregs", "?", "nregs", ":", "1", ";", "if", "(", "ncrn", "+", "nregs2", "<=", "NUM_ARG_REGS", ")", "{", "pcum", "->", "aapcs_reg", "=", "gen_rtx_REG", "(", "mode", ",", "ncrn", ")", ";", "pcum", "->", "aapcs_next_ncrn", "=", "ncrn", "+", "nregs", ";", "return", ";", "}", "if", "(", "ncrn", "<", "NUM_ARG_REGS", "&&", "pcum", "->", "can_split", ")", "{", "pcum", "->", "aapcs_reg", "=", "gen_rtx_REG", "(", "mode", ",", "ncrn", ")", ";", "pcum", "->", "aapcs_next_ncrn", "=", "NUM_ARG_REGS", ";", "pcum", "->", "aapcs_partial", "=", "(", "NUM_ARG_REGS", "-", "ncrn", ")", "*", "UNITS_PER_WORD", ";", "return", ";", "}", "pcum", "->", "aapcs_next_ncrn", "=", "NUM_ARG_REGS", ";", "return", ";", "}", "</s>" ]

[ "Lay", "out", "a", "function", "argument", "using", "the", "AAPCS", "rules", ".", "The", "rule", "numbers", "referred", "to", "here", "are", "those", "in", "the", "AAPCS", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Prepare For LiveIntervals **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "if", "(", "MRI", ".", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "if", "(", "HasArgumentDef", "(", "Reg", ",", "MRI", ")", ")", "continue", ";", "BuildMI", "(", "Entry", ",", "Entry", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "IMPLICIT_DEF", ")", ",", "Reg", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "MII", "=", "Entry", ".", "begin", "(", ")", ",", "MIE", "=", "Entry", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", "++", ";", "if", "(", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "{", "MI", ".", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "&", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Prepare For LiveIntervals **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "0", "WebAssembly::IMPLICIT_DEF", "WebAssembly::isArgument" ]

[]

[ "<s>", "unsigned", "getOpSize", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "return", "RI", ".", "getRegSizeInBits", "(", "*", "getOpRegClass", "(", "MI", ",", "OpNo", ")", ")", "/", "8", ";", "}", "</s>" ]

[ "This", "form", "should", "usually", "be", "preferred", "since", "it", "handles", "operands", "with", "unknown", "register", "classes", "." ]

[ "AMDGPU", "8" ]

[]

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

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "void", "Z80RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MII", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ";", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int64_t", "SPOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "SPOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", "<<", "\"alignment : \"", "<<", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectAlignment", "(", "FrameIndex", ")", "<<", "\"\\n\"", ")", ";", "unsigned", "OpNo", "=", "FIOperandNum", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "unsigned", "FrameReg", ";", "FrameReg", "=", "Z80", "::", "SP", ";", "int64_t", "Offset", ";", "bool", "IsKill", "=", "false", ";", "Offset", "=", "SPOffset", "+", "(", "int64_t", ")", "StackSize", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "const", "Z80InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Z80InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "OpNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "Z80", "::", "LD16ri", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Z80", "::", "HL", "&&", "\"Constraints: EliminateFI\"", ")", ";", "std", "::", "advance", "(", "MII", ",", "1", ")", ";", "BuildMI", "(", "MBB", ",", "MII", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Z80", "::", "ADD16HLr", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "\"alignment : \"", "\"\\n\"", "0", "1", "0", "1", "Z80::SP", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "Z80", "Z80", "Z80::LD16ri", "0", "0", "Z80::HL", "\"Constraints: EliminateFI\"", "1", "Z80::ADD16HLr", "0", "0" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitImplicitDef", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "unsigned", "RegNo", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "TRI", "->", "isVirtualRegister", "(", "RegNo", ")", ")", "{", "OutStreamer", ".", "AddComment", "(", "Twine", "(", "\"implicit-def: \"", ")", "+", "getVirtualRegisterName", "(", "RegNo", ")", ")", ";", "}", "else", "{", "OutStreamer", ".", "AddComment", "(", "Twine", "(", "\"implicit-def: \"", ")", "+", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", "->", "getName", "(", "RegNo", ")", ")", ";", "}", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "customize", "the", "output", "of", "IMPLICIT_DEF", "instructions", "in", "verbose", "mode", "." ]

[ "NVPTX", "NVPTX", "0", "\"implicit-def: \"", "\"implicit-def: \"" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isFuncletEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "bool", "HasPads", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "if", "(", "BB", ".", "isEHPad", "(", ")", ")", "{", "HasPads", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasPads", ")", "return", "false", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "WinEHFuncInfo", "FuncInfo", ";", "addStateStores", "(", "F", ",", "FuncInfo", ")", ";", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"no-frame-pointer-elim\"", "\"true\"" ]

[]

[ "<s>", "unsigned", "getElementSize", "(", ")", "const", "{", "assert", "(", "Predicated", ")", ";", "return", "ElementSize", ";", "}", "</s>" ]

[ "Return", "the", "size", "of", "an", "element", "read", "or", "written", "by", "Inst", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "arm_valid_target_attribute_rec", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", ")", "{", "bool", "ret", "=", "true", ";", "for", "(", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "!", "arm_valid_target_attribute_rec", "(", "TREE_VALUE", "(", "args", ")", ",", "opts", ")", ")", "ret", "=", "false", ";", "return", "ret", ";", "}", "else", "if", "(", "TREE_CODE", "(", "args", ")", "!=", "STRING_CST", ")", "{", "error", "(", "\"attribute %<target%> argument not a string\"", ")", ";", "return", "false", ";", "}", "char", "*", "argstr", "=", "ASTRDUP", "(", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "char", "*", "q", ";", "while", "(", "(", "q", "=", "strtok", "(", "argstr", ",", "\",\"", ")", ")", "!=", "NULL", ")", "{", "while", "(", "ISSPACE", "(", "*", "q", ")", ")", "++", "q", ";", "argstr", "=", "NULL", ";", "if", "(", "!", "strncmp", "(", "q", ",", "\"thumb\"", ",", "5", ")", ")", "opts", "->", "x_target_flags", "|=", "MASK_THUMB", ";", "else", "if", "(", "!", "strncmp", "(", "q", ",", "\"arm\"", ",", "3", ")", ")", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "else", "if", "(", "!", "strncmp", "(", "q", ",", "\"fpu=\"", ",", "4", ")", ")", "{", "int", "fpu_index", ";", "if", "(", "!", "opt_enum_arg_to_value", "(", "OPT_mfpu_", ",", "q", "+", "4", ",", "&", "fpu_index", ",", "CL_TARGET", ")", ")", "{", "error", "(", "\"invalid fpu for attribute(target(\\\"%s\\\"))\"", ",", "q", ")", ";", "return", "false", ";", "}", "if", "(", "fpu_index", "==", "TARGET_FPU_auto", ")", "{", "sorry", "(", "\"auto fpu selection not currently permitted here\"", ")", ";", "return", "false", ";", "}", "opts", "->", "x_arm_fpu_index", "=", "(", "enum", "fpu_type", ")", "fpu_index", ";", "}", "else", "{", "error", "(", "\"attribute(target(\\\"%s\\\")) is unknown\"", ",", "q", ")", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Inner", "function", "to", "process", "the", "attribute", "(", "(", "target", "(", "...", ")", ")", ")", ",", "take", "an", "argument", "and", "set", "the", "current", "options", "from", "the", "argument", ".", "If", "we", "have", "a", "list", ",", "recursively", "go", "over", "the", "list", "." ]

[ "arm", "\"attribute %<target%> argument not a string\"", "\",\"", "\"thumb\"", "5", "\"arm\"", "3", "\"fpu=\"", "4", "4", "\"invalid fpu for attribute(target(\\\"%s\\\"))\"", "\"auto fpu selection not currently permitted here\"", "\"attribute(target(\\\"%s\\\")) is unknown\"" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

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

[]

[ "<s>", "llvm", "::", "FastISel", "*", "X86", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ")", "{", "return", "new", "X86FastISel", "(", "funcInfo", ")", ";", "}", "</s>" ]

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

[ "X86", "X86::createFastISel", "X86" ]

[]

[ "<s>", "static", "rtx", "frv_expand_cut_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op2", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "1", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "if", "(", "icode", "==", "CODE_FOR_mdcutssi", "||", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "{", "if", "(", "!", "frv_check_constant_argument", "(", "icode", ",", "2", ",", "op1", ")", ")", "return", "NULL_RTX", ";", "}", "else", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "2", ",", "op1", ")", ";", "op2", "=", "frv_matching_accg_for_acc", "(", "op0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "cut-style", "builtins", ",", "which", "take", "two", "operands", "and", "an", "implicit", "ACCG", "one", "." ]

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

[]

[ "<s>", "SparcSubtarget", "&", "SparcSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "UseSoftMulDiv", "=", "false", ";", "IsV9", "=", "false", ";", "IsLeon", "=", "false", ";", "V8DeprecatedInsts", "=", "false", ";", "IsVIS", "=", "false", ";", "IsVIS2", "=", "false", ";", "IsVIS3", "=", "false", ";", "HasHardQuad", "=", "false", ";", "UsePopc", "=", "false", ";", "UseSoftFloat", "=", "false", ";", "HasNoFSMULD", "=", "false", ";", "HasNoFMULS", "=", "false", ";", "HasLeonCasa", "=", "false", ";", "HasUmacSmac", "=", "false", ";", "HasPWRPSR", "=", "false", ";", "InsertNOPLoad", "=", "false", ";", "FixAllFDIVSQRT", "=", "false", ";", "DetectRoundChange", "=", "false", ";", "HasLeonCycleCounter", "=", "false", ";", "std", "::", "string", "CPUName", "=", "std", "::", "string", "(", "CPU", ")", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "(", "Is64Bit", ")", "?", "\"v9\"", ":", "\"v8\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "if", "(", "!", "IsV9", ")", "UsePopc", "=", "false", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "Sparc", "Sparc", "Sparc", "\"v9\"", "\"v8\"" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "if", "(", "Idx", "==", "getVGPRPressureSet", "(", ")", "||", "Idx", "==", "getAGPRPressureSet", "(", ")", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "if", "(", "Idx", "==", "getSGPRPressureSet", "(", ")", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "return", "AMDGPUGenRegisterInfo", "::", "getRegPressureSetLimit", "(", "MF", ",", "Idx", ")", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ "AMDGPU", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU" ]

[]

[ "<s>", "bool", "arm_output_addr_const_extra", "(", "FILE", "*", "fp", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TLS", ")", "return", "arm_emit_tls_decoration", "(", "fp", ",", "x", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC_LABEL", ")", "{", "char", "label", "[", "256", "]", ";", "int", "labelno", "=", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label", ",", "\"LPIC\"", ",", "labelno", ")", ";", "assemble_name_raw", "(", "fp", ",", "label", ")", ";", "return", "TRUE", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "return", "arm_emit_vector_const", "(", "fp", ",", "x", ")", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

[ "arm", "1", "1", "256", "0", "0", "\"LPIC\"" ]

[]

[ "<s>", "bool", "SystemZShortenInst", "::", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "LiveRegs", ".", "clear", "(", ")", ";", "LiveRegs", ".", "addLiveOuts", "(", "MBB", ")", ";", "for", "(", "auto", "MBBI", "=", "MBB", ".", "rbegin", "(", ")", ",", "MBBE", "=", "MBB", ".", "rend", "(", ")", ";", "MBBI", "!=", "MBBE", ";", "++", "MBBI", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "SystemZ", "::", "IILF", ":", "Changed", "|=", "shortenIIF", "(", "MI", ",", "SystemZ", "::", "LLILL", ",", "SystemZ", "::", "LLILH", ")", ";", "break", ";", "case", "SystemZ", "::", "IIHF", ":", "Changed", "|=", "shortenIIF", "(", "MI", ",", "SystemZ", "::", "LLIHL", ",", "SystemZ", "::", "LLIHH", ")", ";", "break", ";", "case", "SystemZ", "::", "WFADB", ":", "Changed", "|=", "shortenOn001AddCC", "(", "MI", ",", "SystemZ", "::", "ADBR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFDDB", ":", "Changed", "|=", "shortenOn001", "(", "MI", ",", "SystemZ", "::", "DDBR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFIDB", ":", "Changed", "|=", "shortenFPConv", "(", "MI", ",", "SystemZ", "::", "FIDBRA", ")", ";", "break", ";", "case", "SystemZ", "::", "WLDEB", ":", "Changed", "|=", "shortenOn01", "(", "MI", ",", "SystemZ", "::", "LDEBR", ")", ";", "break", ";", "case", "SystemZ", "::", "WLEDB", ":", "Changed", "|=", "shortenFPConv", "(", "MI", ",", "SystemZ", "::", "LEDBRA", ")", ";", "break", ";", "case", "SystemZ", "::", "WFMDB", ":", "Changed", "|=", "shortenOn001", "(", "MI", ",", "SystemZ", "::", "MDBR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFLCDB", ":", "Changed", "|=", "shortenOn01", "(", "MI", ",", "SystemZ", "::", "LCDFR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFLNDB", ":", "Changed", "|=", "shortenOn01", "(", "MI", ",", "SystemZ", "::", "LNDFR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFLPDB", ":", "Changed", "|=", "shortenOn01", "(", "MI", ",", "SystemZ", "::", "LPDFR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFSQDB", ":", "Changed", "|=", "shortenOn01", "(", "MI", ",", "SystemZ", "::", "SQDBR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFSDB", ":", "Changed", "|=", "shortenOn001AddCC", "(", "MI", ",", "SystemZ", "::", "SDBR", ")", ";", "break", ";", "case", "SystemZ", "::", "WFCDB", ":", "Changed", "|=", "shortenOn01", "(", "MI", ",", "SystemZ", "::", "CDBR", ")", ";", "break", ";", "case", "SystemZ", "::", "VL32", ":", "Changed", "|=", "shortenOn0", "(", "MI", ",", "SystemZ", "::", "LDE32", ")", ";", "break", ";", "case", "SystemZ", "::", "VST32", ":", "Changed", "|=", "shortenOn0", "(", "MI", ",", "SystemZ", "::", "STE", ")", ";", "break", ";", "case", "SystemZ", "::", "VL64", ":", "Changed", "|=", "shortenOn0", "(", "MI", ",", "SystemZ", "::", "LD", ")", ";", "break", ";", "case", "SystemZ", "::", "VST64", ":", "Changed", "|=", "shortenOn0", "(", "MI", ",", "SystemZ", "::", "STD", ")", ";", "break", ";", "}", "LiveRegs", ".", "stepBackward", "(", "MI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "SystemZ", "SystemZ", "SystemZ::IILF", "SystemZ::LLILL", "SystemZ::LLILH", "SystemZ::IIHF", "SystemZ::LLIHL", "SystemZ::LLIHH", "SystemZ::WFADB", "SystemZ::ADBR", "SystemZ::WFDDB", "SystemZ::DDBR", "SystemZ::WFIDB", "SystemZ::FIDBRA", "SystemZ::WLDEB", "SystemZ::LDEBR", "SystemZ::WLEDB", "SystemZ::LEDBRA", "SystemZ::WFMDB", "SystemZ::MDBR", "SystemZ::WFLCDB", "SystemZ::LCDFR", "SystemZ::WFLNDB", "SystemZ::LNDFR", "SystemZ::WFLPDB", "SystemZ::LPDFR", "SystemZ::WFSQDB", "SystemZ::SQDBR", "SystemZ::WFSDB", "SystemZ::SDBR", "SystemZ::WFCDB", "SystemZ::CDBR", "SystemZ::VL32", "SystemZ::LDE32", "SystemZ::VST32", "SystemZ::STE", "SystemZ::VL64", "SystemZ::LD", "SystemZ::VST64", "SystemZ::STD" ]

[]

[ "<s>", "const", "char", "*", "nds32_output_return", "(", "void", ")", "{", "char", "pattern", "[", "100", "]", ";", "rtx", "operands", "[", "2", "]", ";", "int", "re_callee_saved", "=", "cfun", "->", "machine", "->", "callee_saved_last_gpr_regno", ";", "int", "sp_adjust", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "if", "(", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", "&&", "!", "cfun", "->", "calls_alloca", ")", "operands", "[", "1", "]", "=", "GEN_INT", "(", "sp_adjust", ")", ";", "else", "operands", "[", "1", "]", "=", "GEN_INT", "(", "0", ")", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop25\\t%%0, %%1\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Function", "to", "output", "return", "operation", "." ]

[ "nds32", "100", "2", "0", "1", "1", "0", "\"pop25\\t%%0, %%1\"", "\"\"" ]

[]

[ "<s>", "static", "bool", "use_rsqrt_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "!", "flag_trapping_math", "&&", "flag_unsafe_math_optimizations", "&&", "(", "(", "aarch64_tune_params", ".", "approx_modes", "->", "recip_sqrt", "&", "AARCH64_APPROX_MODE", "(", "mode", ")", ")", "||", "flag_mrecip_low_precision_sqrt", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "safe", "to", "use", "the", "rsqrt", "optabs", "to", "optimize", "1.0/sqrt", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "rtx_insn", "*", "find_last_same_clock", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "retval", "=", "insn", ";", "rtx_insn", "*", "t", "=", "next_real_insn", "(", "insn", ")", ";", "while", "(", "t", "&&", "GET_MODE", "(", "t", ")", "!=", "TImode", ")", "{", "if", "(", "!", "DEBUG_INSN_P", "(", "t", ")", "&&", "recog_memoized", "(", "t", ")", ">=", "0", ")", "retval", "=", "t", ";", "t", "=", "next_real_insn", "(", "t", ")", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Walk", "forward", "from", "INSN", "to", "find", "the", "last", "insn", "that", "issues", "in", "the", "same", "clock", "cycle", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownOne", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "APInt", "KnownZero2", ";", "APInt", "KnownOne2", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imin", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umin", ":", "computeKnownBitsForMinMax", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "Op", ".", "getOperand", "(", "2", ")", ",", "KnownZero", ",", "KnownOne", ",", "DAG", ",", "Depth", ")", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "}", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "{", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "32", ",", "31", ")", ";", "break", ";", "}", "case", "AMDGPUISD", "::", "BFE_I32", ":", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "CWidth", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "CWidth", ")", "return", ";", "unsigned", "BitWidth", "=", "32", ";", "uint32_t", "Width", "=", "CWidth", "->", "getZExtValue", "(", ")", "&", "0x1f", ";", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BFE_U32", ")", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "Width", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "AMDGPU", "AMDGPU", "0", "ISD::INTRINSIC_WO_CHAIN", "0", "AMDGPUIntrinsic::AMDGPU_imax", "AMDGPUIntrinsic::AMDGPU_umax", "AMDGPUIntrinsic::AMDGPU_imin", "AMDGPUIntrinsic::AMDGPU_umin", "1", "2", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "32", "31", "AMDGPUISD::BFE_I32", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "AMDGPUISD::BFE_U32" ]

[]

[ "<s>", "machine_mode", "aarch64_hard_regno_caller_save_mode", "(", "unsigned", "regno", ",", "unsigned", "nregs", ",", "machine_mode", "mode", ")", "{", "if", "(", "nregs", "==", "1", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "16", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", ")", "return", "mode", ";", "else", "return", "SImode", ";", "}", "else", "return", "choose_hard_reg_mode", "(", "regno", ",", "nregs", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_CALLER_SAVE_MODE", "." ]

[ "aarch64", "1", "16", "4" ]

[]

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

[ "Check", "whether", "this", "section", "is", "``", "virtual", "''", ",", "that", "is", "has", "no", "actual", "object", "file", "contents", "." ]

[ "TGSI" ]

[]

[ "<s>", "bool", "CSKYAsmBackend", "::", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "bool", "WasForced", ")", "const", "{", "if", "(", "!", "Resolved", "&&", "!", "WasForced", ")", "return", "true", ";", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CSKY", "::", "fixup_csky_pcrel_imm10_scale2", ":", "return", "!", "isShiftedInt", "<", "10", ",", "1", ">", "(", "Offset", ")", ";", "case", "CSKY", "::", "fixup_csky_pcrel_imm16_scale2", ":", "return", "!", "isShiftedInt", "<", "16", ",", "1", ">", "(", "Offset", ")", ";", "case", "CSKY", "::", "fixup_csky_pcrel_imm26_scale2", ":", "return", "!", "isShiftedInt", "<", "26", ",", "1", ">", "(", "Offset", ")", ";", "case", "CSKY", "::", "fixup_csky_pcrel_uimm7_scale4", ":", "return", "!", "isShiftedUInt", "<", "8", ",", "2", ">", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "CSKY", "CSKY", "CSKY::fixup_csky_pcrel_imm10_scale2", "10", "1", "CSKY::fixup_csky_pcrel_imm16_scale2", "16", "1", "CSKY::fixup_csky_pcrel_imm26_scale2", "26", "1", "CSKY::fixup_csky_pcrel_uimm7_scale4", "8", "2" ]

[]

[ "<s>", "void", "mips_split_move_insn", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "insn", ")", "{", "mips_split_move", "(", "dest", ",", "src", ",", "mips_insn_split_type", "(", "insn", ")", ",", "insn", ")", ";", "}", "</s>" ]

[ "Split", "a", "move", "from", "SRC", "to", "DEST", "in", "INSN", ",", "given", "that", "mips_split_move_insn_p", "holds", "." ]

[ "mips" ]

[]

[ "<s>", "const", "SNESSubtarget", "*", "SNESTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "{", "return", "&", "SubTarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "SNES", "SNES", "SNES" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "if", "(", "Kind", "==", "k_RegisterIndex", "&&", "RegIdx", ".", "Index", "==", "0", "&&", "RegIdx", ".", "Kind", "&", "RegKind_GPR", ")", "return", "getGPR32Reg", "(", ")", ";", "assert", "(", "Kind", "==", "k_PhysRegister", "&&", "\"Invalid access!\"", ")", ";", "return", "PhysReg", ".", "Num", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "Mips", "0", "\"Invalid access!\"" ]

[]

[ "<s>", "static", "void", "h8300_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "int", "extra_flags", "=", "0", ";", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "h8300_funcvec_function_p", "(", "decl", ")", ")", "extra_flags", "=", "SYMBOL_FLAG_FUNCVEC_FUNCTION", ";", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "decl", ")", "||", "DECL_EXTERNAL", "(", "decl", ")", ")", ")", "{", "if", "(", "h8300_eightbit_data_p", "(", "decl", ")", ")", "extra_flags", "=", "SYMBOL_FLAG_EIGHTBIT_DATA", ";", "else", "if", "(", "first", "&&", "h8300_tiny_data_p", "(", "decl", ")", ")", "extra_flags", "=", "SYMBOL_FLAG_TINY_DATA", ";", "}", "if", "(", "extra_flags", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "extra_flags", ";", "}", "</s>" ]

[ "Mark", "function", "vectors", ",", "and", "various", "small", "data", "objects", "." ]

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

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Operand", ",", "DAGCombinerInfo", "&", "DCI", ",", "unsigned", "&", "RefinementSteps", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "{", "RefinementSteps", "=", "0", ";", "return", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "RCP", ",", "SDLoc", "(", "Operand", ")", ",", "VT", ",", "Operand", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]

[ "R600", "MVT::f32", "0", "AMDGPUISD::RCP" ]

[]

[ "<s>", "static", "void", "mips_ls2_init_dfa_post_cycle_insn", "(", "void", ")", "{", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_ls2_alu1_turn_enabled_insn", "(", ")", ")", ";", "mips_ls2", ".", "alu1_turn_enabled_insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_ls2_alu2_turn_enabled_insn", "(", ")", ")", ";", "mips_ls2", ".", "alu2_turn_enabled_insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_ls2_falu1_turn_enabled_insn", "(", ")", ")", ";", "mips_ls2", ".", "falu1_turn_enabled_insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_ls2_falu2_turn_enabled_insn", "(", ")", ")", ";", "mips_ls2", ".", "falu2_turn_enabled_insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "mips_ls2", ".", "alu1_core_unit_code", "=", "get_cpu_unit_code", "(", "\"ls2_alu1_core\"", ")", ";", "mips_ls2", ".", "alu2_core_unit_code", "=", "get_cpu_unit_code", "(", "\"ls2_alu2_core\"", ")", ";", "mips_ls2", ".", "falu1_core_unit_code", "=", "get_cpu_unit_code", "(", "\"ls2_falu1_core\"", ")", ";", "mips_ls2", ".", "falu2_core_unit_code", "=", "get_cpu_unit_code", "(", "\"ls2_falu2_core\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN", "hook", "for", "Loongson2", "." ]

[ "mips", "\"ls2_alu1_core\"", "\"ls2_alu2_core\"", "\"ls2_falu1_core\"", "\"ls2_falu2_core\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorShiftByScalarCheap", "(", "Type", "*", "Ty", ")", "const", "{", "unsigned", "Bits", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "if", "(", "Bits", "==", "8", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "hasInt256", "(", ")", "&&", "(", "Bits", "==", "32", "||", "Bits", "==", "64", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "is", "used", "to", "enable", "splatted", "operand", "transforms", "for", "vector", "shifts", "and", "vector", "funnel", "shifts", "." ]

[ "X86", "X86", "8", "32", "64" ]

[]

[ "<s>", "static", "enum", "unwind_info_type", "c6x_debug_unwind_info", "(", "void", ")", "{", "if", "(", "flag_unwind_tables", "||", "flag_exceptions", ")", "return", "UI_DWARF2", ";", "return", "default_debug_unwind_info", "(", ")", ";", "}", "</s>" ]

[ "Target", "unwind", "frame", "info", "is", "generated", "from", "dwarf", "CFI", "directives", ",", "so", "always", "output", "dwarf2", "unwind", "info", "." ]

[ "c6x" ]

[]

[ "<s>", "bool", "rs6000_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "!", "arg", ".", "type", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "FLOAT128_IEEE_P", "(", "TYPE_MODE", "(", "arg", ".", "type", ")", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 IEEE 128-bit\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "AGGREGATE_TYPE_P", "(", "arg", ".", "type", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "int_size_in_bytes", "(", "arg", ".", "type", ")", "<", "0", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: variable size\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "arg", ".", "mode", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: AltiVec\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TREE_CODE", "(", "arg", ".", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "arg", ".", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_pass_big_vectors", "=", "false", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: synthetic vector\\n\"", ")", ";", "if", "(", "!", "warned_for_pass_big_vectors", ")", "{", "warning", "(", "OPT_Wpsabi", ",", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility \"", "\"guarantee\"", ")", ";", "warned_for_pass_big_vectors", "=", "true", ";", "}", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "A", "C", "expression", "that", "indicates", "when", "an", "argument", "must", "be", "passed", "by", "reference", ".", "If", "nonzero", "for", "an", "argument", ",", "a", "copy", "of", "that", "argument", "is", "made", "in", "memory", "and", "a", "pointer", "to", "the", "argument", "is", "passed", "instead", "of", "the", "argument", "itself", ".", "The", "pointer", "is", "passed", "in", "whatever", "way", "is", "appropriate", "for", "passing", "a", "pointer", "to", "that", "type", ".", "Under", "V.4", ",", "aggregates", "and", "long", "double", "are", "passed", "by", "reference", ".", "As", "an", "extension", "to", "all", "32-bit", "ABIs", ",", "AltiVec", "vectors", "are", "passed", "by", "reference", "unless", "the", "AltiVec", "vector", "extension", "ABI", "is", "in", "force", ".", "As", "an", "extension", "to", "all", "ABIs", ",", "variable", "sized", "types", "are", "passed", "by", "reference", "." ]

[ "rs6000", "0", "\"function_arg_pass_by_reference: V4 IEEE 128-bit\\n\"", "1", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", "1", "0", "\"function_arg_pass_by_reference: variable size\\n\"", "1", "\"function_arg_pass_by_reference: AltiVec\\n\"", "1", "16", "8", "\"function_arg_pass_by_reference: synthetic vector\\n\"", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility \"", "\"guarantee\"", "1", "0" ]

[]

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

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

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

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "0", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", "+", "4", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "ARM", "0", "0", "4" ]

[]

[ "<s>", "void", "SITypeRewriter", "::", "visitCallInst", "(", "CallInst", "&", "I", ")", "{", "IRBuilder", "<", ">", "Builder", "(", "&", "I", ")", ";", "SmallVector", "<", "Value", "*", ",", "8", ">", "Args", ";", "SmallVector", "<", "Type", "*", ",", "8", ">", "Types", ";", "bool", "NeedToReplace", "=", "false", ";", "Function", "*", "F", "=", "I", ".", "getCalledFunction", "(", ")", ";", "std", "::", "string", "Name", "=", "F", "->", "getName", "(", ")", ".", "str", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "I", ".", "getNumArgOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Value", "*", "Arg", "=", "I", ".", "getArgOperand", "(", "i", ")", ";", "if", "(", "Arg", "->", "getType", "(", ")", "==", "v16i8", ")", "{", "Args", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "Arg", ",", "i128", ")", ")", ";", "Types", ".", "push_back", "(", "i128", ")", ";", "NeedToReplace", "=", "true", ";", "Name", "=", "Name", "+", "\".i128\"", ";", "}", "else", "if", "(", "Arg", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", "&&", "Arg", "->", "getType", "(", ")", "->", "getVectorNumElements", "(", ")", "==", "1", "&&", "Arg", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", "==", "Type", "::", "getInt32Ty", "(", "I", ".", "getContext", "(", ")", ")", ")", "{", "Type", "*", "ElementTy", "=", "Arg", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", ";", "std", "::", "string", "TypeName", "=", "\"i32\"", ";", "InsertElementInst", "*", "Def", "=", "dyn_cast", "<", "InsertElementInst", ">", "(", "Arg", ")", ";", "assert", "(", "Def", ")", ";", "Args", ".", "push_back", "(", "Def", "->", "getOperand", "(", "1", ")", ")", ";", "Types", ".", "push_back", "(", "ElementTy", ")", ";", "std", "::", "string", "VecTypeName", "=", "\"v1\"", "+", "TypeName", ";", "Name", "=", "Name", ".", "replace", "(", "Name", ".", "find", "(", "VecTypeName", ")", ",", "VecTypeName", ".", "length", "(", ")", ",", "TypeName", ")", ";", "NeedToReplace", "=", "true", ";", "}", "else", "{", "Args", ".", "push_back", "(", "Arg", ")", ";", "Types", ".", "push_back", "(", "Arg", "->", "getType", "(", ")", ")", ";", "}", "}", "if", "(", "!", "NeedToReplace", ")", "{", "return", ";", "}", "Function", "*", "NewF", "=", "Mod", "->", "getFunction", "(", "Name", ")", ";", "if", "(", "!", "NewF", ")", "{", "NewF", "=", "Function", "::", "Create", "(", "FunctionType", "::", "get", "(", "F", "->", "getReturnType", "(", ")", ",", "Types", ",", "false", ")", ",", "GlobalValue", "::", "ExternalLinkage", ",", "Name", ",", "Mod", ")", ";", "NewF", "->", "setAttributes", "(", "F", "->", "getAttributes", "(", ")", ")", ";", "}", "I", ".", "replaceAllUsesWith", "(", "Builder", ".", "CreateCall", "(", "NewF", ",", "Args", ")", ")", ";", "I", ".", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "CallInst", "simplification", "." ]

[ "R600", "SI", "8", "8", "0", "\".i128\"", "1", "\"i32\"", "1", "\"v1\"" ]

[]

[ "<s>", "bool", "MOSTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AddrSpace", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "Scale", ">", "1", "||", "AM", ".", "Scale", "<", "0", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", ")", "{", "assert", "(", "AM", ".", "Scale", "==", "1", ")", ";", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "{", "if", "(", "is8BitIndex", "(", "AM", ".", "ScaleType", ")", ")", "return", "true", ";", "return", "!", "AM", ".", "BaseGV", "&&", "0", "<=", "AM", ".", "BaseOffs", "&&", "AM", ".", "BaseOffs", "<", "256", ";", "}", "return", "!", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "BaseOffs", "&&", "(", "is8BitIndex", "(", "AM", ".", "BaseType", ")", "||", "is8BitIndex", "(", "AM", ".", "ScaleType", ")", ")", ";", "}", "if", "(", "AM", ".", "HasBaseReg", ")", "{", "if", "(", "is8BitIndex", "(", "AM", ".", "BaseType", ")", ")", "return", "true", ";", "return", "!", "AM", ".", "BaseGV", "&&", "0", "<=", "AM", ".", "BaseOffs", "&&", "AM", ".", "BaseOffs", "<", "256", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "1", "0", "1", "0", "256", "0", "256" ]

[]

[ "<s>", "static", "unsigned", "aarch64_add_stmt_cost", "(", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "unsigned", "*", "cost", "=", "(", "unsigned", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "tree", "vectype", "=", "stmt_info", "?", "stmt_vectype", "(", "stmt_info", ")", ":", "NULL_TREE", ";", "int", "stmt_cost", "=", "aarch64_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "stmt_info", ")", ")", "{", "loop_vec_info", "loop_info", "=", "STMT_VINFO_LOOP_VINFO", "(", "stmt_info", ")", ";", "struct", "loop", "*", "loop", "=", "LOOP_VINFO_LOOP", "(", "loop_info", ")", ";", "unsigned", "nest_level", "=", "loop_depth", "(", "loop", ")", ";", "count", "*=", "nest_level", ";", "}", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost", "[", "where", "]", "+=", "retval", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.add_stmt_cost", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "ECLairMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "switch", "(", "Size", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled encodeInstruction length!\"", ")", ";", "case", "1", ":", "{", "uint8_t", "ByteBits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "ByteBits", ",", "support", "::", "big", ")", ";", "break", ";", "}", "case", "2", ":", "{", "uint16_t", "WordBits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "WordBits", ",", "support", "::", "big", ")", ";", "break", ";", "}", "case", "3", ":", "{", "uint32_t", "ByteWordBits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "uint8_t", "OpcodeBits", "=", "(", "ByteWordBits", ">>", "16", ")", "&", "0xFF", ";", "uint16_t", "ArgBits", "=", "ByteWordBits", "&", "0xFFFF", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "OpcodeBits", ",", "support", "::", "big", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "ArgBits", ",", "support", "::", "big", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "ECLair", "ECLair", "\"Unhandled encodeInstruction length!\"", "1", "support::endian", "support::big", "2", "support::endian", "support::big", "3", "16", "0xFF", "0xFFFF", "support::endian", "support::big", "support::endian", "support::big" ]

[]

[ "<s>", "void", "SPUHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "}", "</s>" ]

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

[ "CellSPU", "SPU" ]

[]

[ "<s>", "unsigned", "getJumpTableEncoding", "(", ")", "const", "override", "{", "return", "MachineJumpTableInfo", "::", "EK_Custom32", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "rtx", "ia64_single_set", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "x", "=", "PATTERN", "(", "insn", ")", ",", "ret", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "COND_EXEC", ")", "x", "=", "COND_EXEC_CODE", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SET", ")", "return", "x", ";", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_prologue_allocate_stack", ":", "case", "CODE_FOR_prologue_allocate_stack_pr", ":", "case", "CODE_FOR_epilogue_deallocate_stack", ":", "case", "CODE_FOR_epilogue_deallocate_stack_pr", ":", "ret", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "break", ";", "default", ":", "ret", "=", "single_set_2", "(", "insn", ",", "x", ")", ";", "break", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Helper", "function", "-", "like", "single_set", ",", "but", "look", "inside", "COND_EXEC", "." ]

[ "ia64", "0", "0" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "for", "(", "auto", "*", "GV", ":", "AFI", "->", "getGlobalsPromotedToConstantPool", "(", ")", ")", "PromotedGlobals", ".", "insert", "(", "GV", ")", ";", "unsigned", "OptimizationGoal", ";", "if", "(", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "OptimizeNone", ")", ")", "OptimizationGoal", "=", "6", ";", "else", "if", "(", "F", "->", "optForMinSize", "(", ")", ")", "OptimizationGoal", "=", "4", ";", "else", "if", "(", "F", "->", "optForSize", "(", ")", ")", "OptimizationGoal", "=", "3", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "OptimizationGoal", "=", "2", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "OptimizationGoal", "=", "1", ";", "else", "OptimizationGoal", "=", "5", ";", "if", "(", "OptimizationGoals", "==", "-", "1", ")", "OptimizationGoals", "=", "OptimizationGoal", ";", "else", "if", "(", "OptimizationGoals", "!=", "(", "int", ")", "OptimizationGoal", ")", "OptimizationGoals", "=", "0", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Internal", "=", "F", "->", "hasInternalLinkage", "(", ")", ";", "COFF", "::", "SymbolStorageClass", "Scl", "=", "Internal", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ";", "int", "Type", "=", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Scl", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "Type", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "if", "(", "!", "ThumbIndirectPads", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "EmitAlignment", "(", "1", ")", ";", "for", "(", "std", "::", "pair", "<", "unsigned", ",", "MCSymbol", "*", ">", "&", "TIP", ":", "ThumbIndirectPads", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "TIP", ".", "second", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MCInstBuilder", "(", "ARM", "::", "tBX", ")", ".", "addReg", "(", "TIP", ".", "first", ")", ".", "addImm", "(", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ")", ";", "}", "ThumbIndirectPads", ".", "clear", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "6", "4", "3", "2", "1", "5", "1", "0", "1", "ARM::tBX", "ARMCC::AL", "0" ]

[]

[ "<s>", "static", "void", "normalize_bitfield_mem", "(", "rtx", "*", "x", ",", "int", "*", "pos", ")", "{", "rtx", "y", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "!=", "MEM", ")", "return", ";", "y", "=", "XEXP", "(", "*", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "CONST", ")", "y", "=", "XEXP", "(", "y", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "PLUS", ")", "{", "HOST_WIDE_INT", "i", "=", "INTVAL", "(", "XEXP", "(", "y", ",", "1", ")", ")", ";", "HOST_WIDE_INT", "j", "=", "i", "%", "UNITS_PER_WORD", ";", "if", "(", "j", "!=", "0", ")", "{", "if", "(", "j", "<", "0", ")", "j", "+=", "UNITS_PER_WORD", ";", "*", "x", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "*", "x", ")", ",", "plus_constant", "(", "XEXP", "(", "y", ",", "0", ")", ",", "i", "-", "j", ")", ")", ";", "*", "pos", "+=", "BITS_PER_UNIT", "*", "j", ";", "}", "}", "}", "</s>" ]

[ "*", "X", "is", "a", "(", "9-bit", ")", "byte", "in", "memory", "and", "*", "POS", "is", "the", "first", "bit", "of", "a", "bitfield", "starting", "in", "*", "X", ".", "Modify", "*", "X", "and", "*", "POS", "such", "that", "*", "X", "is", "word", "aligned", "and", "*", "POS", "specifies", "the", "first", "bit", ",", "in", "the", "word", "that", "starts", "at", "*", "X", ",", "of", "the", "bitfield", "." ]

[ "pdp10", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "\"e-p:64:64-i64:64-n32:64-S128\"", ":", "\"e-p:32:32-i64:64-n32:64-S128\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "WebAssemblyTargetObjectFile", ">", "(", ")", ")", "{", "initAsmInfo", "(", ")", ";", "setRequiresStructuredCFG", "(", "true", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-p:64:64-i64:64-n32:64-S128\"", "\"e-p:32:32-i64:64-n32:64-S128\"", "WebAssembly" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "EXT", ":", "case", "Mips", "::", "EXT_MM", ":", "case", "Mips", "::", "INS", ":", "case", "Mips", "::", "INS_MM", ":", "case", "Mips", "::", "DINS", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "0", ",", "32", ",", "0", ",", "32", ")", ";", "case", "Mips", "::", "DINSM", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "1", ",", "64", ",", "32", ",", "64", ")", ";", "case", "Mips", "::", "DINSU", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "32", ",", "64", ",", "0", ",", "32", ",", "32", ",", "64", ")", ";", "case", "Mips", "::", "DEXT", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "0", ",", "32", ",", "0", ",", "63", ")", ";", "case", "Mips", "::", "DEXTM", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "0", ",", "32", ",", "32", ",", "64", ",", "32", ",", "64", ")", ";", "case", "Mips", "::", "DEXTU", ":", "return", "verifyInsExtInstruction", "(", "MI", ",", "ErrInfo", ",", "32", ",", "64", ",", "0", ",", "32", ",", "32", ",", "64", ")", ";", "default", ":", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "Mips", "Mips", "Mips::EXT", "Mips::EXT_MM", "Mips::INS", "Mips::INS_MM", "Mips::DINS", "0", "32", "0", "32", "0", "32", "Mips::DINSM", "0", "32", "1", "64", "32", "64", "Mips::DINSU", "32", "64", "0", "32", "32", "64", "Mips::DEXT", "0", "32", "0", "32", "0", "63", "Mips::DEXTM", "0", "32", "32", "64", "32", "64", "Mips::DEXTU", "32", "64", "0", "32", "32", "64" ]

[]

[ "<s>", "const", "MCSection", "*", "XCoreTargetObjectFile", "::", "getSectionForConstant", "(", "SectionKind", "Kind", ")", "const", "{", "if", "(", "Kind", ".", "isMergeableConst4", "(", ")", ")", "return", "MergeableConst4Section", ";", "if", "(", "Kind", ".", "isMergeableConst8", "(", ")", ")", "return", "MergeableConst8Section", ";", "if", "(", "Kind", ".", "isMergeableConst16", "(", ")", ")", "return", "MergeableConst16Section", ";", "assert", "(", "(", "Kind", ".", "isReadOnly", "(", ")", "||", "Kind", ".", "isReadOnlyWithRel", "(", ")", ")", "&&", "\"Unknown section kind\"", ")", ";", "return", "ReadOnlySection", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\"Unknown section kind\"" ]

[]

[ "<s>", "static", "void", "th_mempair_save_regs", "(", "rtx", "operands", "[", "4", "]", ")", "{", "rtx", "set1", "=", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "rtx", "set2", "=", "gen_rtx_SET", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "rtx", "insn", "=", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set1", ",", "set2", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "copy_rtx", "(", "set1", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "copy_rtx", "(", "set2", ")", ")", ";", "}", "</s>" ]

[ "Similar", "like", "riscv_save_reg", ",", "but", "saves", "two", "registers", "to", "memory", "and", "marks", "the", "resulting", "instruction", "as", "frame-related", "." ]

[ "riscv", "4", "0", "1", "2", "3", "2", "1" ]

[]

[ "<s>", "size_t", "size", "(", ")", "{", "switch", "(", "type", "(", ")", ")", "{", "case", "Scalar16", ":", "return", "2", ";", "case", "Scalar32", ":", "return", "4", ";", "case", "Scalar48", ":", "case", "Vector48", ":", "return", "6", ";", "case", "Vector80", ":", "return", "10", ";", "default", ":", "return", "2", ";", "}", "}", "</s>" ]

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

[ "Videocore", "2", "4", "6", "10", "2" ]

[]

[ "<s>", "bool", "TPCResourceModel", "::", "isResourceAvailable", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "!", "SU", "||", "!", "SU", "->", "getInstr", "(", ")", ")", "return", "false", ";", "if", "(", "!", "SU", "->", "getInstr", "(", ")", "->", "isPseudo", "(", ")", ")", "{", "if", "(", "!", "ResourcesModel", "->", "canReserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ")", "return", "false", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "Packet", "[", "i", "]", "->", "Succs", ".", "size", "(", ")", "==", "0", ")", "continue", ";", "for", "(", "SUnit", "::", "const_succ_iterator", "I", "=", "Packet", "[", "i", "]", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "Packet", "[", "i", "]", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCtrl", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getSUnit", "(", ")", "==", "SU", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "scheduling", "of", "this", "SU", "is", "possible", "in", "the", "current", "packet", "." ]

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

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "Register", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "Register", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "MBBI", "->", "isTerminator", "(", ")", ")", "MBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "std", "::", "prev", "(", "MBBI", ")", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "--", "MBBI", ";", "}", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "auto", "LastFrameDestroy", "=", "MBBI", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "RealStackSize", "=", "StackSize", "+", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "uint64_t", "FPOffset", "=", "RealStackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "FPOffset", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "FirstSPAdjustAmount", ")", "{", "uint64_t", "SecondSPAdjustAmount", "=", "MFI", ".", "getStackSize", "(", ")", "-", "FirstSPAdjustAmount", ";", "assert", "(", "SecondSPAdjustAmount", ">", "0", "&&", "\"SecondSPAdjustAmount should be greater than zero\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "SecondSPAdjustAmount", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "FirstSPAdjustAmount", ")", "StackSize", "=", "FirstSPAdjustAmount", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "emitSCSEpilogue", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV", "RISCV", "\"frame pointer should not have been eliminated\"", "0", "\"SecondSPAdjustAmount should be greater than zero\"" ]

[]

[ "<s>", "static", "void", "output_restore", "(", "rtx", "pat", ")", "{", "rtx", "operands", "[", "3", "]", ";", "if", "(", "!", "pat", ")", "{", "fputs", "(", "\"\\t restore\\n\"", ",", "asm_out_file", ")", ";", "return", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", ";", "operands", "[", "0", "]", "=", "SET_DEST", "(", "pat", ")", ";", "pat", "=", "SET_SRC", "(", "pat", ")", ";", "switch", "(", "GET_CODE", "(", "pat", ")", ")", "{", "case", "PLUS", ":", "operands", "[", "1", "]", "=", "XEXP", "(", "pat", ",", "0", ")", ";", "operands", "[", "2", "]", "=", "XEXP", "(", "pat", ",", "1", ")", ";", "output_asm_insn", "(", "\" restore %r1, %2, %Y0\"", ",", "operands", ")", ";", "break", ";", "case", "LO_SUM", ":", "operands", "[", "1", "]", "=", "XEXP", "(", "pat", ",", "0", ")", ";", "operands", "[", "2", "]", "=", "XEXP", "(", "pat", ",", "1", ")", ";", "output_asm_insn", "(", "\" restore %r1, %%lo(%a2), %Y0\"", ",", "operands", ")", ";", "break", ";", "case", "ASHIFT", ":", "operands", "[", "1", "]", "=", "XEXP", "(", "pat", ",", "0", ")", ";", "gcc_assert", "(", "XEXP", "(", "pat", ",", "1", ")", "==", "const1_rtx", ")", ";", "output_asm_insn", "(", "\" restore %r1, %r1, %Y0\"", ",", "operands", ")", ";", "break", ";", "default", ":", "operands", "[", "1", "]", "=", "pat", ";", "output_asm_insn", "(", "\" restore %%g0, %1, %Y0\"", ",", "operands", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Output", "a", "'restore", "'", "instruction", "." ]

[ "sparc", "3", "\"\\t restore\\n\"", "0", "1", "0", "2", "1", "\" restore %r1, %2, %Y0\"", "1", "0", "2", "1", "\" restore %r1, %%lo(%a2), %Y0\"", "1", "0", "1", "\" restore %r1, %r1, %Y0\"", "1", "\" restore %%g0, %1, %Y0\"" ]

[]

[ "<s>", "bool", "RISCVSExtWRemoval", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "DisableSExtWRemoval", ")", "return", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "RISCVSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "I", "++", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "RISCV", "::", "ADDIW", "||", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "||", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "!=", "0", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "continue", ";", "Register", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "SrcReg", ".", "isVirtual", "(", ")", ")", "continue", ";", "const", "MachineInstr", "&", "SrcMI", "=", "*", "MRI", ".", "getVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "isSignExtendedW", "(", "SrcMI", ",", "MRI", ")", ")", "continue", ";", "Register", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "MRI", ".", "getRegClass", "(", "DstReg", ")", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Removing redundant sign-extension\\n\"", ")", ";", "MRI", ".", "replaceRegWith", "(", "DstReg", ",", "SrcReg", ")", ";", "MRI", ".", "clearKillFlags", "(", "SrcReg", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "++", "NumRemovedSExtW", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitFunctionBodyStart", "(", ")", "{", "const", "SIMachineFunctionInfo", "&", "MFI", "=", "*", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MFI", ".", "isEntryFunction", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "STM", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "STM", ".", "hasCodeObjectV3", "(", ")", "&&", "STM", ".", "isAmdHsaOrMesa", "(", "F", ")", "&&", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_KERNEL", "||", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "SPIR_KERNEL", ")", ")", "{", "amd_kernel_code_t", "KernelCode", ";", "getAmdKernelCode", "(", "KernelCode", ",", "CurrentProgramInfo", ",", "*", "MF", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitAMDKernelCodeT", "(", "KernelCode", ")", ";", "}", "if", "(", "STM", ".", "isAmdHsaOS", "(", ")", ")", "HSAMetadataStream", "->", "emitKernel", "(", "*", "MF", ",", "CurrentProgramInfo", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "before", "the", "first", "basic", "block", "in", "the", "function", "." ]

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

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", "->", "isLabel", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MI", ";", "while", "(", "++", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isDebugValue", "(", ")", ")", ";", "if", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "return", "true", ";", "if", "(", "MI", "->", "definesRegister", "(", "ARM", "::", "SP", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "ARM", "ARM", "ARM::t2IT", "ARM::SP" ]

[]

[ "<s>", "void", "ix86_expand_lround", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op1", ")", ";", "const", "struct", "real_format", "*", "fmt", ";", "REAL_VALUE_TYPE", "pred_half", ",", "half_minus_pred_half", ";", "rtx", "adj", ";", "fmt", "=", "REAL_MODE_FORMAT", "(", "mode", ")", ";", "real_2expN", "(", "&", "half_minus_pred_half", ",", "-", "(", "fmt", "->", "p", ")", "-", "1", ",", "mode", ")", ";", "REAL_ARITHMETIC", "(", "pred_half", ",", "MINUS_EXPR", ",", "dconsthalf", ",", "half_minus_pred_half", ")", ";", "adj", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "pred_half", ",", "mode", ")", ")", ";", "ix86_sse_copysign_to_positive", "(", "adj", ",", "adj", ",", "force_reg", "(", "mode", ",", "op1", ")", ",", "NULL_RTX", ")", ";", "adj", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "adj", ",", "op1", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "expand_fix", "(", "op0", ",", "adj", ",", "0", ")", ";", "}", "</s>" ]

[ "Expand", "SSE", "sequence", "for", "computing", "lround", "from", "OP1", "storing", "into", "OP0", "." ]

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

[]

[ "<s>", "const", "std", "::", "string", "&", "AArch64CA53ErratumStub", "::", "name", "(", ")", "const", "{", "return", "m_Name", ";", "}", "</s>" ]

[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "Z80Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "static", "rtx", "arm_expand_ternop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "tree", "arg2", "=", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "rtx", "op2", "=", "expand_normal", "(", "arg2", ")", ";", "rtx", "op3", "=", "NULL_RTX", ";", "bool", "builtin_sha1cpm_p", "=", "false", ";", "if", "(", "insn_data", "[", "icode", "]", ".", "n_operands", "==", "5", ")", "{", "gcc_assert", "(", "icode", "==", "CODE_FOR_crypto_sha1c", "||", "icode", "==", "CODE_FOR_crypto_sha1p", "||", "icode", "==", "CODE_FOR_crypto_sha1m", ")", ";", "builtin_sha1cpm_p", "=", "true", ";", "}", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "mode", ";", "machine_mode", "mode2", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "3", "]", ".", "mode", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode2", ")", ")", "op2", "=", "safe_vector_operand", "(", "op2", ",", "mode2", ")", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "gcc_assert", "(", "(", "GET_MODE", "(", "op0", ")", "==", "mode0", "||", "GET_MODE", "(", "op0", ")", "==", "VOIDmode", ")", "&&", "(", "GET_MODE", "(", "op1", ")", "==", "mode1", "||", "GET_MODE", "(", "op1", ")", "==", "VOIDmode", ")", "&&", "(", "GET_MODE", "(", "op2", ")", "==", "mode2", "||", "GET_MODE", "(", "op2", ")", "==", "VOIDmode", ")", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "predicate", ")", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "3", "]", ".", "predicate", ")", "(", "op2", ",", "mode2", ")", ")", "op2", "=", "copy_to_mode_reg", "(", "mode2", ",", "op2", ")", ";", "if", "(", "builtin_sha1cpm_p", ")", "op3", "=", "GEN_INT", "(", "TARGET_BIG_END", "?", "1", ":", "0", ")", ";", "if", "(", "builtin_sha1cpm_p", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ",", "op3", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Function", "to", "expand", "ternary", "builtins", "." ]

[ "arm", "0", "1", "2", "5", "0", "1", "2", "3", "0", "1", "2", "3", "1", "0", "0" ]

[]

[ "<s>", "void", "LEGFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "{", "return", ";", "}", "unsigned", "StackReg", "=", "LEG", "::", "SP", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LEG", "::", "SUBrr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LEG", "::", "SUBri", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>" ]

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

[ "LEG", "LEG", "LEG::SP", "LEG::SUBrr", "LEG::SUBri" ]

[]

[ "<s>", "bool", "PatmosSPClone", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "SPRoots", ".", "empty", "(", ")", ")", "{", "errs", "(", ")", "<<", "\"Following single-path roots were not found:\\n\"", ";", "for", "(", "auto", "it", "=", "SPRoots", ".", "begin", "(", ")", ";", "it", "!=", "SPRoots", ".", "end", "(", ")", ";", "++", "it", ")", "{", "errs", "(", ")", "<<", "\"'\"", "<<", "*", "it", "<<", "\"' \"", ";", "}", "errs", "(", ")", "<<", "'\\n'", ";", "SPRoots", ".", "clear", "(", ")", ";", "report_fatal_error", "(", "\"Single-path code generation failed due to \"", "\"missing single-path entry functions!\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"Following single-path roots were not found:\\n\"", "\"'\"", "\"' \"", "\"Single-path code generation failed due to \"", "\"missing single-path entry functions!\"" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", ":", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "WebAssemblyTargetObjectFile", ">", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "initAsmInfo", "(", ")", ";", "setRequiresStructuredCFG", "(", "true", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", "WebAssembly" ]

[]

[ "<s>", "bool", "c6x_force_op_for_comparison_p", "(", "enum", "rtx_code", "code", ",", "rtx", "op", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "op", ")", "||", "satisfies_constraint_Iu4", "(", "op", ")", ")", "return", "false", ";", "if", "(", "(", "code", "==", "EQ", "||", "code", "==", "LT", "||", "code", "==", "GT", ")", "&&", "!", "satisfies_constraint_Is5", "(", "op", ")", ")", "return", "true", ";", "if", "(", "(", "code", "==", "GTU", "||", "code", "==", "LTU", ")", "&&", "(", "!", "TARGET_INSNS_64", "||", "!", "satisfies_constraint_Iu5", "(", "op", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "when", "we", "'re", "about", "to", "expand", "an", "integer", "compare", "operation", "which", "performs", "COMPARISON", ".", "It", "examines", "the", "second", "operand", ",", "and", "if", "it", "is", "an", "integer", "constant", "that", "can", "not", "be", "used", "directly", "on", "the", "current", "machine", "in", "a", "comparison", "insn", ",", "it", "returns", "true", "." ]

[ "c6x" ]

[]

[ "<s>", "void", "HexagonPacketizerList", "::", "undoChangedOffset", "(", "MachineInstr", "&", "MI", ")", "{", "unsigned", "BP", ",", "OP", ";", "if", "(", "!", "HII", "->", "getBaseAndOffsetPosition", "(", "MI", ",", "BP", ",", "OP", ")", ")", "llvm_unreachable", "(", "\"Unable to find base and offset operands.\"", ")", ";", "MI", ".", "getOperand", "(", "OP", ")", ".", "setImm", "(", "ChangedOffset", ")", ";", "}", "</s>" ]

[ "Undo", "the", "changed", "offset", "." ]

[ "Hexagon", "Hexagon", "\"Unable to find base and offset operands.\"" ]

[]

[ "<s>", "bool", "CSKYAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", ">=", "FirstLiteralRelocationKind", ")", "return", "true", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "CSKY", "::", "fixup_csky_got32", ":", "case", "CSKY", "::", "fixup_csky_got_imm18_scale4", ":", "case", "CSKY", "::", "fixup_csky_gotoff", ":", "case", "CSKY", "::", "fixup_csky_gotpc", ":", "case", "CSKY", "::", "fixup_csky_plt32", ":", "case", "CSKY", "::", "fixup_csky_plt_imm18_scale4", ":", "case", "CSKY", "::", "fixup_csky_doffset_imm18", ":", "case", "CSKY", "::", "fixup_csky_doffset_imm18_scale2", ":", "case", "CSKY", "::", "fixup_csky_doffset_imm18_scale4", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "CSKY", "CSKY", "CSKY::fixup_csky_got32", "CSKY::fixup_csky_got_imm18_scale4", "CSKY::fixup_csky_gotoff", "CSKY::fixup_csky_gotpc", "CSKY::fixup_csky_plt32", "CSKY::fixup_csky_plt_imm18_scale4", "CSKY::fixup_csky_doffset_imm18", "CSKY::fixup_csky_doffset_imm18_scale2", "CSKY::fixup_csky_doffset_imm18_scale4" ]

[]

[ "<s>", "bool", "FISCDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "FISC", "FISC", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "static", "void", "arm_test_fpu_data", "(", "void", ")", "{", "auto_sbitmap", "isa_all_fpubits", "(", "isa_num_bits", ")", ";", "auto_sbitmap", "fpubits", "(", "isa_num_bits", ")", ";", "auto_sbitmap", "tmpset", "(", "isa_num_bits", ")", ";", "static", "const", "enum", "isa_feature", "fpu_bitlist", "[", "]", "=", "{", "ISA_ALL_FPU_INTERNAL", ",", "isa_nobit", "}", ";", "arm_initialize_isa", "(", "isa_all_fpubits", ",", "fpu_bitlist", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "TARGET_FPU_auto", ";", "i", "++", ")", "{", "arm_initialize_isa", "(", "fpubits", ",", "all_fpus", "[", "i", "]", ".", "isa_bits", ")", ";", "bitmap_and_compl", "(", "tmpset", ",", "isa_all_fpubits", ",", "fpubits", ")", ";", "bitmap_clear", "(", "isa_all_fpubits", ")", ";", "bitmap_copy", "(", "isa_all_fpubits", ",", "tmpset", ")", ";", "}", "if", "(", "!", "bitmap_empty_p", "(", "isa_all_fpubits", ")", ")", "{", "fprintf", "(", "stderr", ",", "\"Error: found feature bits in the ALL_FPU_INTERAL\"", "\" group that are not defined by any FPU.\\n\"", "\" Check your arm-cpus.in.\\n\"", ")", ";", "ASSERT_TRUE", "(", "bitmap_empty_p", "(", "isa_all_fpubits", ")", ")", ";", "}", "}", "</s>" ]

[ "Scan", "the", "static", "data", "tables", "generated", "by", "parsecpu.awk", "looking", "for", "potential", "issues", "with", "the", "data", ".", "Here", "we", "check", "for", "consistency", "between", "the", "fpu", "bits", ",", "in", "particular", "we", "check", "that", "ISA_ALL_FPU_INTERNAL", "does", "not", "contain", "a", "feature", "bit", "that", "is", "not", "defined", "by", "any", "FPU", "flag", "." ]

[ "arm", "0", "\"Error: found feature bits in the ALL_FPU_INTERAL\"", "\" group that are not defined by any FPU.\\n\"", "\" Check your arm-cpus.in.\\n\"" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Subtarget", "->", "hasMultivalue", "(", ")", "||", "Outs", ".", "size", "(", ")", "<=", "1", "&&", "\"MVP WebAssembly can only return up to one value\"", ")", ";", "if", "(", "!", "callingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "RETURN", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "for", "(", "const", "ISD", "::", "OutputArg", "&", "Out", ":", "Outs", ")", "{", "assert", "(", "!", "Out", ".", "Flags", ".", "isByVal", "(", ")", "&&", "\"byval is not valid for return values\"", ")", ";", "assert", "(", "!", "Out", ".", "Flags", ".", "isNest", "(", ")", "&&", "\"nest is not valid for return values\"", ")", ";", "assert", "(", "Out", ".", "IsFixed", "&&", "\"non-fixed return value is not valid\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last results\"", ")", ";", "}", "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", "\"MVP WebAssembly can only return up to one value\"", "\"WebAssembly doesn't support non-C calling conventions\"", "4", "1", "WebAssemblyISD::RETURN", "MVT::Other", "ISD::OutputArg", "\"byval is not valid for return values\"", "\"nest is not valid for return values\"", "\"non-fixed return value is not valid\"", "\"WebAssembly hasn't implemented inalloca results\"", "\"WebAssembly hasn't implemented cons regs results\"", "\"WebAssembly hasn't implemented cons regs last results\"" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FPTOSI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_FPTOUI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SHUFFLE_VECTOR", ":", "return", "legalizeShuffleVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeGlobalValue", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "legalizeLoad", "(", "MI", ",", "MRI", ",", "B", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_FMAD", ":", "return", "legalizeFMad", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "legalizeFDIV", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_UDIV", ":", "case", "TargetOpcode", "::", "G_UREM", ":", "return", "legalizeUDIV_UREM", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "case", "TargetOpcode", "::", "G_SREM", ":", "return", "legalizeSDIV_SREM", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "return", "legalizeAtomicCmpXChg", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FLOG", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "1.0f", "/", "numbers", "::", "log2ef", ")", ";", "case", "TargetOpcode", "::", "G_FLOG10", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "numbers", "::", "ln2f", "/", "numbers", "::", "ln10f", ")", ";", "case", "TargetOpcode", "::", "G_FEXP", ":", "return", "legalizeFExp", "(", "MI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FPOW", ":", "return", "legalizeFPow", "(", "MI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FFLOOR", ":", "return", "legalizeFFloor", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_BUILD_VECTOR", ":", "return", "legalizeBuildVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "SI", "1.0f", "\"expected switch to return\"" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "lowerToVVP", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "unsigned", "Opcode", "=", "Op", "->", "getOpcode", "(", ")", ";", "auto", "VVPOpcodeOpt", "=", "getVVPOpcode", "(", "Opcode", ")", ";", "if", "(", "!", "VVPOpcodeOpt", ".", "hasValue", "(", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "VVPOpcode", "=", "VVPOpcodeOpt", ".", "getValue", "(", ")", ";", "const", "bool", "FromVP", "=", "ISD", "::", "isVPOpcode", "(", "Opcode", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "MVT", "MaskVT", "=", "MVT", "::", "v256i1", ";", "EVT", "OpVecVT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "LegalVecVT", "=", "getTypeToTransformTo", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "OpVecVT", ")", ";", "SDValue", "AVL", ";", "SDValue", "Mask", ";", "if", "(", "FromVP", ")", "{", "auto", "MaskIdx", "=", "ISD", "::", "getVPMaskIdx", "(", "Opcode", ")", ".", "getValue", "(", ")", ";", "auto", "AVLIdx", "=", "ISD", "::", "getVPExplicitVectorLengthIdx", "(", "Opcode", ")", ".", "getValue", "(", ")", ";", "Mask", "=", "Op", "->", "getOperand", "(", "MaskIdx", ")", ";", "AVL", "=", "Op", "->", "getOperand", "(", "AVLIdx", ")", ";", "}", "else", "{", "AVL", "=", "DAG", ".", "getConstant", "(", "OpVecVT", ".", "getVectorNumElements", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "ConstTrue", "=", "DAG", ".", "getConstant", "(", "1", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Mask", "=", "DAG", ".", "getNode", "(", "VEISD", "::", "VEC_BROADCAST", ",", "DL", ",", "MaskVT", ",", "ConstTrue", ")", ";", "}", "bool", "IsBinaryOp", "=", "false", ";", "switch", "(", "VVPOpcode", ")", "{", "case", "VEISD", "::", "VVPNAME", ":", "\\", "IsBinaryOp", "=", "true", ";", "\\", "break", ";", "}", "if", "(", "IsBinaryOp", ")", "{", "assert", "(", "LegalVecVT", ".", "isSimple", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "VVPOpcode", ",", "DL", ",", "LegalVecVT", ",", "Op", "->", "getOperand", "(", "0", ")", ",", "Op", "->", "getOperand", "(", "1", ")", ",", "Mask", ",", "AVL", ")", ";", "}", "llvm_unreachable", "(", "\"lowerToVVP called for unexpected SDNode.\"", ")", ";", "}", "</s>" ]

[ "}", "Custom", "Inserter" ]

[ "VE", "VE", "ISD::isVPOpcode", "MVT::v256i1", "ISD::getVPMaskIdx", "ISD::getVPExplicitVectorLengthIdx", "MVT::i32", "1", "MVT::i32", "VEISD::VEC_BROADCAST", "VEISD::VVPNAME", "0", "1", "\"lowerToVVP called for unexpected SDNode.\"" ]

[]

[ "<s>", "bool", "WebAssemblyReplacePhysRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Replace Physical Registers **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "MRI", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "unsigned", "PReg", "=", "WebAssembly", "::", "NoRegister", "+", "1", ";", "PReg", "<", "WebAssembly", "::", "NUM_TARGET_REGS", ";", "++", "PReg", ")", "{", "if", "(", "PReg", "==", "WebAssembly", "::", "EXPR_STACK", "||", "PReg", "==", "WebAssembly", "::", "ARGUMENTS", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "PReg", ")", ";", "unsigned", "VReg", "=", "WebAssembly", "::", "NoRegister", ";", "for", "(", "auto", "I", "=", "MRI", ".", "reg_begin", "(", "PReg", ")", ",", "E", "=", "MRI", ".", "reg_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", "++", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", ")", "{", "if", "(", "VReg", "==", "WebAssembly", "::", "NoRegister", ")", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MO", ".", "setReg", "(", "VReg", ")", ";", "if", "(", "MO", ".", "getParent", "(", ")", "->", "isDebugValue", "(", ")", ")", "MO", ".", "setIsDebug", "(", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Replace Physical Registers **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "WebAssembly::NoRegister", "1", "WebAssembly::NUM_TARGET_REGS", "WebAssembly::EXPR_STACK", "WebAssembly::ARGUMENTS", "WebAssembly::NoRegister", "WebAssembly::NoRegister" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "sh_cannot_substitute_mem_equiv_p", "(", "rtx", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "SUBST", "ca", "n't", "safely", "replace", "its", "equivalent", "during", "RA", "." ]

[ "sh" ]

[]

[ "<s>", "void", "rs6000_xcoff_declare_object_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "tree", "decl", ")", "{", "struct", "declare_alias_data", "data", "=", "{", "file", ",", "false", "}", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "name", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "symtab_node", "::", "get_create", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "}", "</s>" ]

[ "This", "macro", "produces", "the", "initial", "definition", "of", "a", "object", "(", "variable", ")", "name", ".", "Because", "AIX", "assembler", "'s", ".set", "command", "has", "unexpected", "semantics", ",", "we", "output", "all", "aliases", "as", "alternative", "labels", "in", "front", "of", "the", "definition", "." ]

[ "powerpcspe", "\":\\n\"" ]

[]

[ "<s>", "static", "void", "loongarch_save_restore_reg", "(", "machine_mode", "mode", ",", "int", "regno", ",", "HOST_WIDE_INT", "offset", ",", "loongarch_save_restore_fn", "fn", ")", "{", "rtx", "mem", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "fn", "(", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ",", "mem", ")", ";", "}", "</s>" ]

[ "Use", "FN", "to", "save", "or", "restore", "register", "REGNO", ".", "MODE", "is", "the", "register", "'s", "mode", "and", "OFFSET", "is", "the", "offset", "of", "its", "save", "slot", "from", "the", "current", "stack", "pointer", "." ]

[ "loongarch" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "genAlternativeCodeSequence", "(", "MachineInstr", "&", "Root", ",", "MachineCombinerPattern", "::", "MC_PATTERN", "Pattern", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "InsInstrs", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "DelInstrs", ",", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "InstIdxForVirtReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "Root", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "Prev", "=", "nullptr", ";", "switch", "(", "Pattern", ")", "{", "case", "MachineCombinerPattern", "::", "MC_REASSOC_AX_BY", ":", "case", "MachineCombinerPattern", "::", "MC_REASSOC_XA_BY", ":", "Prev", "=", "MRI", ".", "getUniqueVRegDef", "(", "Root", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineCombinerPattern", "::", "MC_REASSOC_AX_YB", ":", "case", "MachineCombinerPattern", "::", "MC_REASSOC_XA_YB", ":", "Prev", "=", "MRI", ".", "getUniqueVRegDef", "(", "Root", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "Prev", "&&", "\"Unknown pattern for machine combiner\"", ")", ";", "reassociateOps", "(", "Root", ",", "*", "Prev", ",", "Pattern", ",", "InsInstrs", ",", "DelInstrs", ",", "InstIdxForVirtReg", ")", ";", "return", ";", "}", "</s>" ]

[ "When", "getMachineCombinerPatterns", "(", ")", "finds", "potential", "patterns", ",", "this", "function", "generates", "the", "instructions", "that", "could", "replace", "the", "original", "code", "sequence", "." ]

[ "X86", "X86", "1", "2", "\"Unknown pattern for machine combiner\"" ]

[]

[ "<s>", "static", "int", "ix86_value_regno", "(", "enum", "machine_mode", "mode", ",", "tree", "func", ",", "tree", "fntype", ")", "{", "gcc_assert", "(", "!", "TARGET_64BIT", ")", ";", "if", "(", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ")", "return", "FIRST_MMX_REG", ";", "if", "(", "mode", "==", "TImode", "||", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", ")", ")", "return", "FIRST_SSE_REG", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "||", "!", "TARGET_FLOAT_RETURNS_IN_80387", ")", "return", "0", ";", "if", "(", "(", "func", "||", "fntype", ")", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "{", "int", "sse_level", "=", "ix86_function_sseregparm", "(", "fntype", ",", "func", ")", ";", "if", "(", "(", "sse_level", ">=", "1", "&&", "mode", "==", "SFmode", ")", "||", "(", "sse_level", "==", "2", "&&", "mode", "==", "DFmode", ")", ")", "return", "FIRST_SSE_REG", ";", "}", "return", "FIRST_FLOAT_REG", ";", "}", "</s>" ]

[ "Given", "a", "mode", ",", "return", "the", "register", "to", "use", "for", "a", "return", "value", "." ]

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

[]

[ "<s>", "bool", "AVRAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Error", "=", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "ExtraCode", ",", "O", ")", ";", "if", "(", "Error", "&&", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "if", "(", "ExtraCode", "[", "0", "]", ">=", "'A'", "&&", "ExtraCode", "[", "0", "]", "<=", "'Z'", ")", "{", "const", "MachineOperand", "&", "RegOp", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "RegOp", ".", "isReg", "(", ")", "&&", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", ")", ";", "unsigned", "Reg", "=", "RegOp", ".", "getReg", "(", ")", ";", "unsigned", "ByteNumber", "=", "ExtraCode", "[", "0", "]", "-", "'A'", ";", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "(", "void", ")", "NumOpRegs", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "BytesPerReg", "=", "TRI", ".", "getRegSizeInBits", "(", "*", "RC", ")", "/", "8", ";", "assert", "(", "BytesPerReg", "<=", "2", "&&", "\"Only 8 and 16 bit regs are supported.\"", ")", ";", "unsigned", "RegIdx", "=", "ByteNumber", "/", "BytesPerReg", ";", "assert", "(", "RegIdx", "<", "NumOpRegs", "&&", "\"Multibyte index out of range.\"", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "RegIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "BytesPerReg", "==", "2", ")", "{", "Reg", "=", "TRI", ".", "getSubReg", "(", "Reg", ",", "ByteNumber", "%", "BytesPerReg", "?", "AVR", "::", "sub_hi", ":", "AVR", "::", "sub_lo", ")", ";", "}", "O", "<<", "AVRInstPrinter", "::", "getPrettyRegisterName", "(", "Reg", ",", "MRI", ")", ";", "return", "false", ";", "}", "}", "if", "(", "Error", ")", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "AVR", "AVR", "0", "1", "0", "0", "0", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", "0", "1", "AVR", "AVR", "8", "2", "\"Only 8 and 16 bit regs are supported.\"", "\"Multibyte index out of range.\"", "2", "AVR::sub_hi", "AVR::sub_lo", "AVR" ]

[]

[ "<s>", "static", "int", "c_number", "(", "const", "char", "*", "a", ")", "{", "int", "val", "=", "0", ";", "if", "(", "digit", "(", "*", "a", ")", "&&", "!", "digit", "(", "*", "(", "a", "-", "1", ")", ")", ")", "{", "while", "(", "digit", "(", "*", "a", ")", ")", "val", "=", "10", "*", "val", "+", "(", "*", "a", "++", ")", "-", "'0'", ";", "}", "return", "val", ";", "}", "</s>" ]

[ "If", "A", "starts", "a", "group", "of", "digits", ",", "return", "their", "value", "as", "a", "number", "." ]

[ "avr", "0", "1", "10" ]

[]

[ "<s>", "bool", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "override", "{", "bool", "NoFloat", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "64", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "64" ]

[]

[ "<s>", "static", "void", "split_delayed_insns", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "JUMP_P", "(", "insn", ")", "||", "CALL_P", "(", "insn", ")", ")", "split_delayed_branch", "(", "insn", ")", ";", "}", "}", "</s>" ]

[ "Split", "every", "insn", "(", "i.e", ".", "jumps", "and", "calls", ")", "which", "can", "have", "delay", "slots", "into", "two", "parts", ":", "the", "first", "one", "is", "scheduled", "normally", "and", "emits", "the", "instruction", ",", "while", "the", "second", "one", "is", "a", "shadow", "insn", "which", "shows", "the", "side", "effect", "taking", "place", ".", "The", "second", "one", "is", "placed", "in", "the", "right", "cycle", "by", "the", "scheduler", ",", "but", "not", "emitted", "as", "an", "assembly", "instruction", "." ]

[ "c6x" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::X0", "RISCV::X1", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorShiftByScalarCheap", "(", "Type", "*", "Ty", ")", "const", "{", "unsigned", "Bits", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "if", "(", "Subtarget", ".", "hasXOP", "(", ")", "&&", "(", "Bits", "==", "8", "||", "Bits", "==", "16", "||", "Bits", "==", "32", "||", "Bits", "==", "64", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "(", "Bits", "==", "32", "||", "Bits", "==", "64", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "Bits", "==", "16", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "is", "used", "to", "enable", "splatted", "operand", "transforms", "for", "vector", "shifts", "and", "vector", "funnel", "shifts", "." ]

[ "X86", "X86", "8", "16", "32", "64", "32", "64", "16" ]

[]

[ "<s>", "const", "SISubtarget", "*", "GCNTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "StringRef", "GPU", "=", "getGPUName", "(", "F", ")", ";", "StringRef", "FS", "=", "getFeatureString", "(", "F", ")", ";", "SmallString", "<", "128", ">", "SubtargetKey", "(", "GPU", ")", ";", "SubtargetKey", ".", "append", "(", "FS", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "SubtargetKey", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "SISubtarget", ">", "(", "TargetTriple", ",", "GPU", ",", "FS", ",", "*", "this", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "SIGISelActualAccessor", "*", "GISel", "=", "new", "SIGISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AMDGPUCallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

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

[]

[ "<s>", "void", "HexagonShuffler", "::", "reset", "(", ")", "{", "Packet", ".", "clear", "(", ")", ";", "BundleFlags", "=", "0", ";", "Error", "=", "SHUFFLE_SUCCESS", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

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

[]

[ "<s>", "virtual", "const", "rvexSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "rvex", "rvex" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "VTBits", "=", "Op", ".", "getScalarValueSizeInBits", "(", ")", ";", "unsigned", "Opcode", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "X86ISD", "::", "SETCC_CARRY", ":", "return", "VTBits", ";", "case", "X86ISD", "::", "VSEXT", ":", "{", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Src", ",", "Depth", "+", "1", ")", ";", "Tmp", "+=", "VTBits", "-", "Src", ".", "getScalarValueSizeInBits", "(", ")", ";", "return", "Tmp", ";", "}", "case", "X86ISD", "::", "VSHLI", ":", "{", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Src", ",", "Depth", "+", "1", ")", ";", "APInt", "ShiftVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "->", "getAPIntValue", "(", ")", ";", "if", "(", "ShiftVal", ".", "uge", "(", "VTBits", ")", ")", "return", "VTBits", ";", "if", "(", "ShiftVal", ".", "uge", "(", "Tmp", ")", ")", "return", "1", ";", "return", "Tmp", "-", "ShiftVal", ".", "getZExtValue", "(", ")", ";", "}", "case", "X86ISD", "::", "VSRAI", ":", "{", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Src", ",", "Depth", "+", "1", ")", ";", "APInt", "ShiftVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "->", "getAPIntValue", "(", ")", ";", "ShiftVal", "+=", "Tmp", ";", "return", "ShiftVal", ".", "uge", "(", "VTBits", ")", "?", "VTBits", ":", "ShiftVal", ".", "getZExtValue", "(", ")", ";", "}", "case", "X86ISD", "::", "PCMPGT", ":", "case", "X86ISD", "::", "PCMPEQ", ":", "case", "X86ISD", "::", "CMPP", ":", "case", "X86ISD", "::", "VPCOM", ":", "case", "X86ISD", "::", "VPCOMU", ":", "return", "VTBits", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "X86", "X86", "X86ISD::SETCC_CARRY", "X86ISD::VSEXT", "0", "1", "X86ISD::VSHLI", "0", "1", "1", "1", "X86ISD::VSRAI", "0", "1", "1", "X86ISD::PCMPGT", "X86ISD::PCMPEQ", "X86ISD::CMPP", "X86ISD::VPCOM", "X86ISD::VPCOMU", "1" ]

[]

[ "<s>", "bool", "BPFAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

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

[]

[ "<s>", "void", "handle_arm_neon_h", "(", "void", ")", "{", "aarch64_simd_switcher", "simd", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "ARM_NEON_H_TYPES_LAST", ";", "i", "++", ")", "for", "(", "unsigned", "int", "count", "=", "2", ";", "count", "<=", "4", ";", "++", "count", ")", "if", "(", "!", "aarch64_scalar_builtin_type_p", "(", "aarch64_simd_types", "[", "i", "]", ".", "type", ")", ")", "register_tuple_type", "(", "count", ",", "i", ")", ";", "aarch64_init_simd_builtin_functions", "(", "true", ")", ";", "aarch64_init_simd_intrinsics", "(", ")", ";", "}", "</s>" ]

[ "Implement", "#", "pragma", "GCC", "aarch64", "``", "arm_neon.h", "''", ".", "The", "types", "and", "functions", "defined", "here", "need", "to", "be", "available", "internally", "during", "LTO", "as", "well", "." ]

[ "aarch64", "0", "2", "4" ]

[]

[ "<s>", "void", "ix86_asm_output_function_label", "(", "FILE", "*", "asm_out_file", ",", "const", "char", "*", "fname", ",", "tree", "decl", ")", "{", "bool", "is_ms_hook", "=", "ix86_function_ms_hook_prologue", "(", "decl", ")", ";", "if", "(", "is_ms_hook", ")", "{", "int", "i", ",", "filler_count", "=", "(", "TARGET_64BIT", "?", "32", ":", "16", ")", ";", "unsigned", "int", "filler_cc", "=", "0xcccccccc", ";", "for", "(", "i", "=", "0", ";", "i", "<", "filler_count", ";", "i", "+=", "4", ")", "fprintf", "(", "asm_out_file", ",", "ASM_LONG", "\" %#x\\n\"", ",", "filler_cc", ")", ";", "}", "SUBTARGET_ASM_UNWIND_INIT", "(", "asm_out_file", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "fname", ")", ";", "if", "(", "is_ms_hook", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "ASM_BYTE", "\"0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\\n\"", ")", ";", "}", "else", "{", "asm_fprintf", "(", "asm_out_file", ",", "ASM_BYTE", "\"0x8b, 0xff, 0x55, 0x8b, 0xec\\n\"", ")", ";", "}", "}", "}", "</s>" ]

[ "Write", "the", "extra", "assembler", "code", "needed", "to", "declare", "a", "function", "properly", "." ]

[ "i386", "32", "16", "0xcccccccc", "0", "4", "\" %#x\\n\"", "\"0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\\n\"", "\"0x8b, 0xff, 0x55, 0x8b, 0xec\\n\"" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "requiresFrameIndexReplacementScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", ".", "hasStackObjects", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "using", "the", "RegScavenger", "directly", "for", "frame", "elimination", "despite", "using", "requiresFrameIndexScavenging", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "void", "XNCMInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "llvm_unreachable", "(", "\"Cannot load this register from stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "\"Cannot load this register from stack slot!\"" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "MCB", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "const", "MCInstrInfo", "&", "MCII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", "->", "getIterator", "(", ")", ";", "unsigned", "IgnoreCount", "=", "0", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "if", "(", "MII", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", "||", "MII", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ")", "++", "IgnoreCount", ";", "else", "HexagonLowerToMC", "(", "MCII", ",", "&", "*", "MII", ",", "MCB", ",", "*", "this", ")", ";", "}", "else", "HexagonLowerToMC", "(", "MCII", ",", "MI", ",", "MCB", ",", "*", "this", ")", ";", "bool", "Ok", "=", "HexagonMCInstrInfo", "::", "canonicalizePacket", "(", "MCII", ",", "*", "Subtarget", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ",", "nullptr", ")", ";", "assert", "(", "Ok", ")", ";", "(", "void", ")", "Ok", ";", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "==", "0", ")", "return", ";", "OutStreamer", "->", "EmitInstruction", "(", "MCB", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "DataFlowGraph", "::", "alias", "(", "RegisterRef", "RA", ",", "RegisterRef", "RB", ")", "const", "{", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "RA", ".", "Reg", ")", ")", ";", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "RB", ".", "Reg", ")", ")", ";", "MCRegUnitMaskIterator", "UMA", "(", "RA", ".", "Reg", ",", "&", "TRI", ")", ";", "MCRegUnitMaskIterator", "UMB", "(", "RB", ".", "Reg", ",", "&", "TRI", ")", ";", "while", "(", "UMA", ".", "isValid", "(", ")", "&&", "UMB", ".", "isValid", "(", ")", ")", "{", "std", "::", "pair", "<", "uint32_t", ",", "LaneBitmask", ">", "PA", "=", "*", "UMA", ";", "std", "::", "pair", "<", "uint32_t", ",", "LaneBitmask", ">", "PB", "=", "*", "UMB", ";", "if", "(", "PA", ".", "first", "==", "PB", ".", "first", ")", "{", "if", "(", "PA", ".", "second", ".", "none", "(", ")", "||", "PB", ".", "second", ".", "none", "(", ")", ")", "return", "true", ";", "LaneBitmask", "LA", "=", "PA", ".", "second", "&", "RA", ".", "Mask", ";", "LaneBitmask", "LB", "=", "PB", ".", "second", "&", "RB", ".", "Mask", ";", "if", "(", "LA", ".", "any", "(", ")", "&&", "LB", ".", "any", "(", ")", ")", "{", "unsigned", "Root", "=", "*", "MCRegUnitRootIterator", "(", "PA", ".", "first", ",", "&", "TRI", ")", ";", "uint32_t", "SubA", "=", "TRI", ".", "getSubRegIndex", "(", "RA", ".", "Reg", ",", "Root", ")", ";", "uint32_t", "SubB", "=", "TRI", ".", "getSubRegIndex", "(", "RB", ".", "Reg", ",", "Root", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "*", "TRI", ".", "getMinimalPhysRegClass", "(", "Root", ")", ";", "LaneBitmask", "MaskA", "=", "TRI", ".", "reverseComposeSubRegIndexLaneMask", "(", "SubA", ",", "LA", ")", ";", "LaneBitmask", "MaskB", "=", "TRI", ".", "reverseComposeSubRegIndexLaneMask", "(", "SubB", ",", "LB", ")", ";", "if", "(", "(", "MaskA", "&", "MaskB", "&", "RC", ".", "LaneMask", ")", ".", "any", "(", ")", ")", "return", "true", ";", "}", "++", "UMA", ";", "++", "UMB", ";", "continue", ";", "}", "if", "(", "PA", ".", "first", "<", "PB", ".", "first", ")", "++", "UMA", ";", "else", "if", "(", "PB", ".", "first", "<", "PA", ".", "first", ")", "++", "UMB", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "alias", "-", "If", "one", "of", "the", "pointers", "is", "to", "a", "global", "that", "we", "are", "tracking", ",", "and", "the", "other", "is", "some", "random", "pointer", ",", "we", "know", "there", "can", "not", "be", "an", "alias", ",", "because", "the", "address", "of", "the", "global", "is", "n't", "taken", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "rs6000_is_valid_insert_mask", "(", "rtx", "mask", ",", "rtx", "shift", ",", "machine_mode", "mode", ")", "{", "int", "nb", ",", "ne", ";", "if", "(", "!", "rs6000_is_valid_mask", "(", "mask", ",", "&", "nb", ",", "&", "ne", ",", "mode", ")", ")", "return", "false", ";", "int", "n", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "int", "sh", "=", "INTVAL", "(", "XEXP", "(", "shift", ",", "1", ")", ")", ";", "if", "(", "sh", "<", "0", "||", "sh", ">=", "n", ")", "return", "false", ";", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "if", "(", "sh", "==", "0", ")", "code", "=", "ROTATE", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "ne", ">=", "sh", ")", "code", "=", "ASHIFT", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "nb", "<", "sh", ")", "{", "code", "=", "LSHIFTRT", ";", "sh", "=", "n", "-", "sh", ";", "}", "if", "(", "mode", "==", "DImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "ne", "==", "sh", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", ")", ";", "if", "(", "ne", ">", "nb", ")", "return", "false", ";", "if", "(", "code", "==", "ASHIFT", "&&", "ne", "<", "sh", ")", "return", "false", ";", "if", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", "&&", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "32", "-", "sh", ")", ")", "return", "true", ";", "if", "(", "code", "==", "LSHIFTRT", ")", "sh", "=", "64", "-", "sh", ";", "if", "(", "ne", "==", "sh", ")", "return", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "sh", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "MASK", "(", "a", "CONST_INT", ")", "is", "a", "valid", "mask", "for", "any", "rlwimi", "or", "rldimi", "instruction", ",", "to", "implement", "an", "insert", "with", "shift", "SHIFT", "(", "a", "ROTATE", ",", "ASHIFT", ",", "or", "LSHIFTRT", ")", "in", "mode", "MODE", "." ]

[ "powerpcspe", "1", "0", "0", "0", "0", "32", "32", "32", "32", "32", "32", "32", "64" ]

[]

[ "<s>", "void", "pass_vsetvl", "::", "emit_local_forward_vsetvls", "(", "const", "bb_info", "*", "bb", ")", "{", "auto", "&", "block_info", "=", "m_vector_manager", "->", "vector_block_infos", "[", "bb", "->", "index", "(", ")", "]", ";", "if", "(", "block_info", ".", "local_dem", ".", "empty_p", "(", ")", ")", "return", ";", "vector_insn_info", "curr_info", ";", "for", "(", "insn_info", "*", "insn", ":", "bb", "->", "real_nondebug_insns", "(", ")", ")", "{", "const", "vector_insn_info", "prev_info", "=", "curr_info", ";", "enum", "vsetvl_type", "type", "=", "NUM_VSETVL_TYPE", ";", "transfer_before", "(", "curr_info", ",", "insn", ")", ";", "if", "(", "has_vtype_op", "(", "insn", "->", "rtl", "(", ")", ")", ")", "{", "if", "(", "static_cast", "<", "const", "vl_vtype_info", "&", ">", "(", "prev_info", ")", "!=", "static_cast", "<", "const", "vl_vtype_info", "&", ">", "(", "curr_info", ")", ")", "{", "const", "auto", "require", "=", "m_vector_manager", "->", "vector_insn_infos", "[", "insn", "->", "uid", "(", ")", "]", ";", "if", "(", "!", "require", ".", "compatible_p", "(", "static_cast", "<", "const", "vl_vtype_info", "&", ">", "(", "prev_info", ")", ")", ")", "type", "=", "insert_vsetvl", "(", "EMIT_BEFORE", ",", "insn", "->", "rtl", "(", ")", ",", "require", ",", "prev_info", ")", ";", "}", "}", "if", "(", "type", "==", "VSETVL_VTYPE_CHANGE_ONLY", ")", "{", "curr_info", ".", "set_avl_info", "(", "prev_info", ".", "get_avl_info", "(", ")", ")", ";", "}", "transfer_after", "(", "curr_info", ",", "insn", ")", ";", "}", "block_info", ".", "reaching_out", "=", "curr_info", ";", "}", "</s>" ]

[ "Emit", "vsetvl", "within", "each", "block", "by", "forward", "data-flow", "analysis", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "unsigned", "ValVReg", ",", "unsigned", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", "<=", "64", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "<=", "64", "&&", "\"Unsupported location size\"", ")", ";", "markPhysRegUsed", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "ARM", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "64", "\"Unsupported value size\"", "64", "\"Unsupported location size\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getNumMicroOps", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "1", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "Class", "=", "Desc", ".", "getSchedClass", "(", ")", ";", "unsigned", "UOps", "=", "ItinData", "->", "Itineraries", "[", "Class", "]", ".", "NumMicroOps", ";", "if", "(", "UOps", ")", "return", "UOps", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected multi-uops instruction!\"", ")", ";", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "case", "ARM", "::", "VSTMQIA", ":", "return", "2", ";", "case", "ARM", "::", "VLDMDIA", ":", "case", "ARM", "::", "VLDMDIA_UPD", ":", "case", "ARM", "::", "VLDMDDB_UPD", ":", "case", "ARM", "::", "VLDMSIA", ":", "case", "ARM", "::", "VLDMSIA_UPD", ":", "case", "ARM", "::", "VLDMSDB_UPD", ":", "case", "ARM", "::", "VSTMDIA", ":", "case", "ARM", "::", "VSTMDIA_UPD", ":", "case", "ARM", "::", "VSTMDDB_UPD", ":", "case", "ARM", "::", "VSTMSIA", ":", "case", "ARM", "::", "VSTMSIA_UPD", ":", "case", "ARM", "::", "VSTMSDB_UPD", ":", "{", "unsigned", "NumRegs", "=", "MI", "->", "getNumOperands", "(", ")", "-", "Desc", ".", "getNumOperands", "(", ")", ";", "return", "(", "NumRegs", "/", "2", ")", "+", "(", "NumRegs", "%", "2", ")", "+", "1", ";", "}", "case", "ARM", "::", "LDMIA_RET", ":", "case", "ARM", "::", "LDMIA", ":", "case", "ARM", "::", "LDMDA", ":", "case", "ARM", "::", "LDMDB", ":", "case", "ARM", "::", "LDMIB", ":", "case", "ARM", "::", "LDMIA_UPD", ":", "case", "ARM", "::", "LDMDA_UPD", ":", "case", "ARM", "::", "LDMDB_UPD", ":", "case", "ARM", "::", "LDMIB_UPD", ":", "case", "ARM", "::", "STMIA", ":", "case", "ARM", "::", "STMDA", ":", "case", "ARM", "::", "STMDB", ":", "case", "ARM", "::", "STMIB", ":", "case", "ARM", "::", "STMIA_UPD", ":", "case", "ARM", "::", "STMDA_UPD", ":", "case", "ARM", "::", "STMDB_UPD", ":", "case", "ARM", "::", "STMIB_UPD", ":", "case", "ARM", "::", "tLDMIA", ":", "case", "ARM", "::", "tLDMIA_UPD", ":", "case", "ARM", "::", "tSTMIA_UPD", ":", "case", "ARM", "::", "tPOP_RET", ":", "case", "ARM", "::", "tPOP", ":", "case", "ARM", "::", "tPUSH", ":", "case", "ARM", "::", "t2LDMIA_RET", ":", "case", "ARM", "::", "t2LDMIA", ":", "case", "ARM", "::", "t2LDMDB", ":", "case", "ARM", "::", "t2LDMIA_UPD", ":", "case", "ARM", "::", "t2LDMDB_UPD", ":", "case", "ARM", "::", "t2STMIA", ":", "case", "ARM", "::", "t2STMDB", ":", "case", "ARM", "::", "t2STMIA_UPD", ":", "case", "ARM", "::", "t2STMDB_UPD", ":", "{", "unsigned", "NumRegs", "=", "MI", "->", "getNumOperands", "(", ")", "-", "Desc", ".", "getNumOperands", "(", ")", "+", "1", ";", "if", "(", "Subtarget", ".", "isCortexA8", "(", ")", ")", "{", "if", "(", "NumRegs", "<", "4", ")", "return", "2", ";", "UOps", "=", "(", "NumRegs", "/", "2", ")", ";", "if", "(", "NumRegs", "%", "2", ")", "++", "UOps", ";", "return", "UOps", ";", "}", "else", "if", "(", "Subtarget", ".", "isCortexA9", "(", ")", ")", "{", "UOps", "=", "(", "NumRegs", "/", "2", ")", ";", "if", "(", "(", "NumRegs", "%", "2", ")", "||", "!", "MI", "->", "hasOneMemOperand", "(", ")", "||", "(", "*", "MI", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", "<", "8", ")", "++", "UOps", ";", "return", "UOps", ";", "}", "else", "{", "return", "NumRegs", ";", "}", "}", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "issue", "slots", "required", "for", "this", "MI", "." ]

[ "ARM", "ARM", "1", "\"Unexpected multi-uops instruction!\"", "ARM::VLDMQIA", "ARM::VSTMQIA", "2", "ARM::VLDMDIA", "ARM::VLDMDIA_UPD", "ARM::VLDMDDB_UPD", "ARM::VLDMSIA", "ARM::VLDMSIA_UPD", "ARM::VLDMSDB_UPD", "ARM::VSTMDIA", "ARM::VSTMDIA_UPD", "ARM::VSTMDDB_UPD", "ARM::VSTMSIA", "ARM::VSTMSIA_UPD", "ARM::VSTMSDB_UPD", "2", "2", "1", "ARM::LDMIA_RET", "ARM::LDMIA", "ARM::LDMDA", "ARM::LDMDB", "ARM::LDMIB", "ARM::LDMIA_UPD", "ARM::LDMDA_UPD", "ARM::LDMDB_UPD", "ARM::LDMIB_UPD", "ARM::STMIA", "ARM::STMDA", "ARM::STMDB", "ARM::STMIB", "ARM::STMIA_UPD", "ARM::STMDA_UPD", "ARM::STMDB_UPD", "ARM::STMIB_UPD", "ARM::tLDMIA", "ARM::tLDMIA_UPD", "ARM::tSTMIA_UPD", "ARM::tPOP_RET", "ARM::tPOP", "ARM::tPUSH", "ARM::t2LDMIA_RET", "ARM::t2LDMIA", "ARM::t2LDMDB", "ARM::t2LDMIA_UPD", "ARM::t2LDMDB_UPD", "ARM::t2STMIA", "ARM::t2STMDB", "ARM::t2STMIA_UPD", "ARM::t2STMDB_UPD", "1", "4", "2", "2", "2", "2", "2", "8" ]

[]

[ "<s>", "int", "small_data_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "TARGET_SDATA_USE", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "return", "SYMBOL_REF_SMALL_P", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INT16_P", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", ")", "return", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "for", "an", "operand", "in", "small", "memory", "on", "V.4/eabi", "." ]

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

[]

[ "<s>", "bool", "MipsAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "%", "4", ")", "return", "false", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "4", "4", "0", "0" ]

[]