Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "int", "sh_contains_memref_p_1", "(", "rtx", "*", "loc", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "*", "loc", ")", "==", "MEM", ")", ";", "}", "</s>" ]

[ "Called", "by", "sh_contains_memref_p", "via", "for_each_rtx", "." ]

[ "sh" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addInstSelector", "(", ")", "{", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonRemoveExtendArgs", "(", "TM", ")", ")", ";", "addPass", "(", "createHexagonISelDag", "(", "TM", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableGenPred", ")", "addPass", "(", "createHexagonGenPredicate", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "printAndVerify", "(", "\"After hexagon peephole pass\"", ")", ";", "if", "(", "EnableGenInsert", ")", "addPass", "(", "createHexagonGenInsert", "(", ")", ",", "false", ")", ";", "if", "(", "EnableEarlyIf", ")", "addPass", "(", "createHexagonEarlyIfConversion", "(", ")", ",", "false", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"After hexagon peephole pass\"", "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "GBZ80RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "GB", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "GBZ80", "GB", "GB::SP" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "WebAssemblyAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "WebAssembly", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_code_sleb128_i32\"", ",", "0", ",", "5", "*", "8", ",", "0", "}", ",", "{", "\"fixup_code_sleb128_i64\"", ",", "0", ",", "10", "*", "8", ",", "0", "}", ",", "{", "\"fixup_code_uleb128_i32\"", ",", "0", ",", "5", "*", "8", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::NumTargetFixupKinds", "\"fixup_code_sleb128_i32\"", "0", "5", "8", "0", "\"fixup_code_sleb128_i64\"", "0", "10", "8", "0", "\"fixup_code_uleb128_i32\"", "0", "5", "8", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "inline", "bool", "offset_12bit_unsigned_scaled_p", "(", "machine_mode", "mode", ",", "poly_int64", "offset", ")", "{", "HOST_WIDE_INT", "multiple", ";", "return", "(", "constant_multiple_p", "(", "offset", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "&", "multiple", ")", "&&", "IN_RANGE", "(", "multiple", ",", "0", ",", "4095", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "an", "unsigned", "12-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

[ "aarch64", "0", "4095" ]

[]

[ "<s>", "void", "ARM64AsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "{", "assert", "(", "false", "&&", "\"ARM64AsmBackend::relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"ARM64AsmBackend::relaxInstruction() unimplemented\"" ]

[]

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

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

[ "X86", "X86", "\"unknown pcrel immediate operand\"" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "ARMConstantPoolValue", "::", "dump", "(", ")", "const", "{", "errs", "(", ")", "<<", "\" \"", "<<", "*", "this", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "ARM", "ARM", "\" \"" ]

[]

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

[ "Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "." ]

[ "SPIRV" ]

[]

[ "<s>", "int", "small_data_operand", "(", "rtx", "op", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "sym_ref", ";", "if", "(", "rs6000_sdata", "==", "SDATA_NONE", "||", "rs6000_sdata", "==", "SDATA_DATA", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "sym_ref", "=", "op", ";", "else", "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", ")", "return", "0", ";", "else", "{", "rtx", "sum", "=", "XEXP", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "summand", ";", "summand", "=", "INTVAL", "(", "XEXP", "(", "sum", ",", "1", ")", ")", ";", "if", "(", "summand", "<", "0", "||", "summand", ">", "g_switch_value", ")", "return", "0", ";", "sym_ref", "=", "XEXP", "(", "sum", ",", "0", ")", ";", "}", "return", "SYMBOL_REF_SMALL_P", "(", "sym_ref", ")", ";", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "uint32_t", "*", "M68kRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_STD_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "NumTCycles", ",", "unsigned", "ExtraTCycles", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "NumFCycles", ",", "unsigned", "ExtraFCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "int", "s390_issue_rate", "(", "void", ")", "{", "switch", "(", "s390_tune", ")", "{", "case", "PROCESSOR_2084_Z990", ":", "case", "PROCESSOR_2094_Z9_109", ":", "case", "PROCESSOR_2094_Z9_EC", ":", "case", "PROCESSOR_2817_Z196", ":", "return", "3", ";", "case", "PROCESSOR_2097_Z10", ":", "return", "2", ";", "case", "PROCESSOR_9672_G5", ":", "case", "PROCESSOR_9672_G6", ":", "case", "PROCESSOR_2064_Z900", ":", "case", "PROCESSOR_2827_ZEC12", ":", "case", "PROCESSOR_2964_Z13", ":", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "The", "number", "of", "instructions", "that", "can", "be", "issued", "per", "cycle", "." ]

[ "s390", "3", "2", "1" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "Options", ".", "StackAlignmentOverride", ",", "is64Bit", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "ELFWriterInfo", "(", "is64Bit", ",", "true", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "static", "void", "unw_access_gr", "(", "struct", "_Unwind_Context", "*", "info", ",", "int", "regnum", ",", "unsigned", "long", "*", "val", ",", "char", "*", "nat", ",", "int", "write", ")", "{", "unsigned", "long", "*", "addr", ",", "*", "nat_addr", "=", "0", ",", "nat_mask", "=", "0", ",", "dummy_nat", ";", "struct", "unw_ireg", "*", "ireg", ";", "if", "(", "(", "unsigned", ")", "regnum", "-", "1", ">=", "127", ")", "abort", "(", ")", ";", "if", "(", "regnum", "<", "1", ")", "{", "nat_addr", "=", "addr", "=", "&", "dummy_nat", ";", "dummy_nat", "=", "0", ";", "}", "else", "if", "(", "regnum", "<", "32", ")", "{", "ireg", "=", "&", "info", "->", "ireg", "[", "regnum", "-", "2", "]", ";", "addr", "=", "ireg", "->", "loc", ";", "if", "(", "addr", ")", "{", "nat_addr", "=", "addr", "+", "ireg", "->", "nat", ".", "off", ";", "switch", "(", "ireg", "->", "nat", ".", "type", ")", "{", "case", "UNW_NAT_VAL", ":", "if", "(", "write", ")", "{", "if", "(", "*", "nat", ")", "{", "addr", "[", "0", "]", "=", "0", ";", "addr", "[", "1", "]", "=", "0x1fffe", ";", "return", ";", "}", "addr", "[", "1", "]", "=", "0x1003e", ";", "}", "else", "if", "(", "addr", "[", "0", "]", "==", "0", "&&", "addr", "[", "1", "]", "==", "0x1ffe", ")", "{", "*", "val", "=", "0", ";", "*", "nat", "=", "1", ";", "return", ";", "}", "case", "UNW_NAT_NONE", ":", "dummy_nat", "=", "0", ";", "nat_addr", "=", "&", "dummy_nat", ";", "break", ";", "case", "UNW_NAT_MEMSTK", ":", "nat_mask", "=", "1UL", "<<", "(", "(", "long", ")", "addr", "&", "0x1f8", ")", "/", "8", ";", "break", ";", "case", "UNW_NAT_REGSTK", ":", "if", "(", "(", "unsigned", "long", ")", "addr", ">=", "info", "->", "regstk_top", ")", "nat_addr", "=", "&", "info", "->", "rnat", ";", "else", "nat_addr", "=", "ia64_rse_rnat_addr", "(", "addr", ")", ";", "nat_mask", "=", "1UL", "<<", "ia64_rse_slot_num", "(", "addr", ")", ";", "break", ";", "}", "}", "}", "else", "{", "addr", "=", "ia64_rse_skip_regs", "(", "(", "unsigned", "long", "*", ")", "info", "->", "bsp", ",", "regnum", "-", "32", ")", ";", "if", "(", "(", "unsigned", "long", ")", "addr", ">=", "info", "->", "regstk_top", ")", "nat_addr", "=", "&", "info", "->", "rnat", ";", "else", "nat_addr", "=", "ia64_rse_rnat_addr", "(", "addr", ")", ";", "nat_mask", "=", "1UL", "<<", "ia64_rse_slot_num", "(", "addr", ")", ";", "}", "if", "(", "write", ")", "{", "*", "addr", "=", "*", "val", ";", "if", "(", "*", "nat", ")", "*", "nat_addr", "|=", "nat_mask", ";", "else", "*", "nat_addr", "&=", "~", "nat_mask", ";", "}", "else", "{", "*", "val", "=", "*", "addr", ";", "*", "nat", "=", "(", "*", "nat_addr", "&", "nat_mask", ")", "!=", "0", ";", "}", "}", "</s>" ]

[ "Unwind", "accessors", "." ]

[ "ia64", "0", "0", "1", "127", "1", "0", "32", "2", "0", "0", "1", "0x1fffe", "1", "0x1003e", "0", "0", "1", "0x1ffe", "0", "1", "0", "1UL", "0x1f8", "8", "1UL", "32", "1UL", "0" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCallIndirectFixup", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyStoreResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUPrintfRuntimeBinding", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "return", "false", ";", "auto", "PrintfFunction", "=", "M", ".", "getFunction", "(", "\"printf\"", ")", ";", "if", "(", "!", "PrintfFunction", ")", "return", "false", ";", "for", "(", "auto", "&", "U", ":", "PrintfFunction", "->", "uses", "(", ")", ")", "{", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "if", "(", "CI", "->", "isCallee", "(", "&", "U", ")", ")", "Printfs", ".", "push_back", "(", "CI", ")", ";", "}", "}", "if", "(", "Printfs", ".", "empty", "(", ")", ")", "return", "false", ";", "TD", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "auto", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "auto", "GetTLI", "=", "[", "this", "]", "(", "Function", "&", "F", ")", "->", "TargetLibraryInfo", "&", "{", "return", "this", "->", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "F", ")", ";", "}", ";", "return", "lowerPrintfForGpu", "(", "M", ",", "GetTLI", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"printf\"" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "FIOperandNum", "=", "0", ";", "while", "(", "!", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "isFI", "(", ")", ")", "{", "++", "FIOperandNum", ";", "assert", "(", "FIOperandNum", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "*", "MI", ",", "FIOperandNum", ")", ";", "Offset", "+=", "MI", "->", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "return", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "DBG_VALUE", "||", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "STACKMAP", "||", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PATCHPOINT", "||", "(", "isInt", "<", "16", ">", "(", "Offset", ")", "&&", "(", "!", "usesIXAddr", "(", "*", "MI", ")", "||", "(", "Offset", "&", "3", ")", "==", "0", ")", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "PowerPC", "PPC", "0", "\"Instr doesn't have FrameIndex operand!\"", "PPC::DBG_VALUE", "16", "3", "0" ]

[]

[ "<s>", "static", "void", "s390_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "s390_function_arg_vector", "(", "mode", ",", "type", ")", ")", "{", "if", "(", "!", "named", ")", "return", ";", "cum", "->", "vrs", "+=", "1", ";", "}", "else", "if", "(", "s390_function_arg_float", "(", "mode", ",", "type", ")", ")", "{", "cum", "->", "fprs", "+=", "1", ";", "}", "else", "if", "(", "s390_function_arg_integer", "(", "mode", ",", "type", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "cum", "->", "gprs", "+=", "(", "(", "size", "+", "UNITS_PER_LONG", "-", "1", ")", "/", "UNITS_PER_LONG", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available.", ")", ".", "The", "boolean", "NAMED", "specifies", "whether", "the", "argument", "is", "a", "named", "argument", "(", "as", "opposed", "to", "an", "unnamed", "argument", "matching", "an", "ellipsis", ")", "." ]

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

[]

[ "<s>", "void", "prepare", "(", ")", "{", "assert", "(", "RS", "&&", "\"Cannot spill SGPR to memory without RegScavenger\"", ")", ";", "TmpVGPR", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "MI", ",", "0", ",", "false", ")", ";", "TmpVGPRIndex", "=", "MFI", ".", "getScavengeFI", "(", "MF", ".", "getFrameInfo", "(", ")", ",", "TRI", ")", ";", "if", "(", "TmpVGPR", ")", "{", "TmpVGPRLive", "=", "false", ";", "}", "else", "{", "TmpVGPR", "=", "AMDGPU", "::", "VGPR0", ";", "TmpVGPRLive", "=", "true", ";", "}", "assert", "(", "!", "SavedExecReg", "&&", "\"Exec is already saved, refuse to save again\"", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "IsWave32", "?", "AMDGPU", "::", "SGPR_32RegClass", ":", "AMDGPU", "::", "SGPR_64RegClass", ";", "RS", "->", "setRegUsed", "(", "SuperReg", ")", ";", "SavedExecReg", "=", "RS", "->", "scavengeRegister", "(", "&", "RC", ",", "MI", ",", "0", ",", "false", ")", ";", "int64_t", "VGPRLanes", "=", "getPerVGPRData", "(", ")", ".", "VGPRLanes", ";", "if", "(", "SavedExecReg", ")", "{", "RS", "->", "setRegUsed", "(", "SavedExecReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MovOpc", ")", ",", "SavedExecReg", ")", ".", "addReg", "(", "ExecReg", ")", ";", "auto", "I", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MovOpc", ")", ",", "ExecReg", ")", ".", "addImm", "(", "VGPRLanes", ")", ";", "if", "(", "!", "TmpVGPRLive", ")", "I", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "ImplicitDefine", ")", ";", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ")", ";", "}", "else", "{", "if", "(", "TmpVGPRLive", ")", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ",", "false", ")", ";", "auto", "I", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "NotOpc", ")", ",", "ExecReg", ")", ".", "addReg", "(", "ExecReg", ")", ";", "if", "(", "!", "TmpVGPRLive", ")", "I", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "ImplicitDefine", ")", ";", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ")", ";", "}", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "AMDGPU", "\"Cannot spill SGPR to memory without RegScavenger\"", "AMDGPU::VGPR_32RegClass", "0", "AMDGPU::VGPR0", "\"Exec is already saved, refuse to save again\"", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_64RegClass", "0", "0", "0", "0" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_BPF64", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "'\\n'", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i64", ":", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "BPF", "::", "GPRRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}", "else", "{", "fail", "(", "DL", ",", "DAG", ",", "\"defined with too many args\"", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "}", "if", "(", "IsVarArg", "||", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"functions with VarArgs or StructRet are not supported\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::InputArg", "\"Unsupported calling convention\"", "16", "BPF", "\"LowerFormalArguments Unhandled argument type: \"", "0", "MVT::i64", "BPF::GPRRegClass", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"defined with too many args\"", "0", "\"functions with VarArgs or StructRet are not supported\"" ]

[]

[ "<s>", "void", "ARMHazardRecognizer", "::", "Reset", "(", ")", "{", "LastMI", "=", "0", ";", "Stalls", "=", "0", ";", "ITBlockSize", "=", "0", ";", "ScoreboardHazardRecognizer", "::", "Reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

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

[]

[ "<s>", "static", "enum", "tls_model", "tls_symbolic_operand_type", "(", "rtx", "addr", ")", "{", "enum", "tls_model", "tls_kind", "=", "TLS_MODEL_NONE", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "{", "poly_int64", "addend", ";", "rtx", "sym", "=", "strip_offset", "(", "addr", ",", "&", "addend", ")", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", ")", "tls_kind", "=", "SYMBOL_REF_TLS_MODEL", "(", "sym", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", ")", "tls_kind", "=", "SYMBOL_REF_TLS_MODEL", "(", "addr", ")", ";", "return", "tls_kind", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "model", "to", "use", "for", "SYMBOL", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "const", "std", "::", "vector", "<", "SDValue", ">", "&", "BVOps", ",", "MVT", "EVT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "NumElts", "=", "BVOps", ".", "size", "(", ")", ";", "if", "(", "EVT", ".", "getSizeInBits", "(", ")", "*", "NumElts", "==", "64", ")", "return", "false", ";", "if", "(", "NumElts", "==", "2", ")", "return", "true", ";", "if", "(", "NumElts", "==", "4", ")", "{", "return", "(", "isMOVLMask", "(", "&", "BVOps", "[", "0", "]", ",", "4", ")", "||", "isCommutedMOVL", "(", "&", "BVOps", "[", "0", "]", ",", "4", ",", "true", ")", "||", "isSHUFPMask", "(", "&", "BVOps", "[", "0", "]", ",", "4", ")", "||", "isCommutedSHUFP", "(", "&", "BVOps", "[", "0", "]", ",", "4", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "64", "2", "4", "0", "4", "0", "4", "0", "4", "0", "4" ]

[]

[ "<s>", "int", "s390_arg_frame_offset", "(", ")", "{", "struct", "s390_frame", "frame", ";", "s390_frame_info", "(", "&", "frame", ")", ";", "return", "frame", ".", "frame_size", "+", "STACK_POINTER_OFFSET", ";", "}", "</s>" ]

[ "Return", "offset", "between", "argument", "pointer", "and", "frame", "pointer", "initially", "after", "prologue", "." ]

[ "s390" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "initializeSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", ";", "X86MachineFunctionInfo", "*", "AFI", "=", "Entry", "->", "getParent", "(", ")", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setIsSplitCSR", "(", "true", ")", ";", "}", "</s>" ]

[ "Perform", "necessary", "initialization", "to", "handle", "a", "subset", "of", "CSRs", "explicitly", "via", "copies", "." ]

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

[]

[ "<s>", "void", "nds32_spilt_doubleword", "(", "rtx", "*", "operands", ",", "bool", "load_p", ")", "{", "int", "reg", "=", "load_p", "?", "0", ":", "1", ";", "int", "mem", "=", "load_p", "?", "1", ":", "0", ";", "rtx", "reg_rtx", "=", "load_p", "?", "operands", "[", "0", "]", ":", "operands", "[", "1", "]", ";", "rtx", "mem_rtx", "=", "load_p", "?", "operands", "[", "1", "]", ":", "operands", "[", "0", "]", ";", "rtx", "low_part", "[", "2", "]", ",", "high_part", "[", "2", "]", ";", "rtx", "sub_mem", "=", "XEXP", "(", "mem_rtx", ",", "0", ")", ";", "low_part", "[", "reg", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "reg_rtx", ",", "GET_MODE", "(", "reg_rtx", ")", ",", "0", ")", ";", "high_part", "[", "reg", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "reg_rtx", ",", "GET_MODE", "(", "reg_rtx", ")", ",", "4", ")", ";", "if", "(", "GET_CODE", "(", "sub_mem", ")", "==", "POST_DEC", ")", "{", "sub_mem", "=", "XEXP", "(", "sub_mem", ",", "0", ")", ";", "low_part", "[", "mem", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "sub_mem", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sub_mem", ",", "GEN_INT", "(", "4", ")", ")", ")", ")", ";", "high_part", "[", "mem", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "sub_mem", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sub_mem", ",", "GEN_INT", "(", "-", "12", ")", ")", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "sub_mem", ")", "==", "POST_INC", ")", "{", "sub_mem", "=", "XEXP", "(", "sub_mem", ",", "0", ")", ";", "low_part", "[", "mem", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "sub_mem", ")", ")", ";", "high_part", "[", "mem", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "sub_mem", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "sub_mem", ")", "==", "POST_MODIFY", ")", "{", "rtx", "post_mem", "=", "XEXP", "(", "sub_mem", ",", "0", ")", ";", "rtx", "plus_op", "=", "XEXP", "(", "sub_mem", ",", "1", ")", ";", "rtx", "post_val", "=", "XEXP", "(", "plus_op", ",", "1", ")", ";", "low_part", "[", "mem", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "post_mem", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "post_mem", ",", "post_val", ")", ")", ")", ";", "high_part", "[", "mem", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "post_mem", ",", "4", ")", ")", ";", "}", "else", "{", "low_part", "[", "mem", "]", "=", "adjust_address", "(", "mem_rtx", ",", "SImode", ",", "0", ")", ";", "high_part", "[", "mem", "]", "=", "adjust_address", "(", "mem_rtx", ",", "SImode", ",", "4", ")", ";", "}", "if", "(", "(", "load_p", "&&", "reg_overlap_mentioned_p", "(", "low_part", "[", "0", "]", ",", "high_part", "[", "1", "]", ")", ")", "||", "GET_CODE", "(", "sub_mem", ")", "==", "POST_MODIFY", ")", "{", "operands", "[", "2", "]", "=", "high_part", "[", "0", "]", ";", "operands", "[", "3", "]", "=", "high_part", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "low_part", "[", "0", "]", ";", "operands", "[", "5", "]", "=", "low_part", "[", "1", "]", ";", "}", "else", "{", "operands", "[", "2", "]", "=", "low_part", "[", "0", "]", ";", "operands", "[", "3", "]", "=", "low_part", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "high_part", "[", "0", "]", ";", "operands", "[", "5", "]", "=", "high_part", "[", "1", "]", ";", "}", "}", "</s>" ]

[ "Spilt", "a", "doubleword", "instrucion", "to", "two", "single", "word", "instructions", "." ]

[ "nds32", "0", "1", "1", "0", "0", "1", "1", "0", "2", "2", "0", "0", "4", "0", "4", "12", "0", "0", "1", "1", "4", "0", "4", "0", "1", "2", "0", "3", "1", "4", "0", "5", "1", "2", "0", "3", "1", "4", "0", "5", "1" ]

[]

[ "<s>", "bool", "X86CmovConverterPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "EnableCmovConverter", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TSchedModel", ".", "init", "(", "&", "STI", ")", ";", "if", "(", "ForceMemOperand", ")", "{", "CmovGroups", "AllCmovGroups", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "4", ">", "Blocks", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Blocks", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "collectCmovCandidates", "(", "Blocks", ",", "AllCmovGroups", ",", "true", ")", ")", "{", "for", "(", "auto", "&", "Group", ":", "AllCmovGroups", ")", "{", "if", "(", "!", "llvm", "::", "any_of", "(", "Group", ",", "[", "&", "]", "(", "MachineInstr", "*", "I", ")", "{", "return", "I", "->", "mayLoad", "(", ")", ";", "}", ")", ")", "continue", ";", "Changed", "=", "true", ";", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "}", "}", "SmallVector", "<", "MachineLoop", "*", ",", "4", ">", "Loops", "(", "MLI", ".", "begin", "(", ")", ",", "MLI", ".", "end", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "(", "int", ")", "Loops", ".", "size", "(", ")", ";", "++", "i", ")", "for", "(", "MachineLoop", "*", "Child", ":", "Loops", "[", "i", "]", "->", "getSubLoops", "(", ")", ")", "Loops", ".", "push_back", "(", "Child", ")", ";", "for", "(", "MachineLoop", "*", "CurrLoop", ":", "Loops", ")", "{", "if", "(", "!", "CurrLoop", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "continue", ";", "CmovGroups", "CmovInstGroups", ";", "if", "(", "!", "collectCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "if", "(", "!", "checkForProfitableCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "Changed", "=", "true", ";", "for", "(", "auto", "&", "Group", ":", "CmovInstGroups", ")", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"********** \"", "\" : \"", "\"**********\\n\"", "4", "4", "0" ]

[]

[ "<s>", "rtx", "expand", "(", "function_expander", "&", "e", ")", "const", "OVERRIDE", "{", "return", "e", ".", "use_exact_insn", "(", "CODE_FOR_aarch64_wrffr", ")", ";", "}", "</s>" ]

[ "Expand", "the", "call", "and", "return", "its", "lhs", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "emitInst", "(", "uint32_t", "Inst", ")", "{", "char", "Buffer", "[", "4", "]", ";", "const", "bool", "LittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "EmitA64MappingSymbol", "(", ")", ";", "for", "(", "unsigned", "II", "=", "0", ";", "II", "!=", "4", ";", "++", "II", ")", "{", "const", "unsigned", "I", "=", "LittleEndian", "?", "(", "4", "-", "II", "-", "1", ")", ":", "II", ";", "Buffer", "[", "4", "-", "II", "-", "1", "]", "=", "uint8_t", "(", "Inst", ">>", "I", "*", "CHAR_BIT", ")", ";", "}", "MCELFStreamer", "::", "EmitBytes", "(", "StringRef", "(", "Buffer", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "AArch64", "4", "0", "4", "4", "1", "4", "1", "4" ]

[]

[ "<s>", "static", "rtx", "nvptx_wsync", "(", "bool", "after", ")", "{", "return", "gen_nvptx_barsync", "(", "GEN_INT", "(", "after", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "worker-level", "synchronization", "barrier", ".", "We", "use", "different", "markers", "for", "before", "and", "after", "synchronizations", "." ]

[ "nvptx" ]

[]

[ "<s>", "const", "BPFInstrInfo", "*", "getInstrInfo", "(", ")", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addLegalizeMachineIR", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "legalize", "pass", ",", "which", "converts", "the", "instruction", "sequence", "into", "one", "that", "can", "be", "selected", "by", "the", "target", "." ]

[ "AMDGPU" ]

[]

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

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

[ "BPF", "BPF" ]

[]

[ "<s>", "bool", "MSP430TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "return", "(", "VT1", ".", "getSizeInBits", "(", ")", ">", "VT2", ".", "getSizeInBits", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

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

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

[ "SystemZ", "MVT::i32" ]

[]

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

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

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressPCRel", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ")", "const", "{", "ConstantPoolSDNode", "*", "ConstPoolNode", "=", "dyn_cast", "<", "ConstantPoolSDNode", ">", "(", "N", ".", "getNode", "(", ")", ")", ";", "bool", "HasFlag", "=", "ConstPoolNode", "&&", "ConstPoolNode", "->", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PCREL_FLAG", ";", "bool", "HasNode", "=", "N", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "MAT_PCREL_ADDR", ";", "if", "(", "HasFlag", "||", "HasNode", ")", "{", "Base", "=", "N", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressPCRel", "-", "Represent", "the", "specified", "address", "as", "pc", "relative", "to", "be", "represented", "as", "[", "pc+imm", "]", "." ]

[ "PowerPC", "PPC", "PPCII::MO_PCREL_FLAG", "PPCISD::MAT_PCREL_ADDR" ]

[]

[ "<s>", "MachineInstr", "*", "WebAssemblyInstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "&", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx1", ",", "unsigned", "OpIdx2", ")", "const", "{", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "MI", ".", "getOperand", "(", "OpIdx1", ")", ".", "getReg", "(", ")", ")", "||", "MFI", ".", "isVRegStackified", "(", "MI", ".", "getOperand", "(", "OpIdx2", ")", ".", "getReg", "(", ")", ")", ")", "return", "nullptr", ";", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "</s>" ]

[ "Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "." ]

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

[]

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "BoolRC", "=", "TRI", "->", "getBoolRC", "(", ")", ";", "if", "(", "ST", ".", "isWave32", "(", ")", ")", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B32", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B32", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B32", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B32_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B32_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B32_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ";", "Exec", "=", "AMDGPU", "::", "EXEC_LO", ";", "}", "else", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B64", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B64", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B64", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B64_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B64_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B64_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "Exec", "=", "AMDGPU", "::", "EXEC", ";", "}", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ",", "Last", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Last", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "emitIf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "emitElse", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "emitIfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "emitLoop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "emitEndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_AND_B64", ":", "case", "AMDGPU", "::", "S_OR_B64", ":", "case", "AMDGPU", "::", "S_AND_B32", ":", "case", "AMDGPU", "::", "S_OR_B32", ":", "combineMasks", "(", "MI", ")", ";", "Last", "=", "I", ";", "continue", ";", "default", ":", "Last", "=", "I", ";", "continue", ";", "}", "Next", "=", "(", "Last", "==", "MBB", ".", "end", "(", ")", ")", "?", "MBB", ".", "begin", "(", ")", ":", "Last", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32", "AMDGPU::S_XOR_B32", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_ANDN2_B32_term", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_SAVEEXEC_B32", "AMDGPU::EXEC_LO", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_XOR_B64", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_OR_SAVEEXEC_B64", "AMDGPU::EXEC", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32" ]

[]

[ "<s>", "static", "rtx", "arm_trampoline_adjust_address", "(", "rtx", "addr", ")", "{", "if", "(", "TARGET_THUMB", "&&", "!", "TARGET_FDPIC", ")", "addr", "=", "expand_simple_binop", "(", "Pmode", ",", "IOR", ",", "addr", ",", "const1_rtx", ",", "NULL", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Thumb", "trampolines", "should", "be", "entered", "in", "thumb", "mode", ",", "so", "set", "the", "bottom", "bit", "of", "the", "address", "." ]

[ "arm", "0" ]

[]

[ "<s>", "int", "mmix_function_value_regno_p", "(", "int", "regno", ")", "{", "return", "regno", "==", "MMIX_RETURN_VALUE_REGNUM", ";", "}", "</s>" ]

[ "FUNCTION_VALUE_REGNO_P", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "X86Operand", ">", "CreateMem", "(", "unsigned", "ModeSize", ",", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "unsigned", "Size", "=", "0", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "nullptr", ",", "unsigned", "FrontendSize", "=", "0", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "auto", "Res", "=", "std", "::", "make_unique", "<", "X86Operand", ">", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "Res", "->", "Mem", ".", "Size", "=", "Size", ";", "Res", "->", "Mem", ".", "ModeSize", "=", "ModeSize", ";", "Res", "->", "Mem", ".", "FrontendSize", "=", "FrontendSize", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "Res", "->", "AddressOf", "=", "false", ";", "return", "Res", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "X86", "X86", "0", "0", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "shouldSignExtendTypeInLibCall", "(", "EVT", "Type", ",", "bool", "IsSigned", ")", "const", "{", "if", "(", "Subtarget", ".", "hasMips3", "(", ")", "&&", "Subtarget", ".", "useSoftFloat", "(", ")", ")", "{", "if", "(", "Type", "==", "MVT", "::", "i32", ")", "return", "true", ";", "}", "return", "IsSigned", ";", "}", "</s>" ]

[ "Returns", "true", "if", "arguments", "should", "be", "sign-extended", "in", "lib", "calls", "." ]

[ "Mips", "Mips", "Mips", "MVT::i32" ]

[]

[ "<s>", "void", "rvexAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "\"\\t.frame\\t$\"", "+", "StringRef", "(", "rvexInstPrinter", "::", "getRegisterName", "(", "stackReg", ")", ")", ".", "lower", "(", ")", "+", "\",\"", "+", "Twine", "(", "stackSize", ")", "+", "\",$\"", "+", "StringRef", "(", "rvexInstPrinter", "::", "getRegisterName", "(", "returnReg", ")", ")", ".", "lower", "(", ")", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "\"\\t.frame\\t$\"", "rvex", "\",\"", "\",$\"", "rvex" ]

[]

[ "<s>", "void", "BPFRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "MOV_rr", ")", "{", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "unsigned", "reg", "=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "II", ",", "DL", ",", "TII", ".", "get", "(", "BPF", "::", "ADD_ri", ")", ",", "reg", ")", ".", "addReg", "(", "reg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "Offset", ")", ")", "llvm_unreachable", "(", "\"bug in frame offset\"", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "FI_ri", ")", "{", "unsigned", "reg", "=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "II", ",", "DL", ",", "TII", ".", "get", "(", "BPF", "::", "MOV_rr", ")", ",", "reg", ")", ".", "addReg", "(", "FrameReg", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "BPF", "::", "ADD_ri", ")", ",", "reg", ")", ".", "addReg", "(", "reg", ")", ".", "addImm", "(", "Offset", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "BPF::MOV_rr", "1", "BPF::ADD_ri", "1", "32", "\"bug in frame offset\"", "BPF::FI_ri", "1", "BPF::MOV_rr", "BPF::ADD_ri", "1" ]

[]

[ "<s>", "unsigned", "FISCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "0" ]

[]

[ "<s>", "static", "int", "frv_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "xmode", "=", "(", "mode", "==", "BLKmode", ")", "?", "SImode", ":", "mode", ";", "int", "bytes", "=", "GET_MODE_SIZE", "(", "xmode", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "arg_num", "=", "*", "cum", ";", "int", "ret", ";", "ret", "=", "(", "(", "arg_num", "<=", "LAST_ARG_REGNUM", "&&", "arg_num", "+", "words", ">", "LAST_ARG_REGNUM", "+", "1", ")", "?", "LAST_ARG_REGNUM", "-", "arg_num", "+", "1", ":", "0", ")", ";", "ret", "*=", "UNITS_PER_WORD", ";", "if", "(", "TARGET_DEBUG_ARG", "&&", "ret", ")", "fprintf", "(", "stderr", ",", "\"frv_arg_partial_bytes: %d\\n\"", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "for", "the", "number", "of", "words", ",", "at", "the", "beginning", "of", "an", "argument", ",", "must", "be", "put", "in", "registers", ".", "The", "value", "must", "be", "zero", "for", "arguments", "that", "are", "passed", "entirely", "in", "registers", "or", "that", "are", "entirely", "pushed", "on", "the", "stack", ".", "On", "some", "machines", ",", "certain", "arguments", "must", "be", "passed", "partially", "in", "registers", "and", "partially", "in", "memory", ".", "On", "these", "machines", ",", "typically", "the", "first", "N", "words", "of", "arguments", "are", "passed", "in", "registers", ",", "and", "the", "rest", "on", "the", "stack", ".", "If", "a", "multi-word", "argument", "(", "a", "`", "double", "'", "or", "a", "structure", ")", "crosses", "that", "boundary", ",", "its", "first", "few", "words", "must", "be", "passed", "in", "registers", "and", "the", "rest", "must", "be", "pushed", ".", "This", "macro", "tells", "the", "compiler", "when", "this", "occurs", ",", "and", "how", "many", "of", "the", "words", "should", "go", "in", "registers", ".", "`", "FUNCTION_ARG", "'", "for", "these", "arguments", "should", "return", "the", "first", "register", "to", "be", "used", "by", "the", "caller", "for", "this", "argument", ";", "likewise", "`", "FUNCTION_INCOMING_ARG", "'", ",", "for", "the", "called", "function", "." ]

[ "frv", "1", "1", "1", "0", "\"frv_arg_partial_bytes: %d\\n\"" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSoftFloat", "(", "false", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "HasDSPR3", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "UseTCCInDIV", "(", "false", ")", ",", "HasSym32", "(", "false", ")", ",", "HasEVA", "(", "false", ")", ",", "DisableMadd4", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "isABI_O32", "(", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "isPositionIndependent", "(", ")", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "if", "(", "isABI_N64", "(", ")", "&&", "!", "TM", ".", "isPositionIndependent", "(", ")", "&&", "!", "hasSym32", "(", ")", ")", "NoABICalls", "=", "true", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "bool", "Split", "=", "false", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "VRegs", "[", "i", "]", ")", ";", "unsigned", "Dst", "=", "VRegs", "[", "i", "]", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "F", ".", "getCallingConv", "(", ")", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "if", "(", "!", "Split", ")", "{", "Split", "=", "true", ";", "Dst", "=", "MRI", ".", "createGenericVirtualRegister", "(", "Ty", ")", ";", "MIRBuilder", ".", "buildUndef", "(", "Dst", ")", ";", "}", "unsigned", "Tmp", "=", "MRI", ".", "createGenericVirtualRegister", "(", "Ty", ")", ";", "MIRBuilder", ".", "buildInsert", "(", "Tmp", ",", "Dst", ",", "Reg", ",", "Offset", ")", ";", "Dst", "=", "Tmp", ";", "}", ")", ";", "if", "(", "Dst", "!=", "VRegs", "[", "i", "]", ")", "MIRBuilder", ".", "buildCopy", "(", "VRegs", "[", "i", "]", ",", "Dst", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "{", "return", "false", ";", "}", "uint64_t", "StackOffset", "=", "alignTo", "(", "Handler", ".", "StackUsed", ",", "8", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MFI", ".", "CreateFixedObject", "(", "4", ",", "StackOffset", ",", "true", ")", ")", ";", "}", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "0", "AArch64", "AArch64", "AArch64", "8", "AArch64", "AArch64", "4" ]

[]

[ "<s>", "void", "TPCFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "TPC", "TPC" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isSafeToMoveRegClassDefs", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "RC", "!=", "&", "AMDGPU", "::", "EXECRegRegClass", ";", "}", "</s>" ]

[ "isSafeToMoveRegClassDefs", "-", "Return", "true", "if", "it", "'s", "safe", "to", "move", "a", "machine", "instruction", "that", "defines", "the", "specified", "register", "class", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXECRegRegClass" ]

[]

[ "<s>", "static", "void", "sh_setup_incoming_varargs", "(", "cumulative_args_t", "ca", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_arg_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "gcc_assert", "(", "cfun", "->", "stdarg", ")", ";", "if", "(", "TARGET_VARARGS_PRETEND_ARGS", "(", "current_function_decl", ")", ")", "{", "int", "named_parm_regs", "=", "0", ",", "anon_parm_regs", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "named_parm_regs", "=", "(", "sh_round_reg", "(", "*", "get_cumulative_args", "(", "ca", ")", ",", "arg", ".", "mode", ")", "+", "CEIL", "(", "arg", ".", "promoted_size_in_bytes", "(", ")", ",", "UNITS_PER_WORD", ")", ")", ";", "anon_parm_regs", "=", "NPARM_REGS", "(", "SImode", ")", "-", "named_parm_regs", ";", "if", "(", "anon_parm_regs", ">", "0", ")", "*", "pretend_arg_size", "=", "anon_parm_regs", "*", "4", ";", "}", "}", "</s>" ]

[ "We", "actually", "emit", "the", "code", "in", "sh_expand_prologue", ".", "We", "used", "to", "use", "a", "static", "variable", "to", "flag", "that", "we", "need", "to", "emit", "this", "code", ",", "but", "that", "does", "n't", "when", "inlining", ",", "when", "functions", "are", "deferred", "and", "then", "emitted", "later", ".", "Fortunately", ",", "we", "already", "have", "two", "flags", "that", "are", "part", "of", "struct", "function", "that", "tell", "if", "a", "function", "uses", "varargs", "or", "stdarg", "." ]

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

[]

[ "<s>", "bool", "SparcAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "8", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SparcOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction mnemonic\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Sparc", "Sparc", "8", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "Sparc", "\"invalid operand for instruction\"", "\"invalid instruction mnemonic\"" ]

[]

[ "<s>", "static", "reg_class_t", "cris_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "rclass", "!=", "MOF_REGS", "&&", "rclass", "!=", "MOF_SRP_REGS", "&&", "rclass", "!=", "SRP_REGS", "&&", "rclass", "!=", "CC0_REGS", "&&", "rclass", "!=", "SPECIAL_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "!", "reg_class_subset_p", "(", "rclass", ",", "GENERAL_REGS", ")", ")", "return", "NO_REGS", ";", "if", "(", "satisfies_constraint_P", "(", "x", ")", "&&", "!", "reg_class_subset_p", "(", "rclass", ",", "GENERAL_REGS", ")", ")", "return", "NO_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_PREFERRED_RELOAD_CLASS", ".", "It", "seems", "like", "gcc", "(", "2.7.2", "and", "2.9x", "of", "2000-03-22", ")", "may", "send", "``", "NO_REGS", "''", "as", "the", "class", "for", "a", "constant", "(", "testcase", ":", "__Mul", "in", "arit.c", ")", ".", "To", "avoid", "forcing", "out", "a", "constant", "into", "the", "constant", "pool", ",", "we", "will", "trap", "this", "case", "and", "return", "something", "a", "bit", "more", "sane", ".", "FIXME", ":", "Check", "if", "this", "is", "a", "bug", ".", "Beware", "that", "we", "must", "not", "``", "override", "''", "classes", "that", "can", "be", "specified", "as", "constraint", "letters", ",", "or", "else", "asm", "operands", "using", "them", "will", "fail", "when", "they", "need", "to", "be", "reloaded", ".", "FIXME", ":", "Investigate", "whether", "that", "constitutes", "a", "bug", "." ]

[ "cris" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createX86ELFObjectWriter", "(", "OS", ",", "true", ",", "OSABI", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "cris_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Zero", "initialization", "is", "OK", "for", "all", "current", "fields", "." ]

[ "cris" ]

[]

[ "<s>", "TargetPassConfig", "*", "TGSITargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "TGSIPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI" ]

[]

[ "<s>", "bool", "ARCInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "while", "(", "isPredicated", "(", "*", "I", ")", "||", "I", "->", "isTerminator", "(", ")", "||", "I", "->", "isDebugValue", "(", ")", ")", "{", "bool", "CantAnalyze", "=", "false", ";", "while", "(", "I", "->", "isDebugValue", "(", ")", "||", "!", "I", "->", "isTerminator", "(", ")", ")", "{", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "isJumpOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "!", "FBB", "&&", "\"FBB should have been null.\"", ")", ";", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "2", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "3", ")", ")", ";", "}", "else", "if", "(", "I", "->", "isReturn", "(", ")", ")", "{", "CantAnalyze", "=", "!", "isPredicated", "(", "*", "I", ")", ";", "}", "else", "{", "return", "true", ";", "}", "if", "(", "!", "isPredicated", "(", "*", "I", ")", "&&", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "I", "->", "isReturn", "(", ")", ")", ")", "{", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "AllowModify", ")", "{", "MachineBasicBlock", "::", "iterator", "DI", "=", "std", "::", "next", "(", "I", ")", ";", "while", "(", "DI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineInstr", "&", "InstToDelete", "=", "*", "DI", ";", "++", "DI", ";", "InstToDelete", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "if", "(", "CantAnalyze", ")", "return", "true", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "ARC", "ARC", "0", "\"FBB should have been null.\"", "0", "1", "2", "3" ]

[]

[ "<s>", "bool", "arm_needs_doubleword_align", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "return", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", ">", "PARM_BOUNDARY", "||", "(", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "PARM_BOUNDARY", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "double", "word", "alignment", "is", "required", "for", "argument", "passing", ".", "Return", "-1", "if", "double", "word", "alignment", "used", "to", "be", "required", "for", "argument", "passing", "before", "PR77728", "ABI", "fix", ",", "but", "is", "not", "required", "anymore", ".", "Return", "0", "if", "double", "word", "alignment", "is", "not", "required", "and", "was", "n't", "requried", "before", "either", "." ]

[ "arm" ]

[]

[ "<s>", "void", "spu_allocate_stack", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "HOST_WIDE_INT", "v", ";", "rtx", "chain", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "rtx", "stack_bot", "=", "gen_frame_mem", "(", "V4SImode", ",", "stack_pointer_rtx", ")", ";", "rtx", "sp", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "rtx", "splatted", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "rtx", "pat", "=", "gen_reg_rtx", "(", "TImode", ")", ";", "emit_move_insn", "(", "chain", ",", "stack_bot", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "v", "=", "0x1020300010203ll", ";", "emit_move_insn", "(", "pat", ",", "immed_double_const", "(", "v", ",", "v", ",", "TImode", ")", ")", ";", "emit_insn", "(", "gen_shufb", "(", "splatted", ",", "op1", ",", "op1", ",", "pat", ")", ")", ";", "emit_insn", "(", "gen_spu_convert", "(", "sp", ",", "stack_pointer_rtx", ")", ")", ";", "emit_insn", "(", "gen_subv4si3", "(", "sp", ",", "sp", ",", "splatted", ")", ")", ";", "if", "(", "flag_stack_check", ")", "{", "rtx", "avail", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "result", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_vec_extractv4si", "(", "avail", ",", "sp", ",", "GEN_INT", "(", "1", ")", ")", ")", ";", "emit_insn", "(", "gen_cgt_si", "(", "result", ",", "avail", ",", "GEN_INT", "(", "-", "1", ")", ")", ")", ";", "emit_insn", "(", "gen_spu_heq", "(", "result", ",", "GEN_INT", "(", "0", ")", ")", ")", ";", "}", "emit_insn", "(", "gen_spu_convert", "(", "stack_pointer_rtx", ",", "sp", ")", ")", ";", "emit_move_insn", "(", "stack_bot", ",", "chain", ")", ";", "emit_move_insn", "(", "op0", ",", "virtual_stack_dynamic_rtx", ")", ";", "}", "</s>" ]

[ "We", "need", "to", "correctly", "update", "the", "back", "chain", "pointer", "and", "the", "Available", "Stack", "Size", "(", "which", "is", "in", "the", "second", "slot", "of", "the", "sp", "register", ".", ")" ]

[ "spu", "0x1020300010203ll", "1", "1", "0" ]

[]

[ "<s>", "bool", "LanaiRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "static", "bool", "sh_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "to", "==", "SFmode", "&&", "VECTOR_MODE_P", "(", "from", ")", "&&", "GET_MODE_INNER", "(", "from", ")", "==", "SFmode", ")", "return", "optimize", "?", "!", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "rclass", ")", ":", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "!=", "GET_MODE_SIZE", "(", "to", ")", ")", "{", "if", "(", "TARGET_LITTLE_ENDIAN", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "to", ")", "<", "8", "||", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", "return", "!", "reg_classes_intersect_p", "(", "DF_REGS", ",", "rclass", ")", ";", "}", "else", "{", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", "return", "!", "reg_classes_intersect_p", "(", "DF_REGS", ",", "rclass", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "sh", "8", "8", "8" ]

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_OR1K32", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "OR1KMachineFunctionInfo", "*", "OR1KMFI", "=", "MF", ".", "getInfo", "<", "OR1KMachineFunctionInfo", ">", "(", ")", ";", "auto", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "unsigned", "Reg", "=", "OR1KMFI", "->", "getSRetReturnReg", "(", ")", ";", "assert", "(", "Reg", "&&", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "PtrVT", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "OR1K", "::", "R11", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "OR1K", "::", "R11", ",", "PtrVT", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "OR1KISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "ISD::OutputArg", "16", "OR1K", "4", "1", "0", "\"Can only return in registers!\"", "1", "OR1K", "OR1K", "OR1K", "OR1K", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", "OR1K::R11", "1", "OR1K::R11", "0", "OR1KISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "hasStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "SmallVectorImpl", "<", "const", "MachineMemOperand", "*", ">", "&", "Accesses", ")", "const", "{", "if", "(", "MI", ".", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", ".", "getIterator", "(", ")", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "if", "(", "TargetInstrInfo", "::", "hasStoreToStackSlot", "(", "*", "MII", ",", "Accesses", ")", ")", "return", "true", ";", "return", "false", ";", "}", "return", "TargetInstrInfo", "::", "hasStoreToStackSlot", "(", "MI", ",", "Accesses", ")", ";", "}", "</s>" ]

[ "If", "the", "specified", "machine", "instruction", "has", "a", "store", "to", "a", "stack", "slot", ",", "return", "true", "along", "with", "the", "FrameIndices", "of", "the", "loaded", "stack", "slot", "and", "the", "machine", "mem", "operands", "containing", "the", "reference", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "Thumb1InstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "MIB", ".", "addReg", "(", "0", ")", ";", "bool", "NumRegs", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NumRegs", "=", "true", ";", "}", "if", "(", "NumRegs", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Z80", "Z80" ]

[]

[ "<s>", "bool", "NVPTXFavorNonGenericAddrSpaces", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "DisableFavorNonGeneric", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "B", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "B", ")", "{", "if", "(", "isa", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "Changed", "|=", "optimizeMemoryInstruction", "(", "&", "I", ",", "0", ")", ";", "}", "else", "if", "(", "isa", "<", "StoreInst", ">", "(", "I", ")", ")", "{", "Changed", "|=", "optimizeMemoryInstruction", "(", "&", "I", ",", "1", ")", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "CCAssignFn", "*", "ARM64FastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "WebKit_JS", ")", "return", "CC_ARM64_WebKit_JS", ";", "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?", "CC_ARM64_DarwinPCS", ":", "CC_ARM64_AAPCS", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "static", "void", "aarch64_emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "rtx_insn", "*", "jump", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_reg_br_prob_note", "(", "jump", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "RETURNADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "Op", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "Op", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Custom lowering not defined for operation\"", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalAddress", "ISD::INTRINSIC_W_CHAIN", "ISD::BUILD_VECTOR", "ISD::EXTRACT_SUBVECTOR", "ISD::CONCAT_VECTORS", "ISD::STORE", "ISD::LOAD", "\"Custom lowering not defined for operation\"" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "wasm_atomic_notify", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "4", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOVolatile", "|", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "case", "Intrinsic", "::", "wasm_atomic_wait_i32", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "4", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOVolatile", "|", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "case", "Intrinsic", "::", "wasm_atomic_wait_i64", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i64", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "8", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOVolatile", "|", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "WebAssembly", "WebAssembly", "Intrinsic::wasm_atomic_notify", "ISD::INTRINSIC_W_CHAIN", "MVT::i32", "0", "0", "4", "Intrinsic::wasm_atomic_wait_i32", "ISD::INTRINSIC_W_CHAIN", "MVT::i32", "0", "0", "4", "Intrinsic::wasm_atomic_wait_i64", "ISD::INTRINSIC_W_CHAIN", "MVT::i64", "0", "0", "8" ]

[]

[ "<s>", "void", "AMDGPUDAGToDAGISel", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "AMDGPUArgumentUsageInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "SelectionDAGISel", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "hasSection", "(", ")", ")", "return", "false", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "||", "AFI", "->", "hasRedZone", "(", ")", ".", "getValueOr", "(", "true", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

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

[]

[ "<s>", "inline", "static", "int", "arm_constant_limit", "(", "bool", "size_p", ")", "{", "return", "size_p", "?", "1", ":", "current_tune", "->", "constant_limit", ";", "}", "</s>" ]

[ "The", "maximum", "number", "of", "insns", "to", "be", "used", "when", "loading", "a", "constant", "." ]

[ "arm", "1" ]

[]

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

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

[ "TPC" ]

[]

[ "<s>", "bool", "AArch64ConditionalCompares", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Compares **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SchedModel", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getSchedModel", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "MinSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "bool", "Changed", "=", "false", ";", "CmpConv", ".", "runOnMachineFunction", "(", "MF", ",", "MBPI", ")", ";", "for", "(", "auto", "*", "I", ":", "depth_first", "(", "DomTree", ")", ")", "if", "(", "tryConvert", "(", "I", "->", "getBlock", "(", ")", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Compares **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "unsigned", "AArch64TTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "auto", "*", "RetTy", "=", "ICA", ".", "getReturnType", "(", ")", ";", "switch", "(", "ICA", ".", "getID", "(", ")", ")", "{", "case", "Intrinsic", "::", "umin", ":", "case", "Intrinsic", "::", "umax", ":", "{", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "LT", ".", "second", "==", "MVT", "::", "v2i64", ")", "return", "LT", ".", "first", "*", "2", ";", "LLVM_FALLTHROUGH", ";", "}", "case", "Intrinsic", "::", "smin", ":", "case", "Intrinsic", "::", "smax", ":", "{", "static", "const", "auto", "ValidMinMaxTys", "=", "{", "MVT", "::", "v8i8", ",", "MVT", "::", "v16i8", ",", "MVT", "::", "v4i16", ",", "MVT", "::", "v8i16", ",", "MVT", "::", "v2i32", ",", "MVT", "::", "v4i32", "}", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "any_of", "(", "ValidMinMaxTys", ",", "[", "&", "LT", "]", "(", "MVT", "M", ")", "{", "return", "M", "==", "LT", ".", "second", ";", "}", ")", ")", "return", "LT", ".", "first", ";", "break", ";", "}", "default", ":", "break", ";", "}", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "AArch64", "AArch64", "Intrinsic::umin", "Intrinsic::umax", "MVT::v2i64", "2", "Intrinsic::smin", "Intrinsic::smax", "MVT::v8i8", "MVT::v16i8", "MVT::v4i16", "MVT::v8i16", "MVT::v2i32", "MVT::v4i32" ]

[]

[ "<s>", "inline", "bool", "vgpr_2reg_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", "||", "mode", "==", "V64DImode", "||", "mode", "==", "V64DFmode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "valid", "for", "pair", "of", "VGPR", "registers", "." ]

[ "gcn" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "RISCVISD", "::", "NODE", ":", "\\", "return", "\"RISCVISD::\"", "#", "NODE", ";", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", "NODE_NAME_CASE", "(", "URET_FLAG", ")", "NODE_NAME_CASE", "(", "SRET_FLAG", ")", "NODE_NAME_CASE", "(", "MRET_FLAG", ")", "NODE_NAME_CASE", "(", "CALL", ")", "NODE_NAME_CASE", "(", "SELECT_CC", ")", "NODE_NAME_CASE", "(", "BuildPairF64", ")", "NODE_NAME_CASE", "(", "SplitF64", ")", "NODE_NAME_CASE", "(", "TAIL", ")", "NODE_NAME_CASE", "(", "SLLW", ")", "NODE_NAME_CASE", "(", "SRAW", ")", "NODE_NAME_CASE", "(", "SRLW", ")", "NODE_NAME_CASE", "(", "DIVW", ")", "NODE_NAME_CASE", "(", "DIVUW", ")", "NODE_NAME_CASE", "(", "REMUW", ")", "NODE_NAME_CASE", "(", "ROLW", ")", "NODE_NAME_CASE", "(", "RORW", ")", "NODE_NAME_CASE", "(", "FSLW", ")", "NODE_NAME_CASE", "(", "FSRW", ")", "NODE_NAME_CASE", "(", "FMV_H_X", ")", "NODE_NAME_CASE", "(", "FMV_X_ANYEXTH", ")", "NODE_NAME_CASE", "(", "FMV_W_X_RV64", ")", "NODE_NAME_CASE", "(", "FMV_X_ANYEXTW_RV64", ")", "NODE_NAME_CASE", "(", "READ_CYCLE_WIDE", ")", "NODE_NAME_CASE", "(", "GREVI", ")", "NODE_NAME_CASE", "(", "GREVIW", ")", "NODE_NAME_CASE", "(", "GORCI", ")", "NODE_NAME_CASE", "(", "GORCIW", ")", "NODE_NAME_CASE", "(", "VMV_X_S", ")", "NODE_NAME_CASE", "(", "SPLAT_VECTOR_I64", ")", "NODE_NAME_CASE", "(", "READ_VLENB", ")", "NODE_NAME_CASE", "(", "TRUNCATE_VECTOR", ")", "NODE_NAME_CASE", "(", "VLEFF", ")", "NODE_NAME_CASE", "(", "VLEFF_MASK", ")", "NODE_NAME_CASE", "(", "VLSEGFF", ")", "NODE_NAME_CASE", "(", "VLSEGFF_MASK", ")", "NODE_NAME_CASE", "(", "READ_VL", ")", "NODE_NAME_CASE", "(", "VSLIDEUP", ")", "NODE_NAME_CASE", "(", "VSLIDEDOWN", ")", "NODE_NAME_CASE", "(", "VID", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::NODE", "\"RISCVISD::\"", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM PIC Global Base Reg Initialization\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM PIC Global Base Reg Initialization\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Load / Store Optimizer\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Load / Store Optimizer\"" ]

[]

[ "<s>", "void", "MipsDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "Node", ")", ")", "return", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "ReplaceNode", "(", "Node", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "assert", "(", "(", "Subtarget", "->", "systemSupportsUnalignedAccess", "(", ")", "||", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", "<=", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getAlignment", "(", ")", ")", "&&", "\"Unexpected unaligned loads/stores.\"", ")", ";", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::GLOBAL_OFFSET_TABLE", "ISD::LOAD", "ISD::STORE", "8", "\"Unexpected unaligned loads/stores.\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isStridedAccess", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "llvm", "::", "any_of", "(", "MI", ".", "memoperands", "(", ")", ",", "[", "]", "(", "MachineMemOperand", "*", "MMO", ")", "{", "return", "MMO", "->", "getFlags", "(", ")", "&", "MOStridedAccess", ";", "}", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "given", "load", "or", "store", "is", "a", "strided", "memory", "access", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "unsigned", "Cpu0MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "getCpu0RegisterNumbering", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "Cpu0", "::", "Fixups", "FixupKind", "=", "Cpu0", "::", "Fixups", "(", "0", ")", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "case", "MCSymbolRefExpr", "::", "VK_Cpu0_GPREL", ":", "FixupKind", "=", "Cpu0", "::", "fixup_Cpu0_GPREL16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Cpu0_GOT_CALL", ":", "FixupKind", "=", "Cpu0", "::", "fixup_Cpu0_CALL24", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Cpu0_GOT16", ":", "FixupKind", "=", "Cpu0", "::", "fixup_Cpu0_GOT_Global", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Cpu0_GOT", ":", "FixupKind", "=", "Cpu0", "::", "fixup_Cpu0_GOT_Local", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Cpu0_ABS_HI", ":", "FixupKind", "=", "Cpu0", "::", "fixup_Cpu0_HI16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Cpu0_ABS_LO", ":", "FixupKind", "=", "Cpu0", "::", "fixup_Cpu0_LO16", ";", "break", ";", "default", ":", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "32", "Cpu0::Fixups", "Cpu0::Fixups", "0", "Cpu0", "Cpu0::fixup_Cpu0_GPREL16", "Cpu0", "Cpu0::fixup_Cpu0_CALL24", "Cpu0", "Cpu0::fixup_Cpu0_GOT_Global", "Cpu0", "Cpu0::fixup_Cpu0_GOT_Local", "Cpu0", "Cpu0::fixup_Cpu0_HI16", "Cpu0", "Cpu0::fixup_Cpu0_LO16", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", ";", "default", ":", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "R600", "ISD::SIGN_EXTEND_INREG" ]

[]

[ "<s>", "static", "void", "ft32_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "enum", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "named_size", "=", "GET_MODE_SIZE", "(", "SImode", ")", "*", "(", "*", "cum", "-", "FT32_R0", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "named_size", "<", "24", ")", "*", "pretend_size", "=", "24", "-", "named_size", ";", "else", "*", "pretend_size", "=", "0", ";", "}", "</s>" ]

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

[ "ft32", "24", "24", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_base_register_rtx_p", "(", "rtx", "x", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "return", "(", "REG_P", "(", "x", ")", "&&", "aarch64_regno_ok_for_base_p", "(", "REGNO", "(", "x", ")", ",", "strict_p", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "base", "register", "for", "mode", "MODE", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "tree", "rs6000_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_gpr", ",", "f_fpr", ",", "f_res", ",", "f_ovf", ",", "f_sav", ",", "record", ",", "type_decl", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "return", "build_pointer_type", "(", "char_type_node", ")", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_gpr", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"gpr\"", ")", ",", "unsigned_char_type_node", ")", ";", "f_fpr", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"fpr\"", ")", ",", "unsigned_char_type_node", ")", ";", "f_res", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"reserved\"", ")", ",", "short_unsigned_type_node", ")", ";", "f_ovf", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"overflow_arg_area\"", ")", ",", "ptr_type_node", ")", ";", "f_sav", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"reg_save_area\"", ")", ",", "ptr_type_node", ")", ";", "va_list_gpr_counter_field", "=", "f_gpr", ";", "va_list_fpr_counter_field", "=", "f_fpr", ";", "DECL_FIELD_CONTEXT", "(", "f_gpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_fpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_res", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ovf", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_sav", ")", "=", "record", ";", "TREE_CHAIN", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_gpr", ";", "TREE_CHAIN", "(", "f_gpr", ")", "=", "f_fpr", ";", "TREE_CHAIN", "(", "f_fpr", ")", "=", "f_res", ";", "TREE_CHAIN", "(", "f_res", ")", "=", "f_ovf", ";", "TREE_CHAIN", "(", "f_ovf", ")", "=", "f_sav", ";", "layout_type", "(", "record", ")", ";", "return", "build_array_type", "(", "record", ",", "build_index_type", "(", "size_zero_node", ")", ")", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", "." ]

[ "rs6000", "\"__va_list_tag\"", "\"gpr\"", "\"fpr\"", "\"reserved\"", "\"overflow_arg_area\"", "\"reg_save_area\"" ]

[]

[ "<s>", "Register", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "SP", "::", "I0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "Sparc", "SP::I0" ]

[]

[ "<s>", "void", "LanaiTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", "(", "nullptr", ",", "0", ")", ";", "if", "(", "Constraint", ".", "length", "(", ")", ">", "1", ")", "return", ";", "char", "ConstraintLetter", "=", "Constraint", "[", "0", "]", ";", "switch", "(", "ConstraintLetter", ")", "{", "case", "'I'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "SDLoc", "(", "C", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'J'", ":", "case", "'O'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "C", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'K'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isUInt", "<", "16", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "SDLoc", "(", "C", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'L'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "31", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "C", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'M'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "int64_t", "Val", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "(", "isInt", "<", "32", ">", "(", "Val", ")", ")", "&&", "(", "(", "Val", "&", "0xffff", ")", "==", "0", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "SDLoc", "(", "C", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'N'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "int64_t", "Val", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "(", "Val", ">=", "-", "33554432", ")", "&&", "(", "Val", "<=", "33554431", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "SDLoc", "(", "C", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "default", ":", "break", ";", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "Lanai", "Lanai", "0", "1", "0", "16", "0", "0", "16", "31", "32", "0xffff", "0", "33554432", "33554431" ]

[]

[ "<s>", "static", "rtx", "mmix_function_arg_1", "(", "const", "cumulative_args_t", "argsp_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ",", "bool", "incoming", ")", "{", "CUMULATIVE_ARGS", "*", "argsp", "=", "get_cumulative_args", "(", "argsp_v", ")", ";", "if", "(", "type", "==", "void_type_node", ")", "return", "(", "argsp", "->", "regs", "<", "MMIX_MAX_ARGS_IN_REGS", ")", "?", "gen_rtx_REG", "(", "mode", ",", "(", "incoming", "?", "MMIX_FIRST_INCOMING_ARG_REGNUM", ":", "MMIX_FIRST_ARG_REGNUM", ")", "+", "argsp", "->", "regs", ")", ":", "NULL_RTX", ";", "return", "(", "argsp", "->", "regs", "<", "MMIX_MAX_ARGS_IN_REGS", "&&", "!", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", "&&", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "64", "||", "argsp", "->", "lib", "||", "TARGET_LIBFUNC", ")", ")", "?", "gen_rtx_REG", "(", "mode", ",", "(", "incoming", "?", "MMIX_FIRST_INCOMING_ARG_REGNUM", ":", "MMIX_FIRST_ARG_REGNUM", ")", "+", "argsp", "->", "regs", ")", ":", "NULL_RTX", ";", "}", "</s>" ]

[ "Helper", "function", "for", "mmix_function_arg", "and", "mmix_function_incoming_arg", "." ]

[ "mmix", "64" ]

[]

[ "<s>", "void", "s390_expand_plus_operand", "(", "rtx", "target", ",", "rtx", "src", ",", "rtx", "scratch", ")", "{", "rtx", "sum1", ",", "sum2", ";", "struct", "s390_address", "ad", ";", "gcc_assert", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "src", ")", "==", "Pmode", ")", ";", "sum1", "=", "find_replacement", "(", "&", "XEXP", "(", "src", ",", "0", ")", ")", ";", "sum2", "=", "find_replacement", "(", "&", "XEXP", "(", "src", ",", "1", ")", ")", ";", "src", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "sum1", ",", "sum2", ")", ";", "if", "(", "!", "s390_decompose_address", "(", "src", ",", "&", "ad", ")", "||", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "||", "(", "ad", ".", "indx", "&&", "!", "REGNO_OK_FOR_INDEX_P", "(", "REGNO", "(", "ad", ".", "indx", ")", ")", ")", ")", "{", "if", "(", "true_regnum", "(", "sum1", ")", "<", "1", "||", "true_regnum", "(", "sum1", ")", ">", "15", ")", "{", "emit_move_insn", "(", "scratch", ",", "sum1", ")", ";", "sum1", "=", "scratch", ";", "}", "if", "(", "true_regnum", "(", "sum2", ")", "<", "1", "||", "true_regnum", "(", "sum2", ")", ">", "15", ")", "{", "emit_move_insn", "(", "scratch", ",", "sum2", ")", ";", "sum2", "=", "scratch", ";", "}", "if", "(", "sum1", "==", "scratch", "&&", "sum2", "==", "scratch", ")", "{", "debug_rtx", "(", "src", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "src", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "sum1", ",", "sum2", ")", ";", "}", "s390_load_address", "(", "target", ",", "src", ")", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "SRC", ",", "which", "is", "PLUS", "that", "is", "not", "a", "legitimate", "operand", "for", "the", "LA", "instruction", ",", "into", "TARGET", ".", "SCRATCH", "may", "be", "used", "as", "scratch", "register", "." ]

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

[]

[ "<s>", "void", "mips_split_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "enum", "mips_split_type", "split_type", ")", "{", "rtx", "low_dest", ";", "gcc_checking_assert", "(", "mips_split_move_p", "(", "dest", ",", "src", ",", "split_type", ")", ")", ";", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "||", "FP_REG_RTX_P", "(", "src", ")", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "DImode", ")", "emit_insn", "(", "gen_move_doubleword_fprdi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "DFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprdf", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V2SFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprv2sf", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V2SImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv2si", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V4HImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv4hi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V8QImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv8qi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "TFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprtf", "(", "dest", ",", "src", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", "==", "MD_REG_FIRST", ")", "{", "low_dest", "=", "mips_subword", "(", "dest", ",", "false", ")", ";", "mips_emit_move", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mthidi_ti", "(", "dest", ",", "mips_subword", "(", "src", ",", "true", ")", ",", "low_dest", ")", ")", ";", "else", "emit_insn", "(", "gen_mthisi_di", "(", "dest", ",", "mips_subword", "(", "src", ",", "true", ")", ",", "low_dest", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "src", ")", "&&", "REGNO", "(", "src", ")", "==", "MD_REG_FIRST", ")", "{", "mips_emit_move", "(", "mips_subword", "(", "dest", ",", "false", ")", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mfhidi_ti", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "src", ")", ")", ";", "else", "emit_insn", "(", "gen_mfhisi_di", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "src", ")", ")", ";", "}", "else", "{", "low_dest", "=", "mips_subword", "(", "dest", ",", "false", ")", ";", "if", "(", "REG_P", "(", "low_dest", ")", "&&", "reg_overlap_mentioned_p", "(", "low_dest", ",", "src", ")", ")", "{", "mips_emit_move", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "mips_subword", "(", "src", ",", "true", ")", ")", ";", "mips_emit_move", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "}", "else", "{", "mips_emit_move", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "mips_emit_move", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "mips_subword", "(", "src", ",", "true", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "a", "move", "from", "SRC", "to", "DEST", ",", "given", "that", "mips_split_move_p", "holds", ".", "SPLIT_TYPE", "describes", "the", "split", "condition", "." ]

[ "mips" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "RegNo", ";", "}", "</s>" ]

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

[ "X86", "\"Invalid access!\"" ]

[]

[ "<s>", "bool", "X86Subtarget", "::", "enableEarlyIfConversion", "(", ")", "const", "{", "return", "hasCMov", "(", ")", "&&", "X86EarlyIfConv", ";", "}", "</s>" ]

[ "Enable", "the", "use", "of", "the", "early", "if", "conversion", "pass", "." ]

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

[]

[ "<s>", "static", "tree", "arm_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "arm", "\"%qE attribute only applies to functions\"" ]

[]

[ "<s>", "void", "ia64_split_return_addr_rtx", "(", "rtx", "dest", ")", "{", "rtx", "src", ";", "if", "(", "TEST_HARD_REG_BIT", "(", "current_frame_info", ".", "mask", ",", "BR_REG", "(", "0", ")", ")", ")", "{", "if", "(", "current_frame_info", ".", "reg_save_b0", "!=", "0", ")", "src", "=", "gen_rtx_REG", "(", "DImode", ",", "current_frame_info", ".", "reg_save_b0", ")", ";", "else", "{", "HOST_WIDE_INT", "off", ";", "unsigned", "int", "regno", ";", "off", "=", "(", "current_frame_info", ".", "spill_cfa_off", "+", "current_frame_info", ".", "spill_size", ")", ";", "for", "(", "regno", "=", "GR_REG", "(", "1", ")", ";", "regno", "<=", "GR_REG", "(", "31", ")", ";", "++", "regno", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "current_frame_info", ".", "mask", ",", "regno", ")", ")", "off", "-=", "8", ";", "if", "(", "frame_pointer_needed", ")", "src", "=", "hard_frame_pointer_rtx", ";", "else", "{", "src", "=", "stack_pointer_rtx", ";", "off", "+=", "current_frame_info", ".", "total_size", ";", "}", "if", "(", "CONST_OK_FOR_I", "(", "off", ")", ")", "emit_insn", "(", "gen_adddi3", "(", "dest", ",", "src", ",", "GEN_INT", "(", "off", ")", ")", ")", ";", "else", "{", "emit_move_insn", "(", "dest", ",", "GEN_INT", "(", "off", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "dest", ",", "src", ",", "dest", ")", ")", ";", "}", "src", "=", "gen_rtx_MEM", "(", "Pmode", ",", "dest", ")", ";", "}", "}", "else", "src", "=", "gen_rtx_REG", "(", "DImode", ",", "BR_REG", "(", "0", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Split", "this", "value", "after", "reload", ",", "now", "that", "we", "know", "where", "the", "return", "address", "is", "saved", "." ]

[ "ia64", "0", "0", "1", "31", "8", "0" ]

[]

[ "<s>", "void", "rs6000_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "[", "]", ",", "int", ")", "{", "prepend_p_to_next_insn", "=", "(", "get_attr_maybe_prefixed", "(", "insn", ")", "==", "MAYBE_PREFIXED_YES", "&&", "get_attr_prefixed", "(", "insn", ")", "==", "PREFIXED_YES", ")", ";", "return", ";", "}", "</s>" ]

[ "Define", "FINAL_PRESCAN_INSN", "if", "some", "processing", "needs", "to", "be", "done", "before", "outputting", "the", "assembler", "code", ".", "On", "the", "PowerPC", ",", "we", "remember", "if", "the", "current", "insn", "is", "a", "prefixed", "insn", "where", "we", "need", "to", "emit", "a", "'", "p", "'", "before", "the", "insn", ".", "In", "addition", ",", "if", "the", "insn", "is", "part", "of", "a", "PC-relative", "reference", "to", "an", "external", "label", "optimization", ",", "this", "is", "recorded", "also", "." ]

[ "rs6000" ]

[]