Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "int", "mips_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "struct", "mips_arg_info", "info", ";", "mips_arg_info", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "&", "info", ")", ";", "return", "info", ".", "stack_words", ">", "0", "?", "info", ".", "reg_words", "*", "UNITS_PER_WORD", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ARG_PARTIAL_BYTES", "." ]

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

[]

[ "<s>", "PreservedAnalyses", "AMDGPUPrintfRuntimeBindingPass", "::", "run", "(", "Module", "&", "M", ",", "ModuleAnalysisManager", "&", "AM", ")", "{", "FunctionAnalysisManager", "&", "FAM", "=", "AM", ".", "getResult", "<", "FunctionAnalysisManagerModuleProxy", ">", "(", "M", ")", ".", "getManager", "(", ")", ";", "auto", "GetDT", "=", "[", "&", "FAM", "]", "(", "Function", "&", "F", ")", "->", "DominatorTree", "&", "{", "return", "FAM", ".", "getResult", "<", "DominatorTreeAnalysis", ">", "(", "F", ")", ";", "}", ";", "auto", "GetTLI", "=", "[", "&", "FAM", "]", "(", "Function", "&", "F", ")", "->", "TargetLibraryInfo", "&", "{", "return", "FAM", ".", "getResult", "<", "TargetLibraryAnalysis", ">", "(", "F", ")", ";", "}", ";", "bool", "Changed", "=", "AMDGPUPrintfRuntimeBindingImpl", "(", "GetDT", ",", "GetTLI", ")", ".", "run", "(", "M", ")", ";", "return", "Changed", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

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

[]

[ "<s>", "bool", "GBZ80RegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "GBZ80", "GB" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "LC3b" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "*", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", "->", "isVarArg", "(", ")", ";", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "MFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "SystemZ", "::", "NumArgGPRs", ";", "++", "I", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "ArgGPRs", "[", "I", "]", ")", ";", "if", "(", "HasFP", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "if", "(", "MFFrame", "->", "hasCalls", "(", ")", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R14D", ")", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "CSRegs", "[", "I", "]", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSRegs", "[", "I", "]", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", "&&", "SavedRegs", ".", "test", "(", "Reg", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::NumArgGPRs", "SystemZ::ArgGPRs", "SystemZ::R11D", "SystemZ::R14D", "0", "SystemZ::GR64BitRegClass", "SystemZ::R15D" ]

[]

[ "<s>", "void", "X86AsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "bool", "Is16BitMode", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ";", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ",", "Is16BitMode", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "Inst", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::Mode16Bit", "256", "\"\\n\"", "\"unexpected instruction to relax: \"" ]

[]

[ "<s>", "bool", "aarch64_mask_and_shift_for_ubfiz_p", "(", "scalar_int_mode", "mode", ",", "rtx", "mask", ",", "rtx", "shft_amnt", ")", "{", "return", "CONST_INT_P", "(", "mask", ")", "&&", "CONST_INT_P", "(", "shft_amnt", ")", "&&", "INTVAL", "(", "shft_amnt", ")", "<", "GET_MODE_BITSIZE", "(", "mode", ")", "&&", "exact_log2", "(", "(", "INTVAL", "(", "mask", ")", ">>", "INTVAL", "(", "shft_amnt", ")", ")", "+", "1", ")", ">=", "0", "&&", "(", "INTVAL", "(", "mask", ")", "&", "(", "(", "HOST_WIDE_INT_1U", "<<", "INTVAL", "(", "shft_amnt", ")", ")", "-", "1", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "mask", "and", "a", "shift", "amount", "from", "an", "RTX", "of", "the", "form", "(", "x", "<", "<", "SHFT_AMNT", ")", "&", "MASK", "are", "valid", "to", "combine", "into", "a", "UBFIZ", "instruction", "of", "mode", "MODE", ".", "See", "the", "*", "andim_ashift", "<", "mode", ">", "_bfiz", "pattern", "." ]

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

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "ARMOperand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "make_unique", "<", "ARMOperand", ">", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "void", "PPCTTIImpl", "::", "getPeelingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "PeelingPreferences", "&", "PP", ")", "{", "BaseT", "::", "getPeelingPreferences", "(", "L", ",", "SE", ",", "PP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "peeling", "transformation", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "HexagonRemoveExtendArgs", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "unsigned", "Idx", "=", "1", ";", "for", "(", "Function", "::", "arg_iterator", "AI", "=", "F", ".", "arg_begin", "(", ")", ",", "AE", "=", "F", ".", "arg_end", "(", ")", ";", "AI", "!=", "AE", ";", "++", "AI", ",", "++", "Idx", ")", "{", "if", "(", "F", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "Argument", "*", "Arg", "=", "AI", ";", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", "->", "getType", "(", ")", ")", ")", "{", "for", "(", "Instruction", "::", "use_iterator", "UI", "=", "Arg", "->", "use_begin", "(", ")", ";", "UI", "!=", "Arg", "->", "use_end", "(", ")", ";", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "*", "UI", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "*", "UI", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "++", "UI", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "F", ".", "getEntryBlock", "(", ")", ".", "begin", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "++", "UI", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "machine_mode", "rs6000_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", ",", "int", "for_return", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "(", "TARGET_32BIT", "?", "4", ":", "8", ")", ")", "mode", "=", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "return", "mode", ";", "}", "</s>" ]

[ "On", "rs6000", ",", "function", "arguments", "are", "promoted", ",", "as", "are", "function", "return", "values", "." ]

[ "rs6000", "4", "8" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "bool", "flag", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MI", ".", "getNumOperands", "(", ")", ";", "i", "++", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "flag", "=", "true", ";", "}", "}", "return", "flag", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "Patmos", "Patmos", "0", "Patmos::PRegsRegClass" ]

[]

[ "<s>", "static", "bool", "dominates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "const_iterator", "A", ",", "MachineBasicBlock", "::", "const_iterator", "B", ")", "{", "auto", "MBBEnd", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "B", "==", "MBBEnd", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "for", "(", ";", "&", "*", "I", "!=", "A", "&&", "&", "*", "I", "!=", "B", ";", "++", "I", ")", ";", "return", "&", "*", "I", "==", "A", ";", "}", "</s>" ]

[ "Returns", "true", "if", "B1", "occurs", "before", "B2", "in", "the", "trace", ",", "or", "if", "it", "is", "the", "same", "block", "as", "B2", "." ]

[ "X86" ]

[]

[ "<s>", "static", "NewSense", "Def", "(", "unsigned", "PR", ",", "bool", "True", ",", "bool", "Float", ")", "{", "NewSense", "NS", "=", "{", "PR", ",", "Float", ",", "false", ",", "True", "}", ";", "return", "NS", ";", "}", "</s>" ]

[ "Pointer", "to", "the", "VPDef", "that", "defines", "this", "VPValue", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "ARMFrameInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "return", "true", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "(", "DisableFramePointerElim", "(", "MF", ")", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "aarch64_advsimd_struct_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "TARGET_SIMD", "&&", "(", "mode", "==", "OImode", "||", "mode", "==", "CImode", "||", "mode", "==", "XImode", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "any", "of", "the", "Advanced", "SIMD", "structure", "modes", "." ]

[ "aarch64" ]

[]

[ "<s>", "ISD", "::", "NodeType", "getExtendForAtomicCmpSwapArg", "(", ")", "const", "override", "{", "return", "ISD", "::", "SIGN_EXTEND", ";", "}", "</s>" ]

[ "Returns", "how", "the", "platform", "'s", "atomic", "compare", "and", "swap", "expects", "its", "comparison", "value", "to", "be", "extended", "(", "ZERO_EXTEND", ",", "SIGN_EXTEND", ",", "or", "ANY_EXTEND", ")", "." ]

[ "RI5CY", "ISD::NodeType", "ISD::SIGN_EXTEND" ]

[]

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

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

[ "XNCM", "XNCM", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MBlazeTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "MBlaze", "::", "GPRRegisterClass", ")", ";", "case", "'d'", ":", "case", "'y'", ":", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "MBlaze", "::", "GPRRegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "1", "0", "0U", "MBlaze::GPRRegisterClass", "MVT::f32", "0U", "MBlaze::GPRRegisterClass" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__memory_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__table_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_size\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_align\"", ")", "==", "0", ")", "{", "bool", "Mutable", "=", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", ";", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "&&", "strcmp", "(", "Name", ",", "\"__table_base\"", ")", "!=", "0", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "Mutable", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__cpp_exception\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_EVENT", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "wasm", "::", "WASM_EVENT_ATTRIBUTE_EXCEPTION", ",", "0", "}", ")", ";", "WasmSym", "->", "setWeak", "(", "true", ")", ";", "WasmSym", "->", "setExternal", "(", "true", ")", ";", "Params", ".", "push_back", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ")", ";", "}", "else", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "getLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "}", "auto", "Signature", "=", "std", "::", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "\"__memory_base\"", "0", "\"__table_base\"", "0", "\"__tls_size\"", "0", "\"__tls_align\"", "0", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "\"__table_base\"", "0", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "\"__cpp_exception\"", "0", "wasm::WASM_SYMBOL_TYPE_EVENT", "wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION", "0", "wasm::ValType", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WasmSignature" ]

[]

[ "<s>", "void", "split_di", "(", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "lo_half", "[", "num", "]", "=", "c6x_subword", "(", "op", ",", "false", ")", ";", "hi_half", "[", "num", "]", "=", "c6x_subword", "(", "op", ",", "true", ")", ";", "}", "}", "</s>" ]

[ "Split", "one", "or", "more", "DImode", "RTL", "references", "into", "pairs", "of", "SImode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "DImode", "RTL", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "." ]

[ "c6x" ]

[]

[ "<s>", "virtual", "void", "completeType", "(", "BTFDebug", "&", "BDebug", ")", "{", "}", "</s>" ]

[ "Complete", "BTF", "type", "generation", "after", "all", "related", "DebugInfo", "types", "have", "been", "visited", "so", "their", "BTF", "type", "id", "'s", "are", "available", "for", "cross", "referece", "." ]

[ "BPF" ]

[]

[ "<s>", "MCSymbol", "*", "TeeRISCMCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "TeeRISC", "TeeRISC", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'y'", ":", "{", "const", "char", "*", "RegName", "=", "\"r0\"", ";", "if", "(", "!", "Subtarget", "->", "isDarwin", "(", ")", ")", "RegName", "=", "PPCRegisterInfo", "::", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "case", "'U'", ":", "case", "'X'", ":", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"r0\"", "PPC", "\", \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "static", "const", "MachineOperand", "&", "getLdStOffsetOp", "(", "const", "MachineInstr", "&", "MI", ")", "{", "unsigned", "Idx", "=", "isPairedLdSt", "(", "MI", ")", "||", "AArch64InstrInfo", "::", "isPreLdSt", "(", "MI", ")", "?", "3", ":", "2", ";", "return", "MI", ".", "getOperand", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "immediate", "offset", "operator", "of", "a", "load/store", "." ]

[ "AArch64", "AArch64", "3", "2" ]

[]

[ "<s>", "int", "SystemZTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "BitSize", ">", "64", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isUInt", "<", "32", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xffffffff", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Basic", ";", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "}", "return", "4", "*", "TTI", "::", "TCC_Basic", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "SystemZ", "SystemZ", "0", "64", "0", "64", "32", "32", "0xffffffff", "0", "2", "4" ]

[]

[ "<s>", "static", "void", "replace_addli_pcrel", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "set_src", ";", "rtx", "unspec", ";", "rtx", "opnds", "[", "4", "]", ";", "bool", "first_insn_p", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", ";", "opnds", "[", "0", "]", "=", "SET_DEST", "(", "pattern", ")", ";", "set_src", "=", "SET_SRC", "(", "pattern", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set_src", ")", "==", "LO_SUM", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "set_src", ",", "1", ")", ")", "==", "CONST", ")", ";", "opnds", "[", "1", "]", "=", "XEXP", "(", "set_src", ",", "0", ")", ";", "unspec", "=", "XEXP", "(", "XEXP", "(", "set_src", ",", "1", ")", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "gcc_assert", "(", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_PCREL_SYM", ")", ";", "opnds", "[", "2", "]", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "opnds", "[", "3", "]", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "opnds", "[", "2", "]", ")", "!=", "SYMBOL_REF", ")", "return", ";", "first_insn_p", "=", "(", "opnds", "[", "1", "]", "==", "tilepro_text_label_rtx", "(", ")", ")", ";", "replace_pc_relative_symbol_ref", "(", "insn", ",", "opnds", ",", "first_insn_p", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "tilepro_fixup_pcrel_references", "." ]

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

[]

[ "<s>", "static", "rtx", "pdp11_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "BASE_RETURN_VALUE_REG", "(", "mode", ")", ")", ";", "}", "</s>" ]

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

[ "pdp11" ]

[]

[ "<s>", "bool", "ARMTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "DisableLdStOpti", "&&", "!", "Subtarget", ".", "isThumb", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "DisableIfConversion", "&&", "!", "Subtarget", ".", "isThumb", "(", ")", ")", "PM", ".", "add", "(", "createIfConverterPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getThisReturnPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "nullptr", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_ThisReturn_RegMask", ":", "CSR_AAPCS_ThisReturn_RegMask", ";", "}", "</s>" ]

[ "getThisReturnPreservedMask", "-", "Returns", "a", "call", "preserved", "mask", "specific", "to", "the", "case", "that", "'returned", "'", "is", "on", "an", "i32", "first", "argument", "if", "the", "calling", "convention", "is", "one", "that", "can", "(", "partially", ")", "model", "this", "attribute", "with", "a", "preserved", "mask", "(", "i.e", "." ]

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

[]

[ "<s>", "int", "eq_neq_comparison_operator", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "EQ", "||", "GET_CODE", "(", "op", ")", "==", "NE", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "an", "equality", "comparison", ",", "else", "return", "0", "." ]

[ "pa" ]

[]

[ "<s>", "bool", "TL45AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "0" ]

[]

[ "<s>", "void", "MOSAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "Inst", ";", "InstLowering", ".", "lower", "(", "MI", ",", "Inst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "Inst", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "std", "::", "string", "BlackfinIntrinsicInfo", "::", "getName", "(", "unsigned", "IntrID", ",", "const", "Type", "*", "*", "Tys", ",", "unsigned", "numTys", ")", "const", "{", "static", "const", "char", "*", "const", "names", "[", "]", "=", "{", "}", ";", "assert", "(", "!", "isOverloaded", "(", "IntrID", ")", "&&", "\"Blackfin intrinsics are not overloaded\"", ")", ";", "if", "(", "IntrID", "<", "Intrinsic", "::", "num_intrinsics", ")", "return", "0", ";", "assert", "(", "IntrID", "<", "bfinIntrinsic", "::", "num_bfin_intrinsics", "&&", "\"Invalid intrinsic ID\"", ")", ";", "std", "::", "string", "Result", "(", "names", "[", "IntrID", "-", "Intrinsic", "::", "num_intrinsics", "]", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "Blackfin", "\"Blackfin intrinsics are not overloaded\"", "Intrinsic::num_intrinsics", "0", "bfinIntrinsic::num_bfin_intrinsics", "\"Invalid intrinsic ID\"", "Intrinsic::num_intrinsics" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int64_t", "&", "Mask", ",", "int64_t", "&", "Value", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "C4_cmpneq", ":", "case", "Hexagon", "::", "C4_cmplte", ":", "case", "Hexagon", "::", "C4_cmplteu", ":", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C4_cmpneqi", ":", "case", "Hexagon", "::", "C4_cmplteui", ":", "case", "Hexagon", "::", "C4_cmpltei", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "~", "0", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbgti", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFF", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmphgti", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFFFF", ";", "break", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "C4_cmpneq", ":", "case", "Hexagon", "::", "C4_cmplte", ":", "case", "Hexagon", "::", "C4_cmplteu", ":", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "C4_cmpneqi", ":", "case", "Hexagon", "::", "C4_cmplteui", ":", "case", "Hexagon", "::", "C4_cmpltei", ":", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbgti", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmphgti", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "{", "SrcReg2", "=", "0", ";", "const", "MachineOperand", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "Op2", ".", "isImm", "(", ")", ")", "return", "false", ";", "Value", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpgt", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgtup", "Hexagon::C4_cmpneq", "Hexagon::C4_cmplte", "Hexagon::C4_cmplteu", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpgti", "Hexagon::C2_cmpgtui", "Hexagon::C4_cmpneqi", "Hexagon::C4_cmplteui", "Hexagon::C4_cmpltei", "1", "0", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgt", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbgti", "Hexagon::A4_cmpbgtui", "1", "0xFF", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgt", "Hexagon::A4_cmphgtu", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmphgti", "Hexagon::A4_cmphgtui", "1", "0xFFFF", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpgt", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgtup", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgt", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgt", "Hexagon::A4_cmphgtu", "Hexagon::C4_cmpneq", "Hexagon::C4_cmplte", "Hexagon::C4_cmplteu", "2", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpgtui", "Hexagon::C2_cmpgti", "Hexagon::C4_cmpneqi", "Hexagon::C4_cmplteui", "Hexagon::C4_cmpltei", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbgti", "Hexagon::A4_cmpbgtui", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmphgti", "Hexagon::A4_cmphgtui", "0", "2", "2" ]

[]

[ "<s>", "static", "void", "h8300_emit_stack_adjustment", "(", "int", "sign", ",", "HOST_WIDE_INT", "size", ",", "bool", "in_prologue", ")", "{", "if", "(", "size", "==", "0", ")", "return", ";", "if", "(", "Pmode", "==", "HImode", ")", "{", "rtx_insn", "*", "x", "=", "emit_insn", "(", "gen_addhi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "sign", "*", "size", ")", ")", ")", ";", "if", "(", "size", "<", "4", ")", "F", "(", "x", ",", "0", ")", ";", "}", "else", "F", "(", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "sign", "*", "size", ")", ")", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "language", "to", "FILE", "for", "the", "operation", "OP", "with", "operand", "size", "SIZE", "to", "adjust", "the", "stack", "pointer", "." ]

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

[]

[ "<s>", "bool", "SparcAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "isLandingPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "PI", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", ";", "return", "I", "==", "Pred", "->", "end", "(", ")", "||", "!", "I", "->", "getDesc", "(", ")", ".", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFMADLegal", "(", "const", "SelectionDAG", "&", "DAG", ",", "const", "SDNode", "*", "N", ")", "const", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "!", "hasFP32Denormals", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f16", ")", "{", "return", "Subtarget", "->", "hasMadF16", "(", ")", "&&", "!", "hasFP64FP16Denormals", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "MI", "can", "be", "combined", "with", "another", "instruction", "to", "form", "TargetOpcode", ":", ":G_FMAD", "." ]

[ "AMDGPU", "SI", "0", "MVT::f32", "MVT::f16" ]

[]

[ "<s>", "bool", "reg_overlap_p", "(", "rtx", "x", ",", "rtx", "in", ")", "{", "if", "(", "x", "==", "NULL_RTX", "||", "in", "==", "NULL_RTX", ")", "return", "false", ";", "return", "static_cast", "<", "bool", ">", "(", "reg_overlap_mentioned_p", "(", "x", ",", "in", ")", ")", ";", "}", "</s>" ]

[ "A", "safe", "wrapper", "to", "the", "function", "reg_overlap_mentioned_p", "(", ")", "." ]

[ "nds32" ]

[]

[ "<s>", "bool", "R600Packetizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "R600PacketizerList", "Packetizer", "(", "Fn", ",", "MLI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "::", "iterator", "End", "=", "MBB", "->", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "if", "(", "MI", "->", "isKill", "(", ")", "||", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", "||", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", "&&", "!", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "DeleteMI", "=", "MI", ";", "++", "MI", ";", "MBB", "->", "erase", "(", "DeleteMI", ")", ";", "End", "=", "MBB", "->", "end", "(", ")", ";", "continue", ";", "}", "++", "MI", ";", "}", "}", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "RemainingCount", "=", "MBB", "->", "size", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ";", "RegionEnd", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", "--", "I", ",", "--", "RemainingCount", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "&", "*", "std", "::", "prev", "(", "I", ")", ",", "&", "*", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "I", "=", "MBB", "->", "begin", "(", ")", ";", "if", "(", "I", "==", "RegionEnd", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "--", "RemainingCount", ";", "continue", ";", "}", "if", "(", "I", "==", "std", "::", "prev", "(", "RegionEnd", ")", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "&", "*", "MBB", ",", "&", "*", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "\"Empty DFA table!\"", "AMDGPU::IMPLICIT_DEF", "AMDGPU::CF_ALU", "8" ]

[]

[ "<s>", "bool", "SIFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CS", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "if", "(", "CS", ".", "isSpilledToReg", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "CS", ".", "getDstReg", "(", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "true", ")", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "bool", "IsLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlotCFI", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "!", "IsLiveIn", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "fr30_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "!", "arg", ".", "named", "||", "*", "cum", ">=", "FR30_NUM_ARG_REGS", ")", "return", "0", ";", "if", "(", "*", "cum", "+", "fr30_num_arg_regs", "(", "arg", ")", "<=", "FR30_NUM_ARG_REGS", ")", "return", "0", ";", "return", "(", "FR30_NUM_ARG_REGS", "-", "*", "cum", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "bytes", "in", "which", "*", "part", "*", "of", "a", "parameter", "of", "machine", "mode", "MODE", "and", "tree", "type", "TYPE", "(", "which", "may", "be", "NULL", "if", "the", "type", "is", "not", "known", ")", ".", "If", "the", "argument", "fits", "entirely", "in", "the", "argument", "registers", ",", "or", "entirely", "on", "the", "stack", ",", "then", "0", "is", "returned", ".", "CUM", "is", "the", "number", "of", "argument", "registers", "already", "used", "by", "earlier", "parameters", "to", "the", "function", "." ]

[ "fr30", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Final Branch Preparation\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Final Branch Preparation\"" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "bool", "GPRDest", "=", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "GPRSrc", "=", "ARM", "::", "GPRRegClass", ".", "contains", "(", "SrcReg", ")", ";", "if", "(", "GPRDest", "&&", "GPRSrc", ")", "{", "AddDefaultCC", "(", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "MOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ")", ")", ";", "return", ";", "}", "bool", "SPRDest", "=", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "SPRSrc", "=", "ARM", "::", "SPRRegClass", ".", "contains", "(", "SrcReg", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "SPRDest", "&&", "SPRSrc", ")", "Opc", "=", "ARM", "::", "VMOVS", ";", "else", "if", "(", "GPRDest", "&&", "SPRSrc", ")", "Opc", "=", "ARM", "::", "VMOVRS", ";", "else", "if", "(", "SPRDest", "&&", "GPRSrc", ")", "Opc", "=", "ARM", "::", "VMOVSR", ";", "else", "if", "(", "ARM", "::", "DPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "ARM", "::", "VMOVD", ";", "else", "if", "(", "ARM", "::", "QPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "ARM", "::", "VORRq", ";", "if", "(", "Opc", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ";", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "VORRq", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "QQPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", "||", "ARM", "::", "QQQQPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "assert", "(", "ARM", "::", "qsub_0", "+", "3", "==", "ARM", "::", "qsub_3", "&&", "\"Expected contiguous enum.\"", ")", ";", "unsigned", "EndSubReg", "=", "ARM", "::", "QQPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", "?", "ARM", "::", "qsub_1", ":", "ARM", "::", "qsub_3", ";", "for", "(", "unsigned", "i", "=", "ARM", "::", "qsub_0", ",", "e", "=", "EndSubReg", "+", "1", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Dst", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "i", ")", ";", "unsigned", "Src", "=", "TRI", "->", "getSubReg", "(", "SrcReg", ",", "i", ")", ";", "MachineInstrBuilder", "Mov", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "VORRq", ")", ")", ".", "addReg", "(", "Dst", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Src", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "Src", ",", "getKillRegState", "(", "KillSrc", ")", ")", ")", ";", "if", "(", "i", "==", "EndSubReg", ")", "{", "Mov", "->", "addRegisterDefined", "(", "DestReg", ",", "TRI", ")", ";", "if", "(", "KillSrc", ")", "Mov", "->", "addRegisterKilled", "(", "SrcReg", ",", "TRI", ")", ";", "}", "}", "return", ";", "}", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegClass", "ARM::GPRRegClass", "ARM::MOVr", "ARM::SPRRegClass", "ARM::SPRRegClass", "0", "ARM::VMOVS", "ARM::VMOVRS", "ARM::VMOVSR", "ARM::DPRRegClass", "ARM::VMOVD", "ARM::QPRRegClass", "ARM::VORRq", "ARM::VORRq", "ARM::QQPRRegClass", "ARM::QQQQPRRegClass", "ARM::qsub_0", "3", "ARM::qsub_3", "\"Expected contiguous enum.\"", "ARM::QQPRRegClass", "ARM::qsub_1", "ARM::qsub_3", "ARM::qsub_0", "1", "ARM::VORRq", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "0", "0", "1", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "1", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3", "1", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "int", "rs6000_emit_vector_cond_expr", "(", "rtx", "dest", ",", "rtx", "op_true", ",", "rtx", "op_false", ",", "rtx", "cond", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "mask_mode", "=", "GET_MODE", "(", "cc_op0", ")", ";", "enum", "rtx_code", "rcode", "=", "GET_CODE", "(", "cond", ")", ";", "machine_mode", "cc_mode", "=", "CCmode", ";", "rtx", "mask", ";", "rtx", "cond2", ";", "bool", "invert_move", "=", "false", ";", "if", "(", "VECTOR_UNIT_NONE_P", "(", "dest_mode", ")", ")", "return", "0", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "dest_mode", ")", "==", "GET_MODE_SIZE", "(", "mask_mode", ")", "&&", "GET_MODE_NUNITS", "(", "dest_mode", ")", "==", "GET_MODE_NUNITS", "(", "mask_mode", ")", ")", ";", "switch", "(", "rcode", ")", "{", "case", "NE", ":", "case", "UNLE", ":", "case", "UNLT", ":", "case", "UNGE", ":", "case", "UNGT", ":", "invert_move", "=", "true", ";", "rcode", "=", "reverse_condition_maybe_unordered", "(", "rcode", ")", ";", "if", "(", "rcode", "==", "UNKNOWN", ")", "return", "0", ";", "break", ";", "case", "GE", ":", "case", "LE", ":", "if", "(", "GET_MODE_CLASS", "(", "mask_mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "invert_move", "=", "true", ";", "rcode", "=", "reverse_condition", "(", "rcode", ")", ";", "}", "break", ";", "case", "GTU", ":", "case", "GEU", ":", "case", "LTU", ":", "case", "LEU", ":", "cc_mode", "=", "CCUNSmode", ";", "if", "(", "rcode", "==", "GEU", "||", "rcode", "==", "LEU", ")", "{", "invert_move", "=", "true", ";", "rcode", "=", "reverse_condition", "(", "rcode", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "mask", "=", "rs6000_emit_vector_compare", "(", "rcode", ",", "cc_op0", ",", "cc_op1", ",", "mask_mode", ")", ";", "if", "(", "!", "mask", ")", "return", "0", ";", "if", "(", "invert_move", ")", "std", "::", "swap", "(", "op_true", ",", "op_false", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "dest_mode", ")", "==", "MODE_VECTOR_INT", "&&", "(", "GET_CODE", "(", "op_true", ")", "==", "CONST_VECTOR", "||", "GET_CODE", "(", "op_false", ")", "==", "CONST_VECTOR", ")", ")", "{", "rtx", "constant_0", "=", "CONST0_RTX", "(", "dest_mode", ")", ";", "rtx", "constant_m1", "=", "CONSTM1_RTX", "(", "dest_mode", ")", ";", "if", "(", "op_true", "==", "constant_m1", "&&", "op_false", "==", "constant_0", ")", "{", "emit_move_insn", "(", "dest", ",", "mask", ")", ";", "return", "1", ";", "}", "else", "if", "(", "op_true", "==", "constant_0", "&&", "op_false", "==", "constant_m1", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_NOT", "(", "dest_mode", ",", "mask", ")", ")", ")", ";", "return", "1", ";", "}", "if", "(", "op_true", "==", "constant_m1", ")", "op_true", "=", "mask", ";", "if", "(", "op_false", "==", "constant_0", ")", "op_false", "=", "mask", ";", "}", "if", "(", "!", "REG_P", "(", "op_true", ")", "&&", "!", "SUBREG_P", "(", "op_true", ")", ")", "op_true", "=", "force_reg", "(", "dest_mode", ",", "op_true", ")", ";", "if", "(", "!", "REG_P", "(", "op_false", ")", "&&", "!", "SUBREG_P", "(", "op_false", ")", ")", "op_false", "=", "force_reg", "(", "dest_mode", ",", "op_false", ")", ";", "cond2", "=", "gen_rtx_fmt_ee", "(", "NE", ",", "cc_mode", ",", "gen_lowpart", "(", "dest_mode", ",", "mask", ")", ",", "CONST0_RTX", "(", "dest_mode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "dest_mode", ",", "cond2", ",", "op_true", ",", "op_false", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Emit", "vector", "conditional", "expression", ".", "DEST", "is", "destination", ".", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ".", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", "." ]

[ "powerpcspe", "0", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "bool", "AArch64ConditionalCompares", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Compares **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SchedModel", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "TargetSubtargetInfo", ">", "(", ")", ".", "getSchedModel", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "MinSize", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "bool", "Changed", "=", "false", ";", "CmpConv", ".", "runOnMachineFunction", "(", "MF", ")", ";", "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>", "int", "R600InstrInfo", "::", "getSrcIdx", "(", "unsigned", "Opcode", ",", "unsigned", "SrcNum", ")", "const", "{", "static", "const", "unsigned", "OpTable", "[", "]", "=", "{", "AMDGPU", "::", "OpName", "::", "src0", ",", "AMDGPU", "::", "OpName", "::", "src1", ",", "AMDGPU", "::", "OpName", "::", "src2", "}", ";", "assert", "(", "SrcNum", "<", "3", ")", ";", "return", "getOperandIdx", "(", "Opcode", ",", "OpTable", "[", "SrcNum", "]", ")", ";", "}", "</s>" ]

[ "Return", "the", "subregister", "index", "that", "SrcReg", "will", "be", "coalesced", "into", ",", "or", "0", "." ]

[ "AMDGPU", "R600", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "3" ]

[]

[ "<s>", "MCSymbol", "*", "X86TargetLowering", "::", "getPICBaseSymbol", "(", "const", "MachineFunction", "*", "MF", ",", "MCContext", "&", "Ctx", ")", "const", "{", "const", "MCAsmInfo", "&", "MAI", "=", "*", "getTargetMachine", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "return", "Ctx", ".", "GetOrCreateTemporarySymbol", "(", "Twine", "(", "MAI", ".", "getPrivateGlobalPrefix", "(", ")", ")", "+", "Twine", "(", "MF", "->", "getFunctionNumber", "(", ")", ")", "+", "\"$pb\"", ")", ";", "}", "</s>" ]

[ "getPICBaseSymbol", "-", "Return", "a", "function-local", "symbol", "to", "represent", "the", "PIC", "base", "." ]

[ "X86", "X86", "\"$pb\"" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "!", "VRegs", ".", "empty", "(", ")", ")", "||", "(", "!", "Val", "&&", "VRegs", ".", "empty", "(", ")", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "Val", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "const", "X86TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "X86TargetLowering", ">", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitEVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "SplitEVTs", ")", ";", "assert", "(", "VRegs", ".", "size", "(", ")", "==", "SplitEVTs", ".", "size", "(", ")", "&&", "\"For each split Type there should be exactly one VReg.\"", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ArgInfo", "CurArgInfo", "=", "ArgInfo", "{", "VRegs", "[", "i", "]", ",", "SplitEVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", "}", ";", "setArgFlags", "(", "CurArgInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "CurArgInfo", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "Register", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VRegs", "[", "i", "]", ")", ";", "}", ")", ")", "return", "false", ";", "}", "OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "X86", "X86", "4", "\"For each split Type there should be exactly one VReg.\"", "8", "0", "X86" ]

[]

[ "<s>", "void", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "Opcode", ")", ";", "uint64_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "switch", "(", "Size", ")", "{", "case", "0", ":", "break", ";", "case", "4", ":", "if", "(", "IsLittleEndian", ")", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint32_t", ">", "(", "Bits", ")", ";", "}", "else", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "big", ">", "(", "OS", ")", ".", "write", "<", "uint32_t", ">", "(", "Bits", ")", ";", "}", "break", ";", "case", "8", ":", "if", "(", "IsLittleEndian", ")", "{", "uint64_t", "Swapped", "=", "(", "Bits", "<<", "32", ")", "|", "(", "Bits", ">>", "32", ")", ";", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint64_t", ">", "(", "Swapped", ")", ";", "}", "else", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "big", ">", "(", "OS", ")", ".", "write", "<", "uint64_t", ">", "(", "Bits", ")", ";", "}", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid instruction size\"", ")", ";", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "PowerPC", "0", "4", "support::endian", "support::little", "support::endian", "support::big", "8", "32", "32", "support::endian", "support::little", "support::endian", "support::big", "\"Invalid instruction size\"" ]

[]

[ "<s>", "bool", "HexagonCallFrameInformation", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "auto", "&", "HFI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getFrameLowering", "(", ")", ";", "bool", "NeedCFI", "=", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "needsUnwindTableEntry", "(", ")", ";", "if", "(", "!", "NeedCFI", ")", "return", "false", ";", "HFI", ".", "insertCFIInstructions", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "&", "Flags", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Optional", "target", "hook", "that", "returns", "true", "if", "MBB", "is", "safe", "to", "outline", "from", ",", "and", "returns", "any", "target-specific", "information", "in", "Flags", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "static", "int", "mips_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "reg_class_t", "dregs", ";", "int", "cost1", ",", "cost2", ";", "from", "=", "mips_canonicalize_move_class", "(", "from", ")", ";", "to", "=", "mips_canonicalize_move_class", "(", "to", ")", ";", "if", "(", "from", "==", "FP_REGS", ")", "{", "if", "(", "to", "==", "FP_REGS", "&&", "mips_mode_ok_for_mov_fmt_p", "(", "mode", ")", ")", "return", "4", ";", "}", "dregs", "=", "TARGET_MIPS16", "?", "M16_REGS", ":", "GENERAL_REGS", ";", "if", "(", "from", "==", "dregs", ")", "return", "mips_move_from_gpr_cost", "(", "to", ")", ";", "if", "(", "to", "==", "dregs", ")", "return", "mips_move_to_gpr_cost", "(", "from", ")", ";", "cost1", "=", "mips_move_to_gpr_cost", "(", "from", ")", ";", "if", "(", "cost1", "!=", "0", ")", "{", "cost2", "=", "mips_move_from_gpr_cost", "(", "to", ")", ";", "if", "(", "cost2", "!=", "0", ")", "return", "cost1", "+", "cost2", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_REGISTER_MOVE_COST", ".", "Return", "0", "for", "classes", "that", "are", "the", "maximum", "of", "the", "move", "costs", "for", "subclasses", ";", "regclass", "will", "work", "out", "the", "maximum", "for", "us", "." ]

[ "mips", "4", "0", "0", "0" ]

[]

[ "<s>", "SDValue", "PTXTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "PTX", "PTX", "\"Unimplemented operand\"", "ISD::GlobalAddress" ]

[]

[ "<s>", "const", "AArch64InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "s390_expand_vec_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "bool", "all_same", "=", "true", ",", "all_regs", "=", "true", ",", "all_const_int", "=", "true", ";", "rtx", "x", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "x", ")", ")", "all_const_int", "=", "false", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "all_regs", "=", "false", ";", "}", "if", "(", "all_same", "&&", "all_const_int", "&&", "(", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", "==", "const0_rtx", "||", "s390_contiguous_bitmask_vector_p", "(", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "NULL", ",", "NULL", ")", "||", "s390_bytemask_vector_p", "(", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "NULL", ")", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ")", ";", "return", ";", "}", "if", "(", "all_same", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ")", ";", "return", ";", "}", "if", "(", "all_regs", "&&", "REG_P", "(", "target", ")", "&&", "n_elts", "==", "2", "&&", "inner_mode", "==", "DImode", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_VEC_CONCAT", "(", "mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ")", ")", ")", ";", "return", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "CONST0_RTX", "(", "mode", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ",", "GEN_INT", "(", "i", ")", ",", "target", ")", ",", "UNSPEC_VEC_SET", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "RTX", "necessary", "to", "initialize", "the", "vector", "TARGET", "with", "values", "in", "VALS", "." ]

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

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "CC", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "CSR_iOS_CXX_TLS_RegMask", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "vax_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "mem", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_const_mem", "(", "HImode", ",", "fnaddr", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "4", ")", ";", "emit_move_insn", "(", "mem", ",", "cxt", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "11", ")", ";", "emit_move_insn", "(", "mem", ",", "plus_constant", "(", "Pmode", ",", "fnaddr", ",", "2", ")", ")", ";", "emit_insn", "(", "gen_sync_istream", "(", ")", ")", ";", "}", "</s>" ]

[ "We", "copy", "the", "register-mask", "from", "the", "function", "'s", "pure", "code", "to", "the", "start", "of", "the", "trampoline", "." ]

[ "vax", "0", "0", "4", "11", "2" ]

[]

[ "<s>", "void", "mep_save_register_info", "(", "void", ")", "{", "save_register_info", "(", ")", ";", "}", "</s>" ]

[ "These", "three", "functions", "provide", "a", "bridge", "between", "the", "pramgas", "that", "affect", "register", "classes", ",", "and", "the", "functions", "that", "maintain", "them", ".", "We", "ca", "n't", "call", "those", "functions", "directly", "as", "pragma", "handling", "is", "part", "of", "the", "front", "end", "and", "does", "n't", "have", "direct", "access", "to", "them", "." ]

[ "mep" ]

[]

[ "<s>", "void", "ARCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createARCExpandPseudosPass", "(", ")", ")", ";", "addPass", "(", "createARCOptAddrMode", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "ARC", "ARC", "ARC", "ARC" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "useDFAforSMS", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Default", "to", "DFA", "for", "resource", "management", ",", "return", "false", "when", "target", "will", "use", "ProcResource", "in", "InstrSchedModel", "instead", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "rtx", "extract_sfunc_addr", "(", "rtx", "insn", ")", "{", "rtx", "pattern", ",", "part", "=", "NULL_RTX", ";", "int", "len", ",", "i", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "len", "=", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "part", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "part", ")", "==", "USE", "&&", "GET_MODE", "(", "XEXP", "(", "part", ",", "0", ")", ")", "==", "Pmode", "&&", "GENERAL_REGISTER_P", "(", "true_regnum", "(", "XEXP", "(", "part", ",", "0", ")", ")", ")", ")", "return", "XEXP", "(", "part", ",", "0", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", "==", "UNSPEC_VOLATILE", ")", ";", "return", "XVECEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ",", "0", ",", "1", ")", ";", "}", "</s>" ]

[ "INSN", "is", "an", "sfunc", ";", "return", "the", "rtx", "that", "describes", "the", "address", "used", "." ]

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

[]

[ "<s>", "void", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "emitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "void", "nds32_init_builtins", "(", "void", ")", "{", "nds32_init_builtins_impl", "(", ")", ";", "}", "</s>" ]

[ "Miscellaneous", "Parameters", "." ]

[ "nds32" ]

[]

[ "<s>", "void", "x86_function_profiler", "(", "FILE", "*", "file", ",", "int", "labelno", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "cfun", "->", "machine", "->", "insn_queued_at_entrance", ")", "{", "if", "(", "cfun", "->", "machine", "->", "insn_queued_at_entrance", "==", "TYPE_ENDBR", ")", "fprintf", "(", "file", ",", "\"\\t%s\\n\"", ",", "TARGET_64BIT", "?", "\"endbr64\"", ":", "\"endbr32\"", ")", ";", "unsigned", "int", "patch_area_size", "=", "crtl", "->", "patch_area_size", "-", "crtl", "->", "patch_area_entry", ";", "if", "(", "patch_area_size", ")", "ix86_output_patchable_area", "(", "patch_area_size", ",", "crtl", "->", "patch_area_entry", "==", "0", ")", ";", "}", "const", "char", "*", "mcount_name", "=", "MCOUNT_NAME", ";", "if", "(", "current_fentry_name", "(", "&", "mcount_name", ")", ")", ";", "else", "if", "(", "fentry_name", ")", "mcount_name", "=", "fentry_name", ";", "else", "if", "(", "flag_fentry", ")", "mcount_name", "=", "MCOUNT_NAME_BEFORE_PROLOGUE", ";", "if", "(", "TARGET_64BIT", ")", "{", "fprintf", "(", "file", ",", "\"\\tleaq\\t%sP%d(%%rip),%%r11\\n\"", ",", "LPREFIX", ",", "labelno", ")", ";", "if", "(", "!", "TARGET_PECOFF", ")", "{", "switch", "(", "ix86_cmodel", ")", "{", "case", "CM_LARGE", ":", "fprintf", "(", "file", ",", "\"1:\\tmovabsq\\t$%s, %%r10\\n\\tcall\\t*%%r10\\n\"", ",", "mcount_name", ")", ";", "break", ";", "case", "CM_LARGE_PIC", ":", "fprintf", "(", "file", ",", "\"1:\\tmovabsq\\t$_GLOBAL_OFFSET_TABLE_-1b, %%r11\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tleaq\\t1b(%%rip), %%r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\taddq\\t%%r11, %%r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tmovabsq\\t$%s@PLTOFF, %%r11\\n\"", ",", "mcount_name", ")", ";", "fprintf", "(", "file", ",", "\"\\taddq\\t%%r11, %%r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tcall\\t*%%r10\\n\"", ")", ";", "sorry", "(", "\"profiling %<-mcmodel=large%> with PIC is not supported\"", ")", ";", "break", ";", "case", "CM_SMALL_PIC", ":", "case", "CM_MEDIUM_PIC", ":", "fprintf", "(", "file", ",", "\"1:\\tcall\\t*%s@GOTPCREL(%%rip)\\n\"", ",", "mcount_name", ")", ";", "break", ";", "default", ":", "x86_print_call_or_nop", "(", "file", ",", "mcount_name", ")", ";", "break", ";", "}", "}", "else", "x86_print_call_or_nop", "(", "file", ",", "mcount_name", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "fprintf", "(", "file", ",", "\"\\tleal\\t%sP%d@GOTOFF(%%ebx),%%\"", "PROFILE_COUNT_REGISTER", "\"\\n\"", ",", "LPREFIX", ",", "labelno", ")", ";", "fprintf", "(", "file", ",", "\"1:\\tcall\\t*%s@GOT(%%ebx)\\n\"", ",", "mcount_name", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\tmovl\\t$%sP%d,%%\"", "PROFILE_COUNT_REGISTER", "\"\\n\"", ",", "LPREFIX", ",", "labelno", ")", ";", "x86_print_call_or_nop", "(", "file", ",", "mcount_name", ")", ";", "}", "if", "(", "flag_record_mcount", "||", "lookup_attribute", "(", "\"fentry_section\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", ")", "{", "const", "char", "*", "sname", "=", "\"__mcount_loc\"", ";", "if", "(", "current_fentry_section", "(", "&", "sname", ")", ")", ";", "else", "if", "(", "fentry_section", ")", "sname", "=", "fentry_section", ";", "fprintf", "(", "file", ",", "\"\\t.section %s, \\\"a\\\",@progbits\\n\"", ",", "sname", ")", ";", "fprintf", "(", "file", ",", "\"\\t.%s 1b\\n\"", ",", "TARGET_64BIT", "?", "\"quad\"", ":", "\"long\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.previous\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "FILE", "to", "increment", "profiler", "label", "#", "LABELNO", "for", "profiling", "a", "function", "entry", "." ]

[ "i386", "\"\\t%s\\n\"", "\"endbr64\"", "\"endbr32\"", "0", "\"\\tleaq\\t%sP%d(%%rip),%%r11\\n\"", "\"1:\\tmovabsq\\t$%s, %%r10\\n\\tcall\\t*%%r10\\n\"", "\"1:\\tmovabsq\\t$_GLOBAL_OFFSET_TABLE_-1b, %%r11\\n\"", "\"\\tleaq\\t1b(%%rip), %%r10\\n\"", "\"\\taddq\\t%%r11, %%r10\\n\"", "\"\\tmovabsq\\t$%s@PLTOFF, %%r11\\n\"", "\"\\taddq\\t%%r11, %%r10\\n\"", "\"\\tcall\\t*%%r10\\n\"", "\"profiling %<-mcmodel=large%> with PIC is not supported\"", "\"1:\\tcall\\t*%s@GOTPCREL(%%rip)\\n\"", "\"\\tleal\\t%sP%d@GOTOFF(%%ebx),%%\"", "\"\\n\"", "\"1:\\tcall\\t*%s@GOT(%%ebx)\\n\"", "\"\\tmovl\\t$%sP%d,%%\"", "\"\\n\"", "\"fentry_section\"", "\"__mcount_loc\"", "\"\\t.section %s, \\\"a\\\",@progbits\\n\"", "\"\\t.%s 1b\\n\"", "\"quad\"", "\"long\"", "\"\\t.previous\\n\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no-realign-stack\"", ")", ")", "return", "false", ";", "if", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"no-realign-stack\"" ]

[]

[ "<s>", "static", "int", "cris_reg_overlap_mentioned_p", "(", "rtx", "x", ",", "rtx", "in", ")", "{", "if", "(", "GET_CODE", "(", "in", ")", "==", "STRICT_LOW_PART", ")", "in", "=", "XEXP", "(", "in", ",", "0", ")", ";", "return", "reg_overlap_mentioned_p", "(", "x", ",", "in", ")", ";", "}", "</s>" ]

[ "The", "function", "reg_overlap_mentioned_p", "in", "CVS", "(", "still", "as", "of", "2001-05-16", ")", "does", "not", "handle", "the", "case", "where", "the", "IN", "operand", "is", "strict_low_part", ";", "it", "does", "handle", "it", "for", "X.", "Test-case", "in", "Axis-20010516", ".", "This", "function", "takes", "care", "of", "that", "for", "THIS", "port", ".", "FIXME", ":", "strict_low_part", "is", "going", "away", "anyway", "." ]

[ "cris", "0" ]

[]

[ "<s>", "void", "CAHPAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ",", "CInst", ";", "LowerCAHPMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "bool", "Res", "=", "compressInst", "(", "CInst", ",", "TmpInst", ",", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ",", "OutStreamer", "->", "getContext", "(", ")", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "Res", "?", "CInst", ":", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP" ]

[]

[ "<s>", "Reloc", "::", "Model", "MipsSubtarget", "::", "getRelocationModel", "(", ")", "const", "{", "return", "TM", ".", "getRelocationModel", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "code", "generation", "relocation", "model", "." ]

[ "Mips", "Mips" ]

[]

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

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

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

[]

[ "<s>", "static", "int", "sparc_vis_mul8x16", "(", "int", "e8", ",", "int", "e16", ")", "{", "return", "(", "e8", "*", "e16", "+", "128", ")", "/", "256", ";", "}", "</s>" ]

[ "Return", "the", "upper", "16", "bits", "of", "the", "8x16", "multiplication", "." ]

[ "sparc", "128", "256" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "enableSubRegLiveness", "(", ")", "const", "{", "if", "(", "EnableSubRegLiveness", ".", "getNumOccurrences", "(", ")", ")", "return", "EnableSubRegLiveness", ";", "return", "hasMVEIntegerOps", "(", ")", ";", "}", "</s>" ]

[ "Enable", "tracking", "of", "subregister", "liveness", "in", "register", "allocator", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "const", "SIMachineFunctionInfo", "&", "MFI", "=", "*", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MFI", ".", "isEntryFunction", "(", ")", ")", "return", ";", "if", "(", "!", "IsaInfo", "::", "hasCodeObjectV3", "(", "getGlobalSTI", "(", ")", ")", "||", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDHSA", ")", "return", ";", "auto", "&", "Streamer", "=", "getTargetStreamer", "(", ")", "->", "getStreamer", "(", ")", ";", "auto", "&", "Context", "=", "Streamer", ".", "getContext", "(", ")", ";", "auto", "&", "ObjectFileInfo", "=", "*", "Context", ".", "getObjectFileInfo", "(", ")", ";", "auto", "&", "ReadOnlySection", "=", "*", "ObjectFileInfo", ".", "getReadOnlySection", "(", ")", ";", "Streamer", ".", "PushSection", "(", ")", ";", "Streamer", ".", "SwitchSection", "(", "&", "ReadOnlySection", ")", ";", "Streamer", ".", "emitValueToAlignment", "(", "64", ",", "0", ",", "1", ",", "0", ")", ";", "if", "(", "ReadOnlySection", ".", "getAlignment", "(", ")", "<", "64", ")", "ReadOnlySection", ".", "setAlignment", "(", "Align", "(", "64", ")", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "MF", "->", "getSubtarget", "(", ")", ";", "SmallString", "<", "128", ">", "KernelName", ";", "getNameWithPrefix", "(", "KernelName", ",", "&", "MF", "->", "getFunction", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitAmdhsaKernelDescriptor", "(", "STI", ",", "KernelName", ",", "getAmdhsaKernelDescriptor", "(", "*", "MF", ",", "CurrentProgramInfo", ")", ",", "CurrentProgramInfo", ".", "NumVGPRsForWavesPerEU", ",", "CurrentProgramInfo", ".", "NumSGPRsForWavesPerEU", "-", "IsaInfo", "::", "getNumExtraSGPRs", "(", "&", "STI", ",", "CurrentProgramInfo", ".", "VCCUsed", ",", "CurrentProgramInfo", ".", "FlatUsed", ")", ",", "CurrentProgramInfo", ".", "VCCUsed", ",", "CurrentProgramInfo", ".", "FlatUsed", ",", "hasXNACK", "(", "STI", ")", ")", ";", "Streamer", ".", "PopSection", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "64", "0", "1", "0", "64", "64", "128" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Collect LOH **********\\n\"", "<<", "\"Looking in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LOHInfo", "LOHInfos", "[", "N_GPR_REGS", "]", ";", "AArch64FunctionInfo", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "memset", "(", "LOHInfos", ",", "0", ",", "sizeof", "(", "LOHInfos", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "LI", ":", "Succ", "->", "liveins", "(", ")", ")", "{", "int", "RegIdx", "=", "mapRegToGPRIndex", "(", "LI", ".", "PhysReg", ")", ";", "if", "(", "RegIdx", ">=", "0", ")", "LOHInfos", "[", "RegIdx", "]", ".", "OneUser", "=", "true", ";", "}", "}", "for", "(", "const", "MachineInstr", "&", "MI", ":", "make_range", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ")", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "LDRXui", ":", "if", "(", "canDefBePartOfLOH", "(", "MI", ")", ")", "{", "const", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "Def", ".", "isReg", "(", ")", "&&", "Def", ".", "isDef", "(", ")", "&&", "\"Expected reg def\"", ")", ";", "assert", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "\"Expected reg use\"", ")", ";", "int", "DefIdx", "=", "mapRegToGPRIndex", "(", "Def", ".", "getReg", "(", ")", ")", ";", "int", "OpIdx", "=", "mapRegToGPRIndex", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefIdx", ">=", "0", "&&", "OpIdx", ">=", "0", "&&", "handleMiddleInst", "(", "MI", ",", "LOHInfos", "[", "DefIdx", "]", ",", "LOHInfos", "[", "OpIdx", "]", ")", ")", "continue", ";", "}", "break", ";", "case", "AArch64", "::", "ADRP", ":", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "int", "Idx", "=", "mapRegToGPRIndex", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "if", "(", "Idx", ">=", "0", ")", "{", "handleADRP", "(", "MI", ",", "AFI", ",", "LOHInfos", "[", "Idx", "]", ")", ";", "continue", ";", "}", "break", ";", "}", "handleNormalInst", "(", "MI", ",", "LOHInfos", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Collect LOH **********\\n\"", "\"Looking in function \"", "AArch64", "AArch64", "0", "0", "AArch64::ADDXri", "AArch64::LDRXui", "0", "1", "\"Expected reg def\"", "\"Expected reg use\"", "0", "0", "AArch64::ADRP", "0", "0" ]

[]

[ "<s>", "int", "mcore_dllexport_name_p", "(", "const", "char", "*", "symbol", ")", "{", "return", "symbol", "[", "0", "]", "==", "'@'", "&&", "symbol", "[", "1", "]", "==", "'e'", "&&", "symbol", "[", "2", "]", "==", "'.'", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "SYMBOL", "is", "marked", "as", "being", "dllexport", "'d", "." ]

[ "mcore", "0", "1", "2" ]

[]

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

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

[ "XCore", "XCore" ]

[]

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

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

[ "Hexagon", "MVT::i1" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "uint64_t", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "InsertPt", "->", "getDebugLoc", "(", ")", ";", "}", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "\"__stack_pointer\"", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ";", "auto", "*", "MMO", "=", "new", "MachineMemOperand", "(", "MachinePointerInfo", "(", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "4", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "STORE_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::CONST_I32", "\"__stack_pointer\"", "WebAssembly::ADD_I32", "WebAssembly::SP32", "WebAssembly::SP32", "WebAssembly::CONST_I32", "4", "4", "WebAssembly::STORE_I32", "WebAssembly::SP32", "0", "WebAssembly::SP32" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createX86OptimizeLEAs", "(", ")", ")", ";", "addPass", "(", "createX86CallFrameOptimization", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "BitVector", "HexagonRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "HEXAGON_RESERVED_REG_1", ")", ";", "Reserved", ".", "set", "(", "HEXAGON_RESERVED_REG_2", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R31", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "D15", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA1", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R29", "Hexagon::R30", "Hexagon::R31", "Hexagon::PC", "Hexagon::D15", "Hexagon::LC0", "Hexagon::LC1", "Hexagon::SA0", "Hexagon::SA1" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "ECLair" ]

[]

[ "<s>", "SDNode", "*", "MBlazeDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "MBlaze", "::", "ADDI", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "return", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "dl", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "}", "case", "MBlazeISD", "::", "JmpLink", ":", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Callee", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "R20Reg", "=", "CurDAG", "->", "getRegister", "(", "MBlaze", "::", "R20", ",", "MVT", "::", "i32", ")", ";", "SDValue", "InFlag", "(", "0", ",", "0", ")", ";", "if", "(", "(", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "||", "(", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", ")", "{", "SDValue", "GPReg", "=", "CurDAG", "->", "getRegister", "(", "MBlaze", "::", "R15", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Callee", ",", "GPReg", ",", "Chain", "}", ";", "SDValue", "Load", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "MBlaze", "::", "LW", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ",", "3", ")", ",", "0", ")", ";", "Chain", "=", "Load", ".", "getValue", "(", "1", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R20Reg", ",", "Load", ",", "InFlag", ")", ";", "}", "else", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R20Reg", ",", "Callee", ",", "InFlag", ")", ";", "SDNode", "*", "ResNode", "=", "CurDAG", "->", "getMachineNode", "(", "MBlaze", "::", "BRLID", ",", "dl", ",", "MVT", "::", "Other", ",", "MVT", "::", "Flag", ",", "R20Reg", ",", "Chain", ")", ";", "Chain", "=", "SDValue", "(", "ResNode", ",", "0", ")", ";", "InFlag", "=", "SDValue", "(", "ResNode", ",", "1", ")", ";", "ReplaceUses", "(", "SDValue", "(", "Node", ",", "0", ")", ",", "Chain", ")", ";", "ReplaceUses", "(", "SDValue", "(", "Node", ",", "1", ")", ",", "InFlag", ")", ";", "return", "ResNode", ";", "}", "}", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::GLOBAL_OFFSET_TABLE", "ISD::FrameIndex", "0", "MVT::i32", "0", "MBlaze::ADDI", "MBlazeISD::JmpLink", "0", "1", "MBlaze::R20", "MVT::i32", "0", "0", "MBlaze::R15", "MVT::i32", "MBlaze::LW", "MVT::i32", "MVT::Other", "3", "0", "1", "MBlaze::BRLID", "MVT::Other", "MVT::Flag", "0", "1", "0", "1", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "nds32_n13_e2_to_e1_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "def_reg", ";", "switch", "(", "get_attr_type", "(", "producer", ")", ")", "{", "case", "TYPE_LOAD", ":", "case", "TYPE_STORE", ":", "case", "TYPE_LOAD_MULTIPLE", ":", "case", "TYPE_STORE_MULTIPLE", ":", "if", "(", "!", "post_update_insn_p", "(", "producer", ")", ")", "return", "false", ";", "def_reg", "=", "extract_base_reg", "(", "producer", ")", ";", "break", ";", "case", "TYPE_ALU", ":", "case", "TYPE_ALU_SHIFT", ":", "case", "TYPE_PBSAD", ":", "case", "TYPE_PBSADA", ":", "case", "TYPE_MUL", ":", "case", "TYPE_MAC", ":", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "case", "TYPE_BRANCH", ":", "return", "true", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "producer", ")", ")", "{", "rtx", "def_reg1", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "0", ")", ")", ";", "rtx", "def_reg2", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "1", ")", ")", ";", "return", "(", "n13_consumed_by_e1_dep_p", "(", "consumer", ",", "def_reg1", ")", "||", "n13_consumed_by_e1_dep_p", "(", "consumer", ",", "def_reg2", ")", ")", ";", "}", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "n13_consumed_by_e1_dep_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "E2", "to", "E1", "." ]

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

[]

[ "<s>", "SDValue", "LEGTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "!", "isVarArg", "&&", "\"VarArg not supported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_LEG", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "assert", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "i32", "&&", "\"Only support MVT::i32 register passing\"", ")", ";", "const", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "LEG", "::", "GRRegsRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgIn", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgIn", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "\"Can only pass arguments as either registers or via the stack\"", ")", ";", "const", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "const", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "SDValue", "FIPtr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", ")", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i32", "&&", "\"Only support passing arguments as i32\"", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "0", ")", ";", "InVals", ".", "push_back", "(", "Load", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "ISD::InputArg", "\"VarArg not supported\"", "16", "LEG", "MVT::i32", "\"Only support MVT::i32 register passing\"", "LEG::GRRegsRegClass", "\"Can only pass arguments as either registers or via the stack\"", "4", "MVT::i32", "\"Only support passing arguments as i32\"", "0" ]

[]

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

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "isUnconditionalBranch", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "Bcc", "&&", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "==", "A64CC", "::", "AL", ")", "return", "true", ";", "return", "MCInstrAnalysis", "::", "isUnconditionalBranch", "(", "Inst", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "branch", "which", "always", "transfers", "control", "flow", "to", "some", "other", "block", "." ]

[ "AArch64", "AArch64::Bcc", "0", "A64CC::AL" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "setForcedEncodingSize", "(", "0", ")", ";", "if", "(", "Name", ".", "endswith", "(", "\"_e64\"", ")", ")", "setForcedEncodingSize", "(", "64", ")", ";", "else", "if", "(", "Name", ".", "endswith", "(", "\"_e32\"", ")", ")", "setForcedEncodingSize", "(", "32", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "Name", ".", "endswith", "(", "\"_e64\"", ")", ")", "{", "Name", "=", "Name", ".", "substr", "(", "0", ",", "Name", ".", "size", "(", ")", "-", "4", ")", ";", "}", "if", "(", "Name", ".", "endswith", "(", "\"_e32\"", ")", ")", "{", "Name", "=", "Name", ".", "substr", "(", "0", ",", "Name", ".", "size", "(", ")", "-", "4", ")", ";", "}", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "break", ";", "case", "MatchOperand_ParseFail", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"failed parsing operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "case", "MatchOperand_NoMatch", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"not a valid operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "0", "\"_e64\"", "64", "\"_e32\"", "32", "AMDGPU", "\"_e64\"", "0", "4", "\"_e32\"", "0", "4", "AMDGPU", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "void", "nvptx_output_skip", "(", "FILE", "*", ",", "unsigned", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "decl_offset", "+", "size", ">=", "object_size", ")", "{", "if", "(", "decl_offset", "%", "decl_chunk_size", "!=", "0", ")", "nvptx_assemble_value", "(", "0", ",", "decl_chunk_size", ")", ";", "object_finished", "=", "true", ";", "return", ";", "}", "while", "(", "size", ">", "decl_chunk_size", ")", "{", "nvptx_assemble_value", "(", "0", ",", "decl_chunk_size", ")", ";", "size", "-=", "decl_chunk_size", ";", "}", "while", "(", "size", "--", ">", "0", ")", "nvptx_assemble_value", "(", "0", ",", "1", ")", ";", "}", "</s>" ]

[ "Output", "SIZE", "zero", "bytes", ".", "We", "ignore", "the", "FILE", "argument", "since", "the", "functions", "we", "'re", "calling", "to", "perform", "the", "output", "just", "use", "asm_out_file", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_advance_flush", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "HOST_WIDE_INT", "bitpos", ")", "{", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "intregs", ",", "intoffset", ";", "enum", "machine_mode", "mode", ";", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "return", ";", "intoffset", "=", "cum", "->", "intoffset", ";", "cum", "->", "intoffset", "=", "-", "1", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "{", "mode", "=", "mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ",", "MODE_INT", ",", "0", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "intoffset", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "}", "}", "startbit", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "bitpos", "+", "BITS_PER_WORD", "-", "1", ")", "&", "-", "BITS_PER_WORD", ";", "intregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "cum", "->", "words", "+=", "intregs", ";", "}", "</s>" ]

[ "Use", "this", "to", "flush", "pending", "int", "fields", "." ]

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

[]

[ "<s>", "bool", "SIInsertNops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DenseMap", "<", "unsigned", ",", "MachineBasicBlock", "::", "iterator", ">", "LineToInst", ";", "for", "(", "auto", "MBB", "=", "MF", ".", "begin", "(", ")", ";", "MBB", "!=", "MF", ".", "end", "(", ")", ";", "++", "MBB", ")", "{", "for", "(", "auto", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "MI", "!=", "MBB", "->", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", "||", "!", "MI", "->", "getDebugLoc", "(", ")", ")", "{", "continue", ";", "}", "auto", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "auto", "CL", "=", "DL", ".", "getLine", "(", ")", ";", "auto", "LineToInstEntry", "=", "LineToInst", ".", "find", "(", "CL", ")", ";", "if", "(", "LineToInstEntry", "==", "LineToInst", ".", "end", "(", ")", ")", "{", "BuildMI", "(", "*", "MBB", ",", "*", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_NOP", ")", ")", ".", "addImm", "(", "0", ")", ";", "LineToInst", ".", "insert", "(", "std", "::", "make_pair", "(", "CL", ",", "MI", ")", ")", ";", "}", "else", "{", "LineToInstEntry", "->", "second", "=", "MI", ";", "}", "}", "}", "for", "(", "auto", "LineToInstEntry", "=", "LineToInst", ".", "begin", "(", ")", ";", "LineToInstEntry", "!=", "LineToInst", ".", "end", "(", ")", ";", "++", "LineToInstEntry", ")", "{", "auto", "MBB", "=", "LineToInstEntry", "->", "second", "->", "getParent", "(", ")", ";", "auto", "DL", "=", "LineToInstEntry", "->", "second", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "LineToInstEntry", "->", "second", ";", "++", "MI", ";", "if", "(", "MI", "!=", "MBB", "->", "end", "(", ")", ")", "{", "BuildMI", "(", "*", "MBB", ",", "*", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_NOP", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "}", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineInstr", "&", "MI", "=", "MBB", ".", "front", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_NOP", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::S_NOP", "0", "AMDGPU::S_NOP", "0", "AMDGPU::S_NOP", "0" ]

[]

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

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

[ "VE" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", ")", "RC", "=", "ARM", "::", "GPRRegisterClass", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", "||", "RC", "==", "ARM", "::", "DPR_VFP2RegisterClass", "||", "RC", "==", "ARM", "::", "DPR_8RegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VSTRD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VSTRS", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "{", "assert", "(", "(", "RC", "==", "ARM", "::", "QPRRegisterClass", "||", "RC", "==", "ARM", "::", "QPR_VFP2RegisterClass", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "Align", ">=", "16", "&&", "(", "getRegisterInfo", "(", ")", ".", "canRealignStack", "(", "MF", ")", ")", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VST1q64", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "128", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ")", ";", "}", "else", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VSTRQ", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "ARM::tGPRRegisterClass", "ARM::GPRRegisterClass", "ARM::GPRRegisterClass", "ARM::STR", "0", "0", "ARM::DPRRegisterClass", "ARM::DPR_VFP2RegisterClass", "ARM::DPR_8RegisterClass", "ARM::VSTRD", "0", "ARM::SPRRegisterClass", "ARM::VSTRS", "0", "ARM::QPRRegisterClass", "ARM::QPR_VFP2RegisterClass", "\"Unknown regclass!\"", "16", "ARM::VST1q64", "0", "0", "128", "ARM::VSTRQ", "0" ]

[]

[ "<s>", "static", "void", "*", "rs6000_alloc_sched_context", "(", "void", ")", "{", "return", "xmalloc", "(", "sizeof", "(", "rs6000_sched_context_def", ")", ")", ";", "}", "</s>" ]

[ "Allocate", "store", "for", "new", "scheduling", "context", "." ]

[ "rs6000" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "ReadCycleWide", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"ReadCycleWrite is only to be used on riscv32\"", ")", ";", "return", "emitReadCycleWidePseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR16_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR64_Using_CC_GPR", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "BuildPairF64Pseudo", ":", "return", "emitBuildPairF64Pseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "SplitF64Pseudo", ":", "return", "emitSplitF64Pseudo", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Unexpected instr type to insert\"", "RISCV::ReadCycleWide", "\"ReadCycleWrite is only to be used on riscv32\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR16_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "1", ",", "true", ",", "true", ",", "false", ",", "true", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoopDataPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorMarkStridedAccessesPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInterleavedLoadCombinePass", "(", ")", ")", ";", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "addPass", "(", "createAArch64StackTaggingPass", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "static", "void", "mcore_print_operand", "(", "FILE", "*", "stream", ",", "rtx", "x", ",", "int", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "'N'", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "-", "1", ")", "fprintf", "(", "asm_out_file", ",", "\"32\"", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"%d\"", ",", "exact_log2", "(", "INTVAL", "(", "x", ")", "+", "1", ")", ")", ";", "break", ";", "case", "'P'", ":", "fprintf", "(", "asm_out_file", ",", "\"%d\"", ",", "exact_log2", "(", "INTVAL", "(", "x", ")", "&", "0xffffffff", ")", ")", ";", "break", ";", "case", "'Q'", ":", "fprintf", "(", "asm_out_file", ",", "\"%d\"", ",", "exact_log2", "(", "~", "INTVAL", "(", "x", ")", ")", ")", ";", "break", ";", "case", "'O'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "'M'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "-", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "'R'", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "+", "1", "]", ",", "(", "stream", ")", ")", ";", "break", ";", "case", "MEM", ":", "mcore_print_operand_address", "(", "stream", ",", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "adjust_address", "(", "x", ",", "SImode", ",", "4", ")", ",", "0", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "'U'", ":", "fprintf", "(", "asm_out_file", ",", "\"%s-%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "reg_names", "[", "REGNO", "(", "x", ")", "+", "3", "]", ")", ";", "break", ";", "case", "'x'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "'X'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "3", "-", "INTVAL", "(", "x", ")", "/", "8", ")", ";", "break", ";", "default", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "(", "stream", ")", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "break", ";", "}", "}", "</s>" ]

[ "Print", "operand", "x", "(", "an", "rtx", ")", "in", "assembler", "syntax", "to", "file", "stream", "according", "to", "modifier", "code", ".", "'", "R", "'", "print", "the", "next", "register", "or", "memory", "location", "along", ",", "ie", "the", "lsw", "in", "a", "double", "word", "value", "'", "O", "'", "print", "a", "constant", "without", "the", "#", "'M", "'", "print", "a", "constant", "as", "its", "negative", "'", "P", "'", "print", "log2", "of", "a", "power", "of", "two", "'", "Q", "'", "print", "log2", "of", "an", "inverse", "of", "a", "power", "of", "two", "'", "U", "'", "print", "register", "for", "ldm/stm", "instruction", "'", "X", "'", "print", "byte", "number", "for", "xtrbN", "instruction", "." ]

[ "mcore", "1", "\"32\"", "\"%d\"", "1", "\"%d\"", "0xffffffff", "\"%d\"", "1", "4", "0", "\"%s-%s\"", "3", "3", "8", "0" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "CommentStream", ")", "HasCustomInstComment", "=", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "if", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "OS", "<<", "\"\\tlock\\t\"", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CALLpcrel32", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode64Bit", "]", ")", ")", "{", "OS", "<<", "\"\\tcallq\\t\"", ";", "printPCRelImm", "(", "MI", ",", "0", ",", "OS", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", ")", "{", "MCInst", "Data32MI", "(", "*", "MI", ")", ";", "Data32MI", ".", "setOpcode", "(", "X86", "::", "DATA32_PREFIX", ")", ";", "printInstruction", "(", "&", "Data32MI", ",", "OS", ")", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86II::LOCK", "\"\\tlock\\t\"", "X86::CALLpcrel32", "X86::Mode64Bit", "\"\\tcallq\\t\"", "0", "X86::DATA16_PREFIX", "X86::Mode16Bit", "X86::DATA32_PREFIX" ]

[]

[ "<s>", "static", "bool", "riscv_valid_lo_sum_p", "(", "enum", "riscv_symbol_type", "sym_type", ",", "machine_mode", "mode", ")", "{", "if", "(", "riscv_symbol_insns", "(", "sym_type", ")", "==", "0", ")", "return", "false", ";", "if", "(", "!", "riscv_split_symbol_type", "(", "sym_type", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "(", "!", "TARGET_STRICT_ALIGN", "||", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "riscv", "0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Local Dynamic TLS Access Clean-up\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"Local Dynamic TLS Access Clean-up\"" ]

[]