Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "AZPRAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Register", ":", "O", "<<", "'$'", "<<", "StringRef", "(", "AZPRInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AZPR", "AZPR", "AZPR" ]

[]

[ "<s>", "void", "addOptimizedRegAlloc", "(", ")", "override", "{", "addPass", "(", "createTPCExpandHWRegCopies", "(", ")", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "bool", "frv_const_unspec_p", "(", "rtx", "x", ",", "struct", "frv_unspec", "*", "unspec", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "unspec", "->", "offset", "=", "0", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "unspec", "->", "offset", "+=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOT", ")", "{", "unspec", "->", "symbol", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "unspec", "->", "reloc", "=", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ";", "if", "(", "unspec", "->", "offset", "==", "0", ")", "return", "true", ";", "if", "(", "frv_small_data_reloc_p", "(", "unspec", "->", "symbol", ",", "unspec", "->", "reloc", ")", "&&", "unspec", "->", "offset", ">", "0", "&&", "unspec", "->", "offset", "<", "g_switch_value", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "relocation", "unspec", ".", "If", "it", "is", ",", "fill", "in", "UNSPEC", "appropriately", "." ]

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

[]

[ "<s>", "static", "void", "alpha_canonicalize_comparison", "(", "int", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "op0_preserve_value", ")", "{", "if", "(", "!", "op0_preserve_value", "&&", "(", "*", "code", "==", "GE", "||", "*", "code", "==", "GT", "||", "*", "code", "==", "GEU", "||", "*", "code", "==", "GTU", ")", "&&", "(", "REG_P", "(", "*", "op1", ")", "||", "*", "op1", "==", "const0_rtx", ")", ")", "{", "rtx", "tem", "=", "*", "op0", ";", "*", "op0", "=", "*", "op1", ";", "*", "op1", "=", "tem", ";", "*", "code", "=", "(", "int", ")", "swap_condition", "(", "(", "enum", "rtx_code", ")", "*", "code", ")", ";", "}", "if", "(", "(", "*", "code", "==", "LT", "||", "*", "code", "==", "LTU", ")", "&&", "CONST_INT_P", "(", "*", "op1", ")", "&&", "INTVAL", "(", "*", "op1", ")", "==", "256", ")", "{", "*", "code", "=", "*", "code", "==", "LT", "?", "LE", ":", "LEU", ";", "*", "op1", "=", "GEN_INT", "(", "255", ")", ";", "}", "}", "</s>" ]

[ "Canonicalize", "a", "comparison", "from", "one", "we", "do", "n't", "have", "to", "one", "we", "do", "have", "." ]

[ "alpha", "256", "255" ]

[]

[ "<s>", "static", "rtx", "rs6000_debug_legitimize_reload_address", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", ",", "int", "*", "win", ")", "{", "rtx", "ret", "=", "rs6000_legitimize_reload_address", "(", "x", ",", "mode", ",", "opnum", ",", "type", ",", "ind_levels", ",", "win", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_legitimize_reload_address: mode = %s, opnum = %d, \"", "\"type = %d, ind_levels = %d, win = %d, original addr:\\n\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "opnum", ",", "type", ",", "ind_levels", ",", "*", "win", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "x", "==", "ret", ")", "fprintf", "(", "stderr", ",", "\"Same address returned\\n\"", ")", ";", "else", "if", "(", "!", "ret", ")", "fprintf", "(", "stderr", ",", "\"NULL returned\\n\"", ")", ";", "else", "{", "fprintf", "(", "stderr", ",", "\"New address:\\n\"", ")", ";", "debug_rtx", "(", "ret", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_legitimize_reload_address", "." ]

[ "rs6000", "\"\\nrs6000_legitimize_reload_address: mode = %s, opnum = %d, \"", "\"type = %d, ind_levels = %d, win = %d, original addr:\\n\"", "\"Same address returned\\n\"", "\"NULL returned\\n\"", "\"New address:\\n\"" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "SetVector", "<", "Function", "*", ">", "Functions", ";", "AnalysisGetter", "AG", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "Functions", ".", "insert", "(", "&", "F", ")", ";", "}", "CallGraphUpdater", "CGUpdater", ";", "BumpPtrAllocator", "Allocator", ";", "AMDGPUInformationCache", "InfoCache", "(", "M", ",", "AG", ",", "Allocator", ",", "nullptr", ",", "*", "TM", ")", ";", "DenseSet", "<", "const", "char", "*", ">", "Allowed", "(", "{", "&", "AAAMDAttributes", "::", "ID", ",", "&", "AAUniformWorkGroupSize", "::", "ID", ",", "&", "AAAMDFlatWorkGroupSize", "::", "ID", ",", "&", "AACallEdges", "::", "ID", "}", ")", ";", "Attributor", "A", "(", "Functions", ",", "InfoCache", ",", "CGUpdater", ",", "&", "Allowed", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDAttributes", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "A", ".", "getOrCreateAAFor", "<", "AAUniformWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "if", "(", "!", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", ".", "getCallingConv", "(", ")", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDFlatWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "}", "}", "}", "ChangeStatus", "Change", "=", "A", ".", "run", "(", ")", ";", "return", "Change", "==", "ChangeStatus", "::", "CHANGED", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isEntryFunctionCC" ]

[]

[ "<s>", "bool", "ix86_use_pseudo_pic_reg", "(", "void", ")", "{", "if", "(", "(", "TARGET_64BIT", "&&", "(", "ix86_cmodel", "==", "CM_SMALL_PIC", "||", "TARGET_PECOFF", ")", ")", "||", "!", "flag_pic", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "1", "if", "pseudo", "register", "should", "be", "created", "and", "used", "to", "hold", "GOT", "address", "for", "PIC", "code", "." ]

[ "i386" ]

[]

[ "<s>", "rtx", "ix86_libcall_value", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "case", "SCmode", ":", "case", "DFmode", ":", "case", "DCmode", ":", "case", "TFmode", ":", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_SSE_REG", ")", ";", "case", "XFmode", ":", "case", "XCmode", ":", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_FLOAT_REG", ")", ";", "case", "TCmode", ":", "return", "NULL", ";", "default", ":", "return", "gen_rtx_REG", "(", "mode", ",", "0", ")", ";", "}", "}", "else", "return", "gen_rtx_REG", "(", "mode", ",", "ix86_value_regno", "(", "mode", ",", "NULL", ",", "NULL", ")", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "library", "function", "assuming", "the", "value", "has", "mode", "MODE", "." ]

[ "i386", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNSAtoVMEMBug", "(", ")", "&&", "checkNSAtoVMEMHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "checkFPAtomicToDenormModeHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNoDataDepHazard", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "TII", ",", "*", "MI", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "checkInlineAsmHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "checkAnyInstHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

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

[]

[ "<s>", "bool", "isValid", "(", "unsigned", "Val", ")", "const", "{", "return", "Val", "<=", "Max", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "Comet2PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createComet2ISelDag", "(", "getComet2TargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Comet2", "Comet2", "Comet2", "Comet2" ]

[]

[ "<s>", "static", "void", "mmix_target_asm_function_epilogue", "(", "FILE", "*", "stream", ",", "HOST_WIDE_INT", "locals_size", "ATTRIBUTE_UNUSED", ")", "{", "fputc", "(", "'\\n'", ",", "stream", ")", ";", "}", "</s>" ]

[ "TARGET_ASM_FUNCTION_EPILOGUE", "." ]

[ "mmix" ]

[]

[ "<s>", "bool", "PPCCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "MovePCtoLROffset", "=", "0", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "emitBasicBlock", "(", "*", "BB", ")", ";", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"JIT relocation model must be set to static or default!\"", "0" ]

[]

[ "<s>", "bool", "llvm", "::", "getAlign", "(", "const", "CallInst", "&", "I", ",", "unsigned", "index", ",", "unsigned", "&", "align", ")", "{", "if", "(", "MDNode", "*", "alignNode", "=", "I", ".", "getMetadata", "(", "\"callalign\"", ")", ")", "{", "for", "(", "int", "i", "=", "0", ",", "n", "=", "alignNode", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "const", "ConstantInt", "*", "CI", "=", "mdconst", "::", "dyn_extract", "<", "ConstantInt", ">", "(", "alignNode", "->", "getOperand", "(", "i", ")", ")", ")", "{", "unsigned", "v", "=", "CI", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "v", ">>", "16", ")", "==", "index", ")", "{", "align", "=", "v", "&", "0xFFFF", ";", "return", "true", ";", "}", "if", "(", "(", "v", ">>", "16", ")", ">", "index", ")", "{", "return", "false", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "the", "minimum", "known", "alignment", "in", "bytes", "of", "the", "actual", "memory", "reference", "." ]

[ "NVPTX", "\"callalign\"", "0", "16", "0xFFFF", "16" ]

[]

[ "<s>", "static", "bool", "darwin_local_data_pic", "(", "rtx", "disp", ")", "{", "return", "(", "GET_CODE", "(", "disp", ")", "==", "UNSPEC", "&&", "XINT", "(", "disp", ",", "1", ")", "==", "UNSPEC_MACHOPIC_OFFSET", ")", ";", "}", "</s>" ]

[ "Allow", "{", "LABEL", "|", "SYMBOL", "}", "_REF", "-", "SYMBOL_REF-FOR-PICBASE", "for", "Mach-O", "as", "this", "is", "used", "for", "to", "form", "addresses", "to", "local", "data", "when", "-fPIC", "is", "in", "use", "." ]

[ "i386", "1" ]

[]

[ "<s>", "const", "unsigned", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "ghcCall", "=", "false", ";", "if", "(", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "ghcCall", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ":", "false", ")", ";", "}", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "ARM", "::", "LR", ",", "ARM", "::", "R11", ",", "ARM", "::", "R10", ",", "ARM", "::", "R9", ",", "ARM", "::", "R8", ",", "ARM", "::", "R7", ",", "ARM", "::", "R6", ",", "ARM", "::", "R5", ",", "ARM", "::", "R4", ",", "ARM", "::", "D15", ",", "ARM", "::", "D14", ",", "ARM", "::", "D13", ",", "ARM", "::", "D12", ",", "ARM", "::", "D11", ",", "ARM", "::", "D10", ",", "ARM", "::", "D9", ",", "ARM", "::", "D8", ",", "0", "}", ";", "static", "const", "unsigned", "DarwinCalleeSavedRegs", "[", "]", "=", "{", "ARM", "::", "LR", ",", "ARM", "::", "R7", ",", "ARM", "::", "R6", ",", "ARM", "::", "R5", ",", "ARM", "::", "R4", ",", "ARM", "::", "R11", ",", "ARM", "::", "R10", ",", "ARM", "::", "R8", ",", "ARM", "::", "D15", ",", "ARM", "::", "D14", ",", "ARM", "::", "D13", ",", "ARM", "::", "D12", ",", "ARM", "::", "D11", ",", "ARM", "::", "D10", ",", "ARM", "::", "D9", ",", "ARM", "::", "D8", ",", "0", "}", ";", "static", "const", "unsigned", "GhcCalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "ghcCall", "?", "GhcCalleeSavedRegs", ":", "STI", ".", "isTargetDarwin", "(", ")", "?", "DarwinCalleeSavedRegs", ":", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::LR", "ARM::R11", "ARM::R10", "ARM::R9", "ARM::R8", "ARM::R7", "ARM::R6", "ARM::R5", "ARM::R4", "ARM::D15", "ARM::D14", "ARM::D13", "ARM::D12", "ARM::D11", "ARM::D10", "ARM::D9", "ARM::D8", "0", "ARM::LR", "ARM::R7", "ARM::R6", "ARM::R5", "ARM::R4", "ARM::R11", "ARM::R10", "ARM::R8", "ARM::D15", "ARM::D14", "ARM::D13", "ARM::D12", "ARM::D11", "ARM::D10", "ARM::D9", "ARM::D8", "0", "0" ]

[]

[ "<s>", "static", "void", "ix86_expand_ashl_const", "(", "rtx", "operand", ",", "int", "count", ",", "machine_mode", "mode", ")", "{", "if", "(", "count", "==", "1", "||", "(", "count", "*", "ix86_cost", "->", "add", "<=", "ix86_cost", "->", "shift_const", "&&", "!", "optimize_insn_for_size_p", "(", ")", ")", ")", "{", "while", "(", "count", "--", ">", "0", ")", "emit_insn", "(", "gen_add2_insn", "(", "operand", ",", "operand", ")", ")", ";", "}", "else", "{", "rtx", "(", "*", "insn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "insn", "=", "mode", "==", "DImode", "?", "gen_ashlsi3", ":", "gen_ashldi3", ";", "emit_insn", "(", "insn", "(", "operand", ",", "operand", ",", "GEN_INT", "(", "count", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "of", "ix86_split_ashl", "used", "to", "generate", "an", "SImode/DImode", "left", "shift", "by", "a", "constant", ",", "either", "using", "a", "single", "shift", "or", "a", "sequence", "of", "add", "instructions", "." ]

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

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "*", "Reg", ",", "int64_t", "Value", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "STI", ".", "isRV64", "(", ")", "?", "&", "RISCV", "::", "GR64BitRegClass", ":", "&", "RISCV", "::", "GR32BitRegClass", ";", "unsigned", "ZERO", "=", "STI", ".", "isRV64", "(", ")", "?", "RISCV", "::", "zero_64", ":", "RISCV", "::", "zero", ";", "*", "Reg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "if", "(", "isInt", "<", "12", ">", "(", "Value", ")", ")", "{", "Opcode", "=", "STI", ".", "isRV64", "(", ")", "?", "RISCV", "::", "ADDI64", ":", "RISCV", "::", "ADDI", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "*", "Reg", ")", ".", "addReg", "(", "ZERO", ")", ".", "addImm", "(", "Value", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "LI", ")", ",", "*", "Reg", ")", ".", "addImm", "(", "Value", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "RISCV", "RISCV", "RISCV::GR64BitRegClass", "RISCV::GR32BitRegClass", "RISCV::zero_64", "RISCV::zero", "12", "RISCV::ADDI64", "RISCV::ADDI", "RISCV::LI" ]

[]

[ "<s>", "rtx_code", "m68k_output_bftst", "(", "rtx", "zxop0", ",", "rtx", "zxop1", ",", "rtx", "zxop2", ",", "rtx_code", "code", ")", "{", "if", "(", "zxop1", "==", "const1_rtx", "&&", "GET_CODE", "(", "zxop2", ")", "==", "CONST_INT", ")", "{", "int", "width", "=", "GET_CODE", "(", "zxop0", ")", "==", "REG", "?", "31", ":", "7", ";", "return", "m68k_output_btst", "(", "GEN_INT", "(", "width", "-", "INTVAL", "(", "zxop2", ")", ")", ",", "zxop0", ",", "code", ",", "1000", ")", ";", "}", "rtx", "ops", "[", "3", "]", "=", "{", "zxop0", ",", "zxop1", ",", "zxop2", "}", ";", "output_asm_insn", "(", "\"bftst %0{%b2:%b1}\"", ",", "ops", ")", ";", "return", "code", ";", "}", "</s>" ]

[ "Output", "a", "bftst", "instruction", "for", "a", "zero_extract", "with", "ZXOP0", ",", "ZXOP1", "and", "ZXOP2", "operands", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ",", "and", "we", "return", "the", "code", "to", "be", "actually", "used", "in", "the", "jump", "." ]

[ "m68k", "31", "7", "1000", "3", "\"bftst %0{%b2:%b1}\"" ]

[]

[ "<s>", "void", "HexagonMCShuffler", "::", "init", "(", "MCInst", "&", "MCB", ",", "MCInst", "const", "&", "AddMI", ",", "bool", "bInsertAtFront", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "MCB", ")", ")", "{", "if", "(", "bInsertAtFront", ")", "append", "(", "AddMI", ",", "nullptr", ",", "HexagonMCInstrInfo", "::", "getUnits", "(", "MCII", ",", "STI", ",", "AddMI", ")", ")", ";", "MCInst", "const", "*", "Extender", "=", "nullptr", ";", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "MCB", ")", ")", "{", "assert", "(", "!", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "*", "I", ".", "getInst", "(", ")", ")", ".", "isPseudo", "(", ")", ")", ";", "MCInst", "&", "MI", "=", "*", "const_cast", "<", "MCInst", "*", ">", "(", "I", ".", "getInst", "(", ")", ")", ";", "if", "(", "!", "HexagonMCInstrInfo", "::", "isImmext", "(", "MI", ")", ")", "{", "append", "(", "MI", ",", "Extender", ",", "HexagonMCInstrInfo", "::", "getUnits", "(", "MCII", ",", "STI", ",", "MI", ")", ")", ";", "Extender", "=", "nullptr", ";", "}", "else", "Extender", "=", "&", "MI", ";", "}", "if", "(", "!", "bInsertAtFront", ")", "append", "(", "AddMI", ",", "nullptr", ",", "HexagonMCInstrInfo", "::", "getUnits", "(", "MCII", ",", "STI", ",", "AddMI", ")", ")", ";", "}", "Loc", "=", "MCB", ".", "getLoc", "(", ")", ";", "BundleFlags", "=", "MCB", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "return", "isZExtFree", "(", "Val", ".", "getValueType", "(", ")", ",", "VT2", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

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

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

[ "PowerPC", "PPC" ]

[]

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

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

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

[]

[ "<s>", "void", "ia64_expand_compare", "(", "rtx", "*", "expr", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "*", "expr", ")", ";", "rtx", "cmp", ";", "if", "(", "GET_MODE", "(", "*", "op0", ")", "==", "BImode", ")", "{", "gcc_assert", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "*", "op1", "==", "const0_rtx", ")", ";", "cmp", "=", "*", "op0", ";", "}", "else", "if", "(", "TARGET_HPUX", "&&", "GET_MODE", "(", "*", "op0", ")", "==", "TFmode", ")", "{", "enum", "qfcmp_magic", "{", "QCMP_INV", "=", "1", ",", "QCMP_UNORD", "=", "2", ",", "QCMP_EQ", "=", "4", ",", "QCMP_LT", "=", "8", ",", "QCMP_GT", "=", "16", "}", ";", "int", "magic", ";", "enum", "rtx_code", "ncode", ";", "rtx", "ret", ",", "insns", ";", "gcc_assert", "(", "cmptf_libfunc", "&&", "GET_MODE", "(", "*", "op1", ")", "==", "TFmode", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "magic", "=", "QCMP_EQ", ";", "ncode", "=", "NE", ";", "break", ";", "case", "NE", ":", "magic", "=", "QCMP_EQ", ";", "ncode", "=", "EQ", ";", "break", ";", "case", "UNORDERED", ":", "magic", "=", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "ORDERED", ":", "magic", "=", "QCMP_UNORD", ";", "ncode", "=", "EQ", ";", "break", ";", "case", "LT", ":", "magic", "=", "QCMP_LT", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "LE", ":", "magic", "=", "QCMP_LT", "|", "QCMP_EQ", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "GT", ":", "magic", "=", "QCMP_GT", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "GE", ":", "magic", "=", "QCMP_GT", "|", "QCMP_EQ", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNLT", ":", "magic", "=", "QCMP_LT", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNLE", ":", "magic", "=", "QCMP_LT", "|", "QCMP_EQ", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNGT", ":", "magic", "=", "QCMP_GT", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNGE", ":", "magic", "=", "QCMP_GT", "|", "QCMP_EQ", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "start_sequence", "(", ")", ";", "ret", "=", "emit_library_call_value", "(", "cmptf_libfunc", ",", "0", ",", "LCT_CONST", ",", "DImode", ",", "3", ",", "*", "op0", ",", "TFmode", ",", "*", "op1", ",", "TFmode", ",", "GEN_INT", "(", "magic", ")", ",", "DImode", ")", ";", "cmp", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cmp", ",", "gen_rtx_fmt_ee", "(", "ncode", ",", "BImode", ",", "ret", ",", "const0_rtx", ")", ")", ")", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "insns", ",", "cmp", ",", "cmp", ",", "gen_rtx_fmt_ee", "(", "code", ",", "BImode", ",", "*", "op0", ",", "*", "op1", ")", ")", ";", "code", "=", "NE", ";", "}", "else", "{", "cmp", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cmp", ",", "gen_rtx_fmt_ee", "(", "code", ",", "BImode", ",", "*", "op0", ",", "*", "op1", ")", ")", ")", ";", "code", "=", "NE", ";", "}", "*", "expr", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cmp", ",", "const0_rtx", ")", ";", "*", "op0", "=", "cmp", ";", "*", "op1", "=", "const0_rtx", ";", "}", "</s>" ]

[ "Emit", "comparison", "instruction", "if", "necessary", ",", "returning", "the", "expression", "that", "holds", "the", "compare", "result", "in", "the", "proper", "mode", "." ]

[ "ia64", "1", "2", "4", "8", "16", "0", "3" ]

[]

[ "<s>", "HOST_WIDE_INT", "rs6000_builtin_mask_calculate", "(", "void", ")", "{", "return", "(", "(", "(", "TARGET_ALTIVEC", ")", "?", "RS6000_BTM_ALTIVEC", ":", "0", ")", "|", "(", "(", "TARGET_CMPB", ")", "?", "RS6000_BTM_CMPB", ":", "0", ")", "|", "(", "(", "TARGET_VSX", ")", "?", "RS6000_BTM_VSX", ":", "0", ")", "|", "(", "(", "TARGET_PAIRED_FLOAT", ")", "?", "RS6000_BTM_PAIRED", ":", "0", ")", "|", "(", "(", "TARGET_FRE", ")", "?", "RS6000_BTM_FRE", ":", "0", ")", "|", "(", "(", "TARGET_FRES", ")", "?", "RS6000_BTM_FRES", ":", "0", ")", "|", "(", "(", "TARGET_FRSQRTE", ")", "?", "RS6000_BTM_FRSQRTE", ":", "0", ")", "|", "(", "(", "TARGET_FRSQRTES", ")", "?", "RS6000_BTM_FRSQRTES", ":", "0", ")", "|", "(", "(", "TARGET_POPCNTD", ")", "?", "RS6000_BTM_POPCNTD", ":", "0", ")", "|", "(", "(", "rs6000_cpu", "==", "PROCESSOR_CELL", ")", "?", "RS6000_BTM_CELL", ":", "0", ")", "|", "(", "(", "TARGET_P8_VECTOR", ")", "?", "RS6000_BTM_P8_VECTOR", ":", "0", ")", "|", "(", "(", "TARGET_P9_VECTOR", ")", "?", "RS6000_BTM_P9_VECTOR", ":", "0", ")", "|", "(", "(", "TARGET_P9_MISC", ")", "?", "RS6000_BTM_P9_MISC", ":", "0", ")", "|", "(", "(", "TARGET_MODULO", ")", "?", "RS6000_BTM_MODULO", ":", "0", ")", "|", "(", "(", "TARGET_64BIT", ")", "?", "RS6000_BTM_64BIT", ":", "0", ")", "|", "(", "(", "TARGET_POWERPC64", ")", "?", "RS6000_BTM_POWERPC64", ":", "0", ")", "|", "(", "(", "TARGET_CRYPTO", ")", "?", "RS6000_BTM_CRYPTO", ":", "0", ")", "|", "(", "(", "TARGET_HTM", ")", "?", "RS6000_BTM_HTM", ":", "0", ")", "|", "(", "(", "TARGET_DFP", ")", "?", "RS6000_BTM_DFP", ":", "0", ")", "|", "(", "(", "TARGET_HARD_FLOAT", ")", "?", "RS6000_BTM_HARD_FLOAT", ":", "0", ")", "|", "(", "(", "TARGET_LONG_DOUBLE_128", ")", "?", "RS6000_BTM_LDBL128", ":", "0", ")", "|", "(", "(", "TARGET_FLOAT128_TYPE", ")", "?", "RS6000_BTM_FLOAT128", ":", "0", ")", "|", "(", "(", "TARGET_FLOAT128_HW", ")", "?", "RS6000_BTM_FLOAT128_HW", ":", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "builtin", "mask", "of", "the", "various", "options", "used", "that", "could", "affect", "which", "builtins", "were", "used", ".", "In", "the", "past", "we", "used", "target_flags", ",", "but", "we", "'ve", "run", "out", "of", "bits", ",", "and", "some", "options", "like", "PAIRED", "are", "no", "longer", "in", "target_flags", "." ]

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

[]

[ "<s>", "rtx", "m32c_eh_return_stackadj_rtx", "(", "void", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "eh_stack_adjust", ")", "{", "rtx", "sa", ";", "sa", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "cfun", "->", "machine", "->", "eh_stack_adjust", "=", "sa", ";", "}", "return", "cfun", "->", "machine", "->", "eh_stack_adjust", ";", "}", "</s>" ]

[ "Implements", "EH_RETURN_STACKADJ_RTX", ".", "Saved", "and", "used", "later", "in", "m32c_emit_eh_epilogue", "." ]

[ "m32c" ]

[]

[ "<s>", "bool", "SPUAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'L'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "0", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "getStackGrowthDirection", "(", ")", "==", "TargetFrameLowering", "::", "StackGrowsDown", "&&", "\"Upwards growing stack unsupported\"", ")", ";", "int", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ";", "int64_t", "SVEStackSize", "=", "assignSVEStackObjectOffsets", "(", "MFI", ",", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ")", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "AFI", "->", "setStackSizeSVE", "(", "alignTo", "(", "SVEStackSize", ",", "16U", ")", ")", ";", "AFI", "->", "setMinMaxSVECSFrameIndex", "(", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ")", ";", "if", "(", "!", "MF", ".", "hasEHFunclets", "(", ")", ")", "return", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "WinEHFuncInfo", "&", "EHInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "int", "UnwindHelpFI", "=", "MFI", ".", "CreateStackObject", "(", "8", ",", "16", ",", "false", ")", ";", "EHInfo", ".", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "DebugLoc", "DL", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "RS", "->", "backward", "(", "std", "::", "prev", "(", "MBBI", ")", ")", ";", "unsigned", "DstReg", "=", "RS", "->", "FindUnusedReg", "(", "&", "AArch64", "::", "GPR64commonRegClass", ")", ";", "assert", "(", "DstReg", "&&", "\"There must be a free register after frame setup\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "MOVi64imm", ")", ",", "DstReg", ")", ".", "addImm", "(", "-", "2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "STURXi", ")", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "UnwindHelpFI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Upwards growing stack unsupported\"", "AArch64", "AArch64", "16U", "8", "16", "AArch64::GPR64commonRegClass", "\"There must be a free register after frame setup\"", "AArch64::MOVi64imm", "2", "AArch64::STURXi", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "{", "if", "(", "Subtarget", "->", "hasFP32Denormals", "(", ")", ")", "return", "Subtarget", "->", "hasFastFMAF32", "(", ")", "||", "Subtarget", "->", "hasDLInsts", "(", ")", ";", "return", "Subtarget", "->", "hasFastFMAF32", "(", ")", "&&", "Subtarget", "->", "hasDLInsts", "(", ")", ";", "}", "case", "MVT", "::", "f64", ":", "return", "true", ";", "case", "MVT", "::", "f16", ":", "return", "Subtarget", "->", "has16BitInsts", "(", ")", "&&", "Subtarget", "->", "hasFP16Denormals", "(", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

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

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetWindows", "(", ")", ")", "return", "CSR_Win_AArch64_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "CSR_AArch64_AAVPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_AArch64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_AArch64_CXX_TLS_Darwin_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "else", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MipsCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "JTI", "=", "(", "(", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "(", "const", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "const", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getTargetData", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MCE", ".", "setModuleInfo", "(", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "T", "get", "(", "uint32_t", "Idx", ")", "const", "{", "assert", "(", "Idx", "!=", "0", "&&", "!", "Map", ".", "empty", "(", ")", "&&", "Idx", "-", "1", "<", "Map", ".", "size", "(", ")", ")", ";", "return", "Map", "[", "Idx", "-", "1", "]", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

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

[]

[ "<s>", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDCARRY", ":", "IsSelected", "=", "selectAddCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "SUBCARRY", ":", "IsSelected", "=", "selectSubCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "{", "Register", "GP", "=", "Subtarget", "->", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "*", "MF", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getRegister", "(", "GP", ",", "N", "->", "getValueType", "(", "0", ")", ")", ".", "getNode", "(", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "Imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "Dl", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "Subtarget", "->", "hasE2", "(", ")", "?", "CSKY", "::", "ADDI32", ":", "CSKY", "::", "ADDI16XZ", ",", "Dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "Imm", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "case", "CSKYISD", "::", "BITCAST_TO_LOHI", ":", "IsSelected", "=", "selectBITCAST_TO_LOHI", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "INLINEASM", ":", "case", "ISD", "::", "INLINEASM_BR", ":", "IsSelected", "=", "selectInlineAsm", "(", "N", ")", ";", "break", ";", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"== \"", "\"\\n\"", "1", "ISD::ADDCARRY", "ISD::SUBCARRY", "ISD::GLOBAL_OFFSET_TABLE", "0", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "CSKY::ADDI32", "CSKY::ADDI16XZ", "MVT::i32", "CSKYISD::BITCAST_TO_LOHI", "ISD::INLINEASM", "ISD::INLINEASM_BR" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "PIC16Section", "*", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "PIC16", "PIC16" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "12", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "RISCV", "RISCV", "12" ]

[]

[ "<s>", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Mandarin" ]

[]

[ "<s>", "void", "s390_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "n_gpr", ",", "n_fpr", ";", "int", "off", ";", "tree", "f_gpr", ",", "f_fpr", ",", "f_ovf", ",", "f_sav", ";", "tree", "gpr", ",", "fpr", ",", "ovf", ",", "sav", ",", "t", ";", "f_gpr", "=", "TYPE_FIELDS", "(", "TREE_TYPE", "(", "va_list_type_node", ")", ")", ";", "f_fpr", "=", "TREE_CHAIN", "(", "f_gpr", ")", ";", "f_ovf", "=", "TREE_CHAIN", "(", "f_fpr", ")", ";", "f_sav", "=", "TREE_CHAIN", "(", "f_ovf", ")", ";", "valist", "=", "build_va_arg_indirect_ref", "(", "valist", ")", ";", "gpr", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_gpr", ")", ",", "valist", ",", "f_gpr", ",", "NULL_TREE", ")", ";", "fpr", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_fpr", ")", ",", "valist", ",", "f_fpr", ",", "NULL_TREE", ")", ";", "ovf", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ovf", ")", ",", "valist", ",", "f_ovf", ",", "NULL_TREE", ")", ";", "sav", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_sav", ")", ",", "valist", ",", "f_sav", ",", "NULL_TREE", ")", ";", "n_gpr", "=", "current_function_args_info", ".", "gprs", ";", "n_fpr", "=", "current_function_args_info", ".", "fprs", ";", "if", "(", "cfun", "->", "va_list_gpr_size", ")", "{", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "gpr", ")", ",", "gpr", ",", "build_int_cst", "(", "NULL_TREE", ",", "n_gpr", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", ")", "{", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "fpr", ")", ",", "fpr", ",", "build_int_cst", "(", "NULL_TREE", ",", "n_fpr", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "if", "(", "n_gpr", "+", "cfun", "->", "va_list_gpr_size", ">", "GP_ARG_NUM_REG", "||", "n_fpr", "+", "cfun", "->", "va_list_fpr_size", ">", "FP_ARG_NUM_REG", ")", "{", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovf", ")", ",", "virtual_incoming_args_rtx", ")", ";", "off", "=", "INTVAL", "(", "current_function_arg_offset_rtx", ")", ";", "off", "=", "off", "<", "0", "?", "0", ":", "off", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"va_start: n_gpr = %d, n_fpr = %d off %d\\n\"", ",", "(", "int", ")", "n_gpr", ",", "(", "int", ")", "n_fpr", ",", "off", ")", ";", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "off", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "ovf", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "if", "(", "(", "cfun", "->", "va_list_gpr_size", "&&", "n_gpr", "<", "GP_ARG_NUM_REG", ")", "||", "(", "cfun", "->", "va_list_fpr_size", "&&", "n_fpr", "<", "FP_ARG_NUM_REG", ")", ")", "{", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "sav", ")", ",", "return_address_pointer_rtx", ")", ";", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "sav", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "-", "RETURN_REGNUM", "*", "UNITS_PER_WORD", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "sav", ")", ",", "sav", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "}", "</s>" ]

[ "Implement", "va_start", "by", "filling", "the", "va_list", "structure", "VALIST", ".", "STDARG_P", "is", "always", "true", ",", "and", "ignored", ".", "NEXTARG", "points", "to", "the", "first", "anonymous", "stack", "argument", ".", "The", "following", "global", "variables", "are", "used", "to", "initialize", "the", "va_list", "structure", ":", "current_function_args_info", ":", "holds", "number", "of", "gprs", "and", "fprs", "used", "for", "named", "arguments", ".", "current_function_arg_offset_rtx", ":", "holds", "the", "offset", "of", "the", "first", "anonymous", "stack", "argument", "(", "relative", "to", "the", "virtual", "arg", "pointer", ")", "." ]

[ "s390", "1", "1", "0", "0", "\"va_start: n_gpr = %d, n_fpr = %d off %d\\n\"", "1", "1" ]

[]

[ "<s>", "void", "ix86_expand_sse2_abs", "(", "rtx", "target", ",", "rtx", "input", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "rtx", "tmp0", ",", "tmp1", ",", "x", ";", "switch", "(", "mode", ")", "{", "case", "V4SImode", ":", "tmp0", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFTRT", ",", "input", ",", "GEN_INT", "(", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", "-", "1", ")", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "tmp1", "=", "expand_simple_binop", "(", "mode", ",", "XOR", ",", "tmp0", ",", "input", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "x", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "tmp1", ",", "tmp0", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "V8HImode", ":", "tmp0", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "input", ",", "NULL_RTX", ",", "0", ")", ";", "x", "=", "expand_simple_binop", "(", "mode", ",", "SMAX", ",", "tmp0", ",", "input", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "V16QImode", ":", "tmp0", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "input", ",", "NULL_RTX", ",", "0", ")", ";", "x", "=", "expand_simple_binop", "(", "V16QImode", ",", "UMIN", ",", "tmp0", ",", "input", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "x", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "x", ")", ";", "}", "</s>" ]

[ "Calculate", "integer", "abs", "(", ")", "using", "only", "SSE2", "instructions", "." ]

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

[]

[ "<s>", "void", "SIFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedVGPRs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedVGPRs", ",", "RS", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", "->", "isEntryFunction", "(", ")", ")", "return", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "SavedVGPRs", ".", "clearBitsNotInMask", "(", "TRI", "->", "getAllVGPRRegMask", "(", ")", ")", ";", "const", "bool", "WillHaveFP", "=", "FrameInfo", ".", "hasCalls", "(", ")", "&&", "(", "SavedVGPRs", ".", "any", "(", ")", "||", "!", "allStackObjectsAreDead", "(", "FrameInfo", ")", ")", ";", "for", "(", "auto", "SSpill", ":", "MFI", "->", "getSGPRSpillVGPRs", "(", ")", ")", "SavedVGPRs", ".", "reset", "(", "SSpill", ".", "VGPR", ")", ";", "LivePhysRegs", "LiveRegs", ";", "LiveRegs", ".", "init", "(", "*", "TRI", ")", ";", "if", "(", "WillHaveFP", "||", "hasFP", "(", "MF", ")", ")", "{", "getVGPRSpillLaneOrTempRegister", "(", "MF", ",", "LiveRegs", ",", "MFI", "->", "SGPRForFPSaveRestoreCopy", ",", "MFI", "->", "FramePointerSaveIndex", ",", "true", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "MFI", "->", "SGPRForFPSaveRestoreCopy", ")", "LiveRegs", ".", "addReg", "(", "MFI", "->", "SGPRForFPSaveRestoreCopy", ")", ";", "getVGPRSpillLaneOrTempRegister", "(", "MF", ",", "LiveRegs", ",", "MFI", "->", "SGPRForBPSaveRestoreCopy", ",", "MFI", "->", "BasePointerSaveIndex", ",", "false", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "s390_set_current_function", "(", "tree", "fndecl", ")", "{", "if", "(", "fndecl", "==", "s390_previous_fndecl", ")", "return", ";", "tree", "old_tree", ";", "if", "(", "s390_previous_fndecl", "==", "NULL_TREE", ")", "old_tree", "=", "target_option_current_node", ";", "else", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "s390_previous_fndecl", ")", ")", "old_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "s390_previous_fndecl", ")", ";", "else", "old_tree", "=", "target_option_default_node", ";", "if", "(", "fndecl", "==", "NULL_TREE", ")", "{", "if", "(", "old_tree", "!=", "target_option_current_node", ")", "s390_activate_target_options", "(", "target_option_current_node", ")", ";", "return", ";", "}", "tree", "new_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "new_tree", "==", "NULL_TREE", ")", "new_tree", "=", "target_option_default_node", ";", "if", "(", "old_tree", "!=", "new_tree", ")", "s390_activate_target_options", "(", "new_tree", ")", ";", "s390_previous_fndecl", "=", "fndecl", ";", "}", "</s>" ]

[ "Establish", "appropriate", "back-end", "context", "for", "processing", "the", "function", "FNDECL", ".", "The", "argument", "might", "be", "NULL", "to", "indicate", "processing", "at", "top", "level", ",", "outside", "of", "any", "function", "scope", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "ARMGlobalMerge", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "SmallVector", "<", "GlobalVariable", "*", ",", "16", ">", "Globals", ",", "ConstGlobals", ",", "BSSGlobals", ";", "const", "TargetData", "*", "TD", "=", "TLI", "->", "getTargetData", "(", ")", ";", "unsigned", "MaxOffset", "=", "TLI", "->", "getMaximalGlobalOffset", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "hasLocalLinkage", "(", ")", "||", "I", "->", "isThreadLocal", "(", ")", "||", "I", "->", "hasSection", "(", ")", ")", "continue", ";", "unsigned", "Alignment", "=", "I", "->", "getAlignment", "(", ")", ";", "Type", "*", "Ty", "=", "I", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "if", "(", "Alignment", ">", "TD", "->", "getABITypeAlignment", "(", "Ty", ")", ")", "continue", ";", "if", "(", "I", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.\"", ")", "||", "I", "->", "getName", "(", ")", ".", "startswith", "(", "\".llvm.\"", ")", ")", "continue", ";", "if", "(", "TD", "->", "getTypeAllocSize", "(", "Ty", ")", "<", "MaxOffset", ")", "{", "const", "TargetLoweringObjectFile", "&", "TLOF", "=", "TLI", "->", "getObjFileLowering", "(", ")", ";", "if", "(", "TLOF", ".", "getKindForGlobal", "(", "I", ",", "TLI", "->", "getTargetMachine", "(", ")", ")", ".", "isBSSLocal", "(", ")", ")", "BSSGlobals", ".", "push_back", "(", "I", ")", ";", "else", "if", "(", "I", "->", "isConstant", "(", ")", ")", "ConstGlobals", ".", "push_back", "(", "I", ")", ";", "else", "Globals", ".", "push_back", "(", "I", ")", ";", "}", "}", "if", "(", "Globals", ".", "size", "(", ")", ">", "1", ")", "Changed", "|=", "doMerge", "(", "Globals", ",", "M", ",", "false", ")", ";", "if", "(", "BSSGlobals", ".", "size", "(", ")", ">", "1", ")", "Changed", "|=", "doMerge", "(", "BSSGlobals", ",", "M", ",", "false", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "ARM", "ARM", "16", "\"llvm.\"", "\".llvm.\"", "1", "1" ]

[]

[ "<s>", "NVPTXTargetLowering", "::", "AtomicExpansionKind", "NVPTXTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "Type", "*", "Ty", "=", "AI", "->", "getValOperand", "(", ")", "->", "getType", "(", ")", ";", "if", "(", "AI", "->", "isFloatingPointOperation", "(", ")", ")", "{", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "BinOp", "::", "FAdd", ")", "{", "if", "(", "Ty", "->", "isFloatTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "Ty", "->", "isDoubleTy", "(", ")", "&&", "STI", ".", "hasAtomAddF64", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "}", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"Ty should be integer at this point\"", ")", ";", "auto", "ITy", "=", "cast", "<", "llvm", "::", "IntegerType", ">", "(", "Ty", ")", ";", "switch", "(", "AI", "->", "getOperation", "(", ")", ")", "{", "default", ":", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "case", "AtomicRMWInst", "::", "BinOp", "::", "And", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "Or", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "Xor", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "Xchg", ":", "switch", "(", "ITy", "->", "getBitWidth", "(", ")", ")", "{", "case", "8", ":", "case", "16", ":", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "case", "32", ":", "return", "AtomicExpansionKind", "::", "None", ";", "case", "64", ":", "if", "(", "STI", ".", "hasAtomBitwise64", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "default", ":", "llvm_unreachable", "(", "\"unsupported width encountered\"", ")", ";", "}", "case", "AtomicRMWInst", "::", "BinOp", "::", "Add", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "Sub", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "Max", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "Min", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "UMax", ":", "case", "AtomicRMWInst", "::", "BinOp", "::", "UMin", ":", "switch", "(", "ITy", "->", "getBitWidth", "(", ")", ")", "{", "case", "8", ":", "case", "16", ":", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "case", "32", ":", "return", "AtomicExpansionKind", "::", "None", ";", "case", "64", ":", "if", "(", "STI", ".", "hasAtomMinMax64", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "default", ":", "llvm_unreachable", "(", "\"unsupported width encountered\"", ")", ";", "}", "}", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "\"Ty should be integer at this point\"", "8", "16", "32", "64", "\"unsupported width encountered\"", "8", "16", "32", "64", "\"unsupported width encountered\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "PPC", "::", "MFFS", "||", "MI", ".", "getOpcode", "(", ")", "==", "PPC", "::", "MTFSF", ")", "return", "true", ";", "return", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MFFS", "PPC::MTFSF" ]

[]

[ "<s>", "static", "bool", "visium_pass_by_reference", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "argument", "must", "be", "passed", "by", "indirect", "reference", "." ]

[ "visium" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "{", "ConstantSDNode", "*", "True", ",", "*", "False", ";", "if", "(", "(", "True", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "2", ")", ")", ")", "&&", "(", "False", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "3", ")", ")", ")", "&&", "True", "->", "isAllOnesValue", "(", ")", "&&", "False", "->", "isNullValue", "(", ")", "&&", "VT", "==", "MVT", "::", "i1", ")", "{", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SETCC", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ",", "N", "->", "getOperand", "(", "4", ")", ")", ";", "}", "break", ";", "}", "case", "ISD", "::", "SETCC", ":", "{", "SDValue", "Arg0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Arg1", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "CC", "=", "N", "->", "getOperand", "(", "2", ")", ";", "ConstantSDNode", "*", "C", "=", "nullptr", ";", "ISD", "::", "CondCode", "CCOp", "=", "dyn_cast", "<", "CondCodeSDNode", ">", "(", "CC", ")", "->", "get", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "&&", "Arg0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "&&", "Arg0", ".", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", "&&", "(", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Arg1", ")", ")", "&&", "C", "->", "isNullValue", "(", ")", "&&", "CCOp", "==", "ISD", "::", "SETNE", ")", "{", "return", "SimplifySetCC", "(", "VT", ",", "Arg0", ".", "getOperand", "(", "0", ")", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i1", ")", ",", "CCOp", ",", "true", ",", "DCI", ",", "DL", ")", ";", "}", "break", ";", "}", "}", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</s>" ]

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

[ "R600", "SI", "0", "ISD::SELECT_CC", "2", "3", "MVT::i1", "ISD::SETCC", "0", "1", "4", "ISD::SETCC", "0", "1", "2", "ISD::CondCode", "MVT::i1", "ISD::SIGN_EXTEND", "0", "MVT::i1", "ISD::SETNE", "0", "0", "MVT::i1" ]

[]

[ "<s>", "static", "void", "visium_function_arg_advance", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "size", "=", "(", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "stack_size", "=", "0", ";", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "if", "(", "TARGET_FPU", "&&", "(", "(", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", ")", "||", "(", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", "*", "2", ")", ")", ")", "{", "if", "(", "ca", "->", "frcount", "+", "size", "<=", "MAX_ARGS_IN_FP_REGISTERS", ")", "ca", "->", "frcount", "+=", "size", ";", "else", "{", "stack_size", "=", "size", ";", "ca", "->", "frcount", "=", "MAX_ARGS_IN_FP_REGISTERS", ";", "}", "}", "else", "{", "if", "(", "ca", "->", "grcount", "+", "size", "<=", "MAX_ARGS_IN_GP_REGISTERS", ")", "ca", "->", "grcount", "+=", "size", ";", "else", "{", "stack_size", "=", "size", ";", "ca", "->", "grcount", "=", "MAX_ARGS_IN_GP_REGISTERS", ";", "}", "}", "if", "(", "arg", ".", "named", ")", "ca", "->", "stack_words", "+=", "stack_size", ";", "}", "</s>" ]

[ "Update", "the", "summarizer", "variable", "pointed", "to", "by", "PCUM_V", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", ".", "The", "values", "MODE", ",", "TYPE", "and", "NAMED", "describe", "that", "argument", ".", "Once", "this", "is", "done", ",", "the", "variable", "CUM", "is", "suitable", "for", "analyzing", "the", "_following_", "argument", "with", "visium_function_arg", "." ]

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

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "*", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", "PreferFalse", ")", "const", "{", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "MOVCCr", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2MOVCCr", ")", "&&", "\"Unknown select instruction\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", "->", "getOperand", "(", "Invert", "?", "2", ":", "1", ")", ";", "unsigned", "DestReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "PreviousClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "PreviousClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "addOperand", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "ARMCC", "::", "CondCodes", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "4", ")", ")", ";", "if", "(", "NewMI", "->", "hasOptionalDef", "(", ")", ")", "AddDefaultCC", "(", "NewMI", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "addOperand", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "0", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}", "</s>" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ "ARM", "ARM", "ARM::MOVCCr", "ARM::t2MOVCCr", "\"Unknown select instruction\"", "2", "1", "2", "1", "0", "1", "3", "ARMCC::getOppositeCondition", "ARMCC::CondCodes", "4", "0", "1" ]

[]

[ "<s>", "const", "MipsGOT", "&", "MipsGNULDBackend", "::", "getGOT", "(", ")", "const", "{", "assert", "(", "m_pGOT", "!=", "NULL", ")", ";", "return", "*", "m_pGOT", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "global", "offset", "table", "(", "or", "something", "the", "like", ")", "." ]

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

[]

[ "<s>", "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MipsISD", "::", "JmpLink", ":", "return", "\"MipsISD::JmpLink\"", ";", "case", "MipsISD", "::", "Hi", ":", "return", "\"MipsISD::Hi\"", ";", "case", "MipsISD", "::", "Lo", ":", "return", "\"MipsISD::Lo\"", ";", "case", "MipsISD", "::", "GPRel", ":", "return", "\"MipsISD::GPRel\"", ";", "case", "MipsISD", "::", "Ret", ":", "return", "\"MipsISD::Ret\"", ";", "case", "MipsISD", "::", "CMov", ":", "return", "\"MipsISD::CMov\"", ";", "case", "MipsISD", "::", "SelectCC", ":", "return", "\"MipsISD::SelectCC\"", ";", "case", "MipsISD", "::", "FPSelectCC", ":", "return", "\"MipsISD::FPSelectCC\"", ";", "case", "MipsISD", "::", "FPBrcond", ":", "return", "\"MipsISD::FPBrcond\"", ";", "case", "MipsISD", "::", "FPCmp", ":", "return", "\"MipsISD::FPCmp\"", ";", "case", "MipsISD", "::", "FPRound", ":", "return", "\"MipsISD::FPRound\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsISD::JmpLink", "\"MipsISD::JmpLink\"", "MipsISD::Hi", "\"MipsISD::Hi\"", "MipsISD::Lo", "\"MipsISD::Lo\"", "MipsISD::GPRel", "\"MipsISD::GPRel\"", "MipsISD::Ret", "\"MipsISD::Ret\"", "MipsISD::CMov", "\"MipsISD::CMov\"", "MipsISD::SelectCC", "\"MipsISD::SelectCC\"", "MipsISD::FPSelectCC", "\"MipsISD::FPSelectCC\"", "MipsISD::FPBrcond", "\"MipsISD::FPBrcond\"", "MipsISD::FPCmp", "\"MipsISD::FPCmp\"", "MipsISD::FPRound", "\"MipsISD::FPRound\"" ]

[]

[ "<s>", "static", "void", "expand_set_or_movmem_via_rep", "(", "rtx", "destmem", ",", "rtx", "srcmem", ",", "rtx", "destptr", ",", "rtx", "srcptr", ",", "rtx", "value", ",", "rtx", "orig_value", ",", "rtx", "count", ",", "machine_mode", "mode", ",", "bool", "issetmem", ")", "{", "rtx", "destexp", ";", "rtx", "srcexp", ";", "rtx", "countreg", ";", "HOST_WIDE_INT", "rounded_count", ";", "if", "(", "mode", "==", "QImode", "&&", "CONST_INT_P", "(", "count", ")", "&&", "!", "(", "INTVAL", "(", "count", ")", "&", "3", ")", "&&", "(", "!", "issetmem", "||", "orig_value", "==", "const0_rtx", ")", ")", "mode", "=", "SImode", ";", "if", "(", "destptr", "!=", "XEXP", "(", "destmem", ",", "0", ")", "||", "GET_MODE", "(", "destmem", ")", "!=", "BLKmode", ")", "destmem", "=", "adjust_automodify_address_nv", "(", "destmem", ",", "BLKmode", ",", "destptr", ",", "0", ")", ";", "countreg", "=", "ix86_zero_extend_to_Pmode", "(", "scale_counter", "(", "count", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "if", "(", "mode", "!=", "QImode", ")", "{", "destexp", "=", "gen_rtx_ASHIFT", "(", "Pmode", ",", "countreg", ",", "GEN_INT", "(", "exact_log2", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ";", "destexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "destexp", ",", "destptr", ")", ";", "}", "else", "destexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "destptr", ",", "countreg", ")", ";", "if", "(", "(", "!", "issetmem", "||", "orig_value", "==", "const0_rtx", ")", "&&", "CONST_INT_P", "(", "count", ")", ")", "{", "rounded_count", "=", "ROUND_DOWN", "(", "INTVAL", "(", "count", ")", ",", "(", "HOST_WIDE_INT", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "destmem", "=", "shallow_copy_rtx", "(", "destmem", ")", ";", "set_mem_size", "(", "destmem", ",", "rounded_count", ")", ";", "}", "else", "if", "(", "MEM_SIZE_KNOWN_P", "(", "destmem", ")", ")", "clear_mem_size", "(", "destmem", ")", ";", "if", "(", "issetmem", ")", "{", "value", "=", "force_reg", "(", "mode", ",", "gen_lowpart", "(", "mode", ",", "value", ")", ")", ";", "emit_insn", "(", "gen_rep_stos", "(", "destptr", ",", "countreg", ",", "destmem", ",", "value", ",", "destexp", ")", ")", ";", "}", "else", "{", "if", "(", "srcptr", "!=", "XEXP", "(", "srcmem", ",", "0", ")", "||", "GET_MODE", "(", "srcmem", ")", "!=", "BLKmode", ")", "srcmem", "=", "adjust_automodify_address_nv", "(", "srcmem", ",", "BLKmode", ",", "srcptr", ",", "0", ")", ";", "if", "(", "mode", "!=", "QImode", ")", "{", "srcexp", "=", "gen_rtx_ASHIFT", "(", "Pmode", ",", "countreg", ",", "GEN_INT", "(", "exact_log2", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ";", "srcexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "srcexp", ",", "srcptr", ")", ";", "}", "else", "srcexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "srcptr", ",", "countreg", ")", ";", "if", "(", "CONST_INT_P", "(", "count", ")", ")", "{", "rounded_count", "=", "ROUND_DOWN", "(", "INTVAL", "(", "count", ")", ",", "(", "HOST_WIDE_INT", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "srcmem", "=", "shallow_copy_rtx", "(", "srcmem", ")", ";", "set_mem_size", "(", "srcmem", ",", "rounded_count", ")", ";", "}", "else", "{", "if", "(", "MEM_SIZE_KNOWN_P", "(", "srcmem", ")", ")", "clear_mem_size", "(", "srcmem", ")", ";", "}", "emit_insn", "(", "gen_rep_mov", "(", "destptr", ",", "destmem", ",", "srcptr", ",", "srcmem", ",", "countreg", ",", "destexp", ",", "srcexp", ")", ")", ";", "}", "}", "</s>" ]

[ "Output", "``", "rep", ";", "mov", "''", "or", "``", "rep", ";", "stos", "''", "instruction", "depending", "on", "ISSETMEM", "argument", ".", "When", "ISSETMEM", "is", "true", ",", "arguments", "SRCMEM", "and", "SRCPTR", "are", "ignored", ".", "When", "ISSETMEM", "is", "false", ",", "arguments", "VALUE", "and", "ORIG_VALUE", "are", "ignored", ".", "For", "setmem", "case", ",", "VALUE", "is", "a", "promoted", "to", "a", "wider", "size", "ORIG_VALUE", ".", "ORIG_VALUE", "is", "the", "original", "value", "passed", "to", "memset", "to", "fill", "the", "memory", "with", ".", "Other", "arguments", "have", "same", "meaning", "as", "for", "previous", "function", "." ]

[ "i386", "3", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "Register", "ExtReg", ";", "unsigned", "PhysRegSize", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegSizeInBits", "(", "PhysReg", ",", "MRI", ")", ";", "unsigned", "ValSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "unsigned", "LocSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "PhysRegSize", ">", "ValSize", "&&", "LocSize", "==", "ValSize", ")", "{", "assert", "(", "(", "PhysRegSize", "==", "128", "||", "PhysRegSize", "==", "80", ")", "&&", "\"We expect that to be 128 bit\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildAnyExt", "(", "LLT", "::", "scalar", "(", "PhysRegSize", ")", ",", "ValVReg", ")", ";", "ExtReg", "=", "MIB", ".", "getReg", "(", "0", ")", ";", "}", "else", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ExtReg", ")", ";", "}", "</s>" ]

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

[ "X86", "128", "80", "\"We expect that to be 128 bit\"", "0" ]

[]

[ "<s>", "static", "void", "rs6000_emit_prologue_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "rtx", "ptr_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "frame_pointer_needed", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", ")", ";", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "0", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "reg", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "NULL", ")", ";", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "lr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "rtx", "mem", "=", "copy_rtx", "(", "SET_DEST", "(", "single_set", "(", "insn", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "lr", ")", ")", ";", "}", "int", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "32", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "set", "=", "copy_rtx", "(", "single_set", "(", "insn", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "}", "offset", "+=", "reg_size", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS", "." ]

[ "rs6000", "4", "8", "0", "0", "1", "1", "32", "1" ]

[]

[ "<s>", "static", "unsigned", "int", "frv_insn_unit", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_type", "type", ";", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "frv_type_to_unit", "[", "type", "]", "==", "ARRAY_SIZE", "(", "frv_unit_codes", ")", ")", "{", "state_t", "state", ";", "unsigned", "int", "unit", ";", "state", "=", "alloca", "(", "state_size", "(", ")", ")", ";", "state_reset", "(", "state", ")", ";", "state_transition", "(", "state", ",", "insn", ")", ";", "for", "(", "unit", "=", "0", ";", "unit", "<", "ARRAY_SIZE", "(", "frv_unit_codes", ")", ";", "unit", "++", ")", "if", "(", "cpu_unit_reservation_p", "(", "state", ",", "frv_unit_codes", "[", "unit", "]", ")", ")", "break", ";", "gcc_assert", "(", "unit", "!=", "ARRAY_SIZE", "(", "frv_unit_codes", ")", ")", ";", "frv_type_to_unit", "[", "type", "]", "=", "unit", ";", "}", "return", "frv_type_to_unit", "[", "type", "]", ";", "}", "</s>" ]

[ "Return", "the", "index", "of", "the", "DFA", "unit", "in", "FRV_UNIT_NAMES", "[", "]", "that", "instruction", "INSN", "will", "try", "to", "claim", "first", ".", "Since", "this", "value", "depends", "only", "on", "the", "type", "attribute", ",", "we", "can", "cache", "the", "results", "in", "FRV_TYPE_TO_UNIT", "[", "]", "." ]

[ "frv", "0" ]

[]

[ "<s>", "static", "void", "s390_emit_stack_tie", "(", "void", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "stack_pointer_rtx", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "gen_stack_tie", "(", "Pmode", ",", "mem", ",", "hard_frame_pointer_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_stack_tie", "(", "Pmode", ",", "mem", ",", "stack_pointer_rtx", ")", ")", ";", "}", "</s>" ]

[ "This", "ties", "together", "stack", "memory", "(", "MEM", "with", "an", "alias", "set", "of", "frame_alias_set", ")", "and", "the", "change", "to", "the", "stack", "pointer", "." ]

[ "s390" ]

[]

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

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

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

[]

[ "<s>", "void", "m32c_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "address", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "address", ")", "==", "MEM", ")", ";", "m32c_print_operand", "(", "stream", ",", "XEXP", "(", "address", ",", "0", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Implements", "PRINT_OPERAND_ADDRESS", ".", "Nothing", "unusual", "here", "." ]

[ "m32c", "0", "0" ]

[]

[ "<s>", "static", "void", "do_load_for_compare", "(", "rtx", "reg", ",", "rtx", "mem", ",", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE", "(", "reg", ")", ")", "{", "case", "E_V16QImode", ":", "switch", "(", "mode", ")", "{", "case", "E_V16QImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "if", "(", "TARGET_P9_VECTOR", ")", "emit_insn", "(", "gen_vsx_ld_elemrev_v16qi_internal", "(", "reg", ",", "mem", ")", ")", ";", "else", "{", "rtx", "reg_v2di", "=", "simplify_gen_subreg", "(", "V2DImode", ",", "reg", ",", "V16QImode", ",", "0", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "rtx", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "rtx", "mem_v2di", "=", "gen_rtx_MEM", "(", "V2DImode", ",", "addr", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "mem_v2di", ",", "mem", ")", ";", "set_mem_size", "(", "mem", ",", "GET_MODE_SIZE", "(", "V2DImode", ")", ")", ";", "emit_insn", "(", "gen_vsx_ld_elemrev_v2di", "(", "reg_v2di", ",", "mem_v2di", ")", ")", ";", "}", "}", "else", "emit_insn", "(", "gen_vsx_movv2di_64bit", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "E_DImode", ":", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "emit_insn", "(", "gen_zero_extendqidi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhidi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "E_SImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_bswapsi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendsidi2", "(", "reg", ",", "src", ")", ")", ";", "}", "break", ";", "case", "E_DImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapdi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movdi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "E_SImode", ":", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "emit_insn", "(", "gen_zero_extendqisi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhisi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "E_SImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapsi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_DImode", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "E_QImode", ":", "gcc_assert", "(", "mode", "==", "E_QImode", ")", ";", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Figure", "out", "the", "correct", "instructions", "to", "generate", "to", "load", "data", "for", "block", "compare", ".", "MODE", "is", "used", "for", "the", "read", "from", "memory", ",", "and", "data", "is", "zero", "extended", "if", "REG", "is", "wider", "than", "MODE", ".", "If", "LE", "code", "is", "being", "generated", ",", "bswap", "loads", "are", "used", ".", "REG", "is", "the", "destination", "register", "to", "move", "the", "data", "into", ".", "MEM", "is", "the", "memory", "block", "being", "read", ".", "MODE", "is", "the", "mode", "of", "memory", "to", "use", "for", "the", "read", "." ]

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

[]

[ "<s>", "bool", "HCE", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ")", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AssignmentMap", "IMap", ";", "collect", "(", "MF", ")", ";", "llvm", "::", "sort", "(", "Extenders", ".", "begin", "(", ")", ",", "Extenders", ".", "end", "(", ")", ",", "[", "]", "(", "const", "ExtDesc", "&", "A", ",", "const", "ExtDesc", "&", "B", ")", "{", "return", "ExtValue", "(", "A", ")", "<", "ExtValue", "(", "B", ")", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Collected \"", "<<", "Extenders", ".", "size", "(", ")", "<<", "\" extenders\\n\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Extenders", ".", "size", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "unsigned", "B", "=", "I", ";", "const", "ExtRoot", "&", "T", "=", "Extenders", "[", "B", "]", ".", "getOp", "(", ")", ";", "while", "(", "I", "!=", "E", "&&", "ExtRoot", "(", "Extenders", "[", "I", "]", ".", "getOp", "(", ")", ")", "==", "T", ")", "++", "I", ";", "IMap", ".", "clear", "(", ")", ";", "assignInits", "(", "T", ",", "B", ",", "I", ",", "IMap", ")", ";", "Changed", "|=", "replaceExtenders", "(", "IMap", ")", ";", "}", "DEBUG", "(", "{", "if", "(", "Changed", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ";", "else", "dbgs", "(", ")", "<<", "\"No changes\\n\"", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Before \"", "Hexagon", "Hexagon", "\"Collected \"", "\" extenders\\n\"", "0", "\"After \"", "\"No changes\\n\"" ]

[]

[ "<s>", "static", "int", "force_new_group", "(", "int", "sched_verbose", ",", "FILE", "*", "dump", ",", "rtx", "*", "group_insns", ",", "rtx_insn", "*", "next_insn", ",", "bool", "*", "group_end", ",", "int", "can_issue_more", ",", "int", "*", "group_count", ")", "{", "rtx", "nop", ";", "bool", "force", ";", "int", "issue_rate", "=", "rs6000_issue_rate", "(", ")", ";", "bool", "end", "=", "*", "group_end", ";", "int", "i", ";", "if", "(", "next_insn", "==", "NULL_RTX", "||", "DEBUG_INSN_P", "(", "next_insn", ")", ")", "return", "can_issue_more", ";", "if", "(", "rs6000_sched_insert_nops", ">", "sched_finish_regroup_exact", ")", "return", "can_issue_more", ";", "force", "=", "is_costly_group", "(", "group_insns", ",", "next_insn", ")", ";", "if", "(", "!", "force", ")", "return", "can_issue_more", ";", "if", "(", "sched_verbose", ">", "6", ")", "fprintf", "(", "dump", ",", "\"force: group count = %d, can_issue_more = %d\\n\"", ",", "*", "group_count", ",", "can_issue_more", ")", ";", "if", "(", "rs6000_sched_insert_nops", "==", "sched_finish_regroup_exact", ")", "{", "if", "(", "*", "group_end", ")", "can_issue_more", "=", "0", ";", "if", "(", "can_issue_more", "&&", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "can_issue_more", "--", ";", "if", "(", "rs6000_cpu_attr", "==", "CPU_POWER6", "||", "rs6000_cpu_attr", "==", "CPU_POWER7", "||", "rs6000_cpu_attr", "==", "CPU_POWER8", "||", "rs6000_cpu_attr", "==", "CPU_POWER9", ")", "{", "nop", "=", "gen_group_ending_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "can_issue_more", "=", "0", ";", "}", "else", "while", "(", "can_issue_more", ">", "0", ")", "{", "nop", "=", "gen_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "can_issue_more", "--", ";", "}", "*", "group_end", "=", "true", ";", "return", "0", ";", "}", "if", "(", "rs6000_sched_insert_nops", "<", "sched_finish_regroup_exact", ")", "{", "int", "n_nops", "=", "rs6000_sched_insert_nops", ";", "if", "(", "can_issue_more", "==", "0", ")", "can_issue_more", "=", "issue_rate", ";", "can_issue_more", "--", ";", "if", "(", "can_issue_more", "==", "0", ")", "{", "can_issue_more", "=", "issue_rate", "-", "1", ";", "(", "*", "group_count", ")", "++", ";", "end", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "group_insns", "[", "i", "]", "=", "0", ";", "}", "}", "while", "(", "n_nops", ">", "0", ")", "{", "nop", "=", "gen_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "if", "(", "can_issue_more", "==", "issue_rate", "-", "1", ")", "end", "=", "false", ";", "can_issue_more", "--", ";", "if", "(", "can_issue_more", "==", "0", ")", "{", "can_issue_more", "=", "issue_rate", "-", "1", ";", "(", "*", "group_count", ")", "++", ";", "end", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "group_insns", "[", "i", "]", "=", "0", ";", "}", "}", "n_nops", "--", ";", "}", "can_issue_more", "++", ";", "*", "group_end", "=", "(", "end", "||", "(", "can_issue_more", "==", "1", "&&", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<=", "2", "&&", "is_cracked_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<", "issue_rate", "&&", "insn_terminates_group_p", "(", "next_insn", ",", "previous_group", ")", ")", ")", ";", "if", "(", "*", "group_end", "&&", "end", ")", "(", "*", "group_count", ")", "--", ";", "if", "(", "sched_verbose", ">", "6", ")", "fprintf", "(", "dump", ",", "\"done force: group count = %d, can_issue_more = %d\\n\"", ",", "*", "group_count", ",", "can_issue_more", ")", ";", "return", "can_issue_more", ";", "}", "return", "can_issue_more", ";", "}", "</s>" ]

[ "Utility", "of", "the", "function", "redefine_groups", ".", "Check", "if", "it", "is", "too", "costly", "to", "schedule", "NEXT_INSN", "together", "with", "GROUP_INSNS", "in", "the", "same", "dispatch", "group", ".", "If", "so", ",", "insert", "nops", "before", "NEXT_INSN", ",", "in", "order", "to", "keep", "it", "``", "far", "''", "(", "in", "a", "separate", "group", ")", "from", "GROUP_INSNS", ",", "following", "one", "of", "the", "following", "schemes", ",", "depending", "on", "the", "value", "of", "the", "flag", "-minsert_sched_nops", "=", "X", ":", "(", "1", ")", "X", "==", "sched_finish_regroup_exact", ":", "insert", "exactly", "as", "many", "nops", "as", "needed", "in", "order", "to", "force", "NEXT_INSN", "into", "a", "separate", "group", ".", "(", "2", ")", "X", "<", "sched_finish_regroup_exact", ":", "insert", "exactly", "X", "nops", ".", "GROUP_END", ",", "CAN_ISSUE_MORE", "and", "GROUP_COUNT", "record", "the", "state", "after", "nop", "insertion", "(", "has", "a", "group", "just", "ended", ",", "how", "many", "vacant", "issue", "slots", "remain", "in", "the", "last", "group", ",", "and", "how", "many", "dispatch", "groups", "were", "encountered", "so", "far", ")", "." ]

[ "rs6000", "6", "\"force: group count = %d, can_issue_more = %d\\n\"", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "2", "6", "\"done force: group count = %d, can_issue_more = %d\\n\"" ]

[]

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

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

[ "Z80old", "Z80old" ]

[]

[ "<s>", "static", "bool", "split_stack_arg_pointer_used_p", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "!=", "NULL_RTX", "&&", "(", "!", "REG_P", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "||", "HARD_REGISTER_P", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", ")", ")", "return", "true", ";", "rtx_insn", "*", "insn", ";", "basic_block", "bb", "=", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "next_bb", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "df_ref", "use", ";", "FOR_EACH_INSN_USE", "(", "use", ",", "insn", ")", "{", "rtx", "x", "=", "DF_REF_REG", "(", "use", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "12", ")", "return", "true", ";", "}", "df_ref", "def", ";", "FOR_EACH_INSN_DEF", "(", "def", ",", "insn", ")", "{", "rtx", "x", "=", "DF_REF_REG", "(", "def", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "12", ")", "return", "false", ";", "}", "}", "return", "bitmap_bit_p", "(", "DF_LR_OUT", "(", "bb", ")", ",", "12", ")", ";", "}", "</s>" ]

[ "Return", "whether", "the", "split-stack", "arg", "pointer", "(", "r12", ")", "is", "used", "." ]

[ "rs6000", "12", "12", "12" ]

[]

[ "<s>", "bool", "ARM64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", "->", "getTarget", "(", ")", ".", "getSubtarget", "<", "TargetSubtargetInfo", ">", "(", ")", ";", "SchedModel", ".", "init", "(", "*", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "TII", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "*", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "unsigned", "Offset", ";", "if", "(", "TII", "->", "getLdStBaseRegImmOfs", "(", "&", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "&", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

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

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

[ "MSP430" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "FRE", ":", "return", "\"PPCISD::FRE\"", ";", "case", "PPCISD", "::", "FRSQRTE", ":", "return", "\"PPCISD::FRSQRTE\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "TOC_RESTORE", ":", "return", "\"PPCISD::TOC_RESTORE\"", ";", "case", "PPCISD", "::", "LOAD", ":", "return", "\"PPCISD::LOAD\"", ";", "case", "PPCISD", "::", "LOAD_TOC", ":", "return", "\"PPCISD::LOAD_TOC\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "CALL", ":", "return", "\"PPCISD::CALL\"", ";", "case", "PPCISD", "::", "CALL_NOP", ":", "return", "\"PPCISD::CALL_NOP\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL", ":", "return", "\"PPCISD::BCTRL\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "EH_SJLJ_SETJMP", ":", "return", "\"PPCISD::EH_SJLJ_SETJMP\"", ";", "case", "PPCISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "\"PPCISD::EH_SJLJ_LONGJMP\"", ";", "case", "PPCISD", "::", "MFOCRF", ":", "return", "\"PPCISD::MFOCRF\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "BDNZ", ":", "return", "\"PPCISD::BDNZ\"", ";", "case", "PPCISD", "::", "BDZ", ":", "return", "\"PPCISD::BDZ\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "case", "PPCISD", "::", "CR6SET", ":", "return", "\"PPCISD::CR6SET\"", ";", "case", "PPCISD", "::", "CR6UNSET", ":", "return", "\"PPCISD::CR6UNSET\"", ";", "case", "PPCISD", "::", "ADDIS_TOC_HA", ":", "return", "\"PPCISD::ADDIS_TOC_HA\"", ";", "case", "PPCISD", "::", "LD_TOC_L", ":", "return", "\"PPCISD::LD_TOC_L\"", ";", "case", "PPCISD", "::", "ADDI_TOC_L", ":", "return", "\"PPCISD::ADDI_TOC_L\"", ";", "case", "PPCISD", "::", "PPC32_GOT", ":", "return", "\"PPCISD::PPC32_GOT\"", ";", "case", "PPCISD", "::", "ADDIS_GOT_TPREL_HA", ":", "return", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", ";", "case", "PPCISD", "::", "LD_GOT_TPREL_L", ":", "return", "\"PPCISD::LD_GOT_TPREL_L\"", ";", "case", "PPCISD", "::", "ADD_TLS", ":", "return", "\"PPCISD::ADD_TLS\"", ";", "case", "PPCISD", "::", "ADDIS_TLSGD_HA", ":", "return", "\"PPCISD::ADDIS_TLSGD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSGD_L", ":", "return", "\"PPCISD::ADDI_TLSGD_L\"", ";", "case", "PPCISD", "::", "GET_TLS_ADDR", ":", "return", "\"PPCISD::GET_TLS_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_TLSLD_HA", ":", "return", "\"PPCISD::ADDIS_TLSLD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSLD_L", ":", "return", "\"PPCISD::ADDI_TLSLD_L\"", ";", "case", "PPCISD", "::", "GET_TLSLD_ADDR", ":", "return", "\"PPCISD::GET_TLSLD_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_DTPREL_HA", ":", "return", "\"PPCISD::ADDIS_DTPREL_HA\"", ";", "case", "PPCISD", "::", "ADDI_DTPREL_L", ":", "return", "\"PPCISD::ADDI_DTPREL_L\"", ";", "case", "PPCISD", "::", "VADD_SPLAT", ":", "return", "\"PPCISD::VADD_SPLAT\"", ";", "case", "PPCISD", "::", "SC", ":", "return", "\"PPCISD::SC\"", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::FRE", "\"PPCISD::FRE\"", "PPCISD::FRSQRTE", "\"PPCISD::FRSQRTE\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::TOC_RESTORE", "\"PPCISD::TOC_RESTORE\"", "PPCISD::LOAD", "\"PPCISD::LOAD\"", "PPCISD::LOAD_TOC", "\"PPCISD::LOAD_TOC\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::CALL", "\"PPCISD::CALL\"", "PPCISD::CALL_NOP", "\"PPCISD::CALL_NOP\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL", "\"PPCISD::BCTRL\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::EH_SJLJ_SETJMP", "\"PPCISD::EH_SJLJ_SETJMP\"", "PPCISD::EH_SJLJ_LONGJMP", "\"PPCISD::EH_SJLJ_LONGJMP\"", "PPCISD::MFOCRF", "\"PPCISD::MFOCRF\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::BDNZ", "\"PPCISD::BDNZ\"", "PPCISD::BDZ", "\"PPCISD::BDZ\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"", "PPCISD::CR6SET", "\"PPCISD::CR6SET\"", "PPCISD::CR6UNSET", "\"PPCISD::CR6UNSET\"", "PPCISD::ADDIS_TOC_HA", "\"PPCISD::ADDIS_TOC_HA\"", "PPCISD::LD_TOC_L", "\"PPCISD::LD_TOC_L\"", "PPCISD::ADDI_TOC_L", "\"PPCISD::ADDI_TOC_L\"", "PPCISD::PPC32_GOT", "\"PPCISD::PPC32_GOT\"", "PPCISD::ADDIS_GOT_TPREL_HA", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", "PPCISD::LD_GOT_TPREL_L", "\"PPCISD::LD_GOT_TPREL_L\"", "PPCISD::ADD_TLS", "\"PPCISD::ADD_TLS\"", "PPCISD::ADDIS_TLSGD_HA", "\"PPCISD::ADDIS_TLSGD_HA\"", "PPCISD::ADDI_TLSGD_L", "\"PPCISD::ADDI_TLSGD_L\"", "PPCISD::GET_TLS_ADDR", "\"PPCISD::GET_TLS_ADDR\"", "PPCISD::ADDIS_TLSLD_HA", "\"PPCISD::ADDIS_TLSLD_HA\"", "PPCISD::ADDI_TLSLD_L", "\"PPCISD::ADDI_TLSLD_L\"", "PPCISD::GET_TLSLD_ADDR", "\"PPCISD::GET_TLSLD_ADDR\"", "PPCISD::ADDIS_DTPREL_HA", "\"PPCISD::ADDIS_DTPREL_HA\"", "PPCISD::ADDI_DTPREL_L", "\"PPCISD::ADDI_DTPREL_L\"", "PPCISD::VADD_SPLAT", "\"PPCISD::VADD_SPLAT\"", "PPCISD::SC", "\"PPCISD::SC\"" ]

[]

[ "<s>", "void", "RISCVInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "NoAliases", "||", "!", "printAliasInstr", "(", "MI", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "hasCopyImplyingStackAdjustment", "(", "MF", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", ".", "setHasCopyImplyingStackAdjustment", "(", "true", ")", ";", "}", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "}", "</s>" ]

[ "Execute", "target", "specific", "actions", "to", "finalize", "target", "lowering", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "use_skip_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "jump_insn", "=", "next_active_insn", "(", "JUMP_LABEL", "(", "insn", ")", ")", ";", "while", "(", "insn", ")", "{", "insn", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "extract_asm_operands", "(", "PATTERN", "(", "insn", ")", ")", "!=", "NULL_RTX", ")", "break", ";", "if", "(", "get_attr_length", "(", "insn", ")", "==", "4", "&&", "jump_insn", "==", "next_active_insn", "(", "insn", ")", ")", "return", "TRUE", ";", "if", "(", "get_attr_length", "(", "insn", ")", ">", "0", ")", "break", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "INSN", ",", "a", "forward", "jump", "insn", ",", "can", "use", "nullification", "to", "skip", "the", "following", "instruction", ".", "This", "avoids", "an", "extra", "cycle", "due", "to", "a", "mis-predicted", "branch", "when", "we", "fall", "through", "." ]

[ "pa", "4", "0" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "MipsMCInstLower", "MCInstLowering", "(", "Mang", ",", "*", "MF", ",", "*", "this", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "MCInst", "TmpInst0", ";", "SmallVector", "<", "MCInst", ",", "4", ">", "MCInsts", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst0", ")", ";", "if", "(", "!", "OutStreamer", ".", "hasRawTextSupport", "(", ")", "&&", "isDirective", "(", "Opc", ")", ")", "return", ";", "if", "(", "isUnalignedLoadStore", "(", "Opc", ")", ")", "{", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "MCInst", "Directive", ";", "Directive", ".", "setOpcode", "(", "Mips", "::", "MACRO", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "Directive", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "Directive", ".", "setOpcode", "(", "Mips", "::", "NOMACRO", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "Directive", ")", ";", "}", "else", "{", "MCInstLowering", ".", "LowerUnalignedLoadStore", "(", "MI", ",", "MCInsts", ")", ";", "for", "(", "SmallVector", "<", "MCInst", ",", "4", ">", "::", "iterator", "I", "=", "MCInsts", ".", "begin", "(", ")", ";", "I", "!=", "MCInsts", ".", "end", "(", ")", ";", "++", "I", ")", "OutStreamer", ".", "EmitInstruction", "(", "*", "I", ")", ";", "}", "return", ";", "}", "if", "(", "!", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "if", "(", "Opc", "==", "Mips", "::", "CPLOAD", ")", "{", "MCInstLowering", ".", "LowerCPLOAD", "(", "MI", ",", "MCInsts", ")", ";", "for", "(", "SmallVector", "<", "MCInst", ",", "4", ">", "::", "iterator", "I", "=", "MCInsts", ".", "begin", "(", ")", ";", "I", "!=", "MCInsts", ".", "end", "(", ")", ";", "++", "I", ")", "OutStreamer", ".", "EmitInstruction", "(", "*", "I", ")", ";", "return", ";", "}", "if", "(", "Opc", "==", "Mips", "::", "CPRESTORE", ")", "{", "MCInstLowering", ".", "LowerCPRESTORE", "(", "MI", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "return", ";", "}", "}", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "128", "Mips", "4", "Mips::MACRO", "Mips::NOMACRO", "4", "Mips::CPLOAD", "4", "Mips::CPRESTORE" ]

[]

[ "<s>", "const", "uint16_t", "*", "BPFRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_SaveList", ";", "}", "</s>" ]

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

[ "BPF", "BPF" ]

[]

[ "<s>", "rtx", "msp430_subreg", "(", "machine_mode", "mode", ",", "rtx", "r", ",", "machine_mode", "omode", ",", "int", "byte", ")", "{", "rtx", "rv", ";", "if", "(", "GET_CODE", "(", "r", ")", "==", "SUBREG", "&&", "SUBREG_BYTE", "(", "r", ")", "==", "0", ")", "{", "rtx", "ireg", "=", "SUBREG_REG", "(", "r", ")", ";", "machine_mode", "imode", "=", "GET_MODE", "(", "ireg", ")", ";", "if", "(", "imode", "==", "PSImode", "&&", "mode", "==", "HImode", "&&", "byte", "==", "0", ")", "rv", "=", "gen_rtx_SUBREG", "(", "mode", ",", "ireg", ",", "byte", ")", ";", "else", "rv", "=", "simplify_gen_subreg", "(", "mode", ",", "ireg", ",", "imode", ",", "byte", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "r", ")", "==", "MEM", ")", "rv", "=", "adjust_address", "(", "r", ",", "mode", ",", "byte", ")", ";", "else", "if", "(", "GET_CODE", "(", "r", ")", "==", "SYMBOL_REF", "&&", "(", "byte", "==", "0", "||", "byte", "==", "2", ")", "&&", "mode", "==", "HImode", ")", "{", "rv", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "8", "*", "byte", ")", ")", ";", "rv", "=", "gen_rtx_CONST", "(", "HImode", ",", "r", ")", ";", "}", "else", "rv", "=", "simplify_gen_subreg", "(", "mode", ",", "r", ",", "omode", ",", "byte", ")", ";", "if", "(", "!", "rv", ")", "gcc_unreachable", "(", ")", ";", "return", "rv", ";", "}", "</s>" ]

[ "Simplify_gen_subreg", "(", ")", "does", "n't", "handle", "memory", "references", "the", "way", "we", "need", "it", "to", "below", ",", "so", "we", "use", "this", "function", "for", "when", "we", "must", "get", "a", "valid", "subreg", "in", "a", "``", "natural", "''", "state", "." ]

[ "msp430", "0", "0", "0", "2", "16", "8" ]

[]

[ "<s>", "bool", "HexagonRDFOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "RDFLimit", ".", "getPosition", "(", ")", ")", "{", "if", "(", "RDFCount", ">=", "RDFLimit", ")", "return", "false", ";", "RDFCount", "++", ";", "}", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "const", "auto", "&", "HII", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "HexagonRegisterAliasInfo", "HAI", "(", "HRI", ")", ";", "TargetOperandInfo", "TOI", "(", "HII", ")", ";", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "\"\\n\"", ",", "nullptr", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "HII", ",", "HRI", ",", "*", "MDT", ",", "MDF", ",", "HAI", ",", "TOI", ")", ";", "G", ".", "build", "(", ")", ";", "if", "(", "RDFDump", ")", "{", "dbgs", "(", ")", "<<", "PrintNode", "<", "FuncNode", "*", ">", "(", "G", ".", "getFunc", "(", ")", ",", "G", ")", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", "bool", "Changed", ";", "CopyPropagation", "CP", "(", "G", ")", ";", "CP", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "=", "CP", ".", "run", "(", ")", ";", "if", "(", "Changed", ")", "G", ".", "build", "(", ")", ";", "HexagonDCE", "DCE", "(", "G", ",", "*", "MRI", ")", ";", "DCE", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "|=", "DCE", ".", "run", "(", ")", ";", "if", "(", "Changed", ")", "{", "Liveness", "LV", "(", "*", "MRI", ",", "G", ")", ";", "LV", ".", "trace", "(", "RDFDump", ")", ";", "LV", ".", "computeLiveIns", "(", ")", ";", "LV", ".", "resetLiveIns", "(", ")", ";", "LV", ".", "resetKills", "(", ")", ";", "}", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "\"\\n\"", ",", "nullptr", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Before \"", "\"\\n\"", "Hexagon", "\"After \"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "AI", ")", ")", "return", "0", ";", "MVT", "VT", ";", "if", "(", "!", "isLoadTypeLegal", "(", "AI", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI8", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "0", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "0", "PPC::G8RC_and_G8RC_NOX0RegClass", "PPC::ADDI8", "0", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_real_tls_symbol_ref_p", "(", "rtx", "x", ")", "{", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ">=", "TLS_MODEL_REAL", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "symbol", "that", "refers", "to", "real", "(", "rather", "than", "emulated", ")", "TLS", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "rs6000_emit_int_cmove", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "rtx", "condition_rtx", ",", "cr", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "enum", "rtx_code", "cond_code", ";", "rtx", "(", "*", "isel_func", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "bool", "signedp", ";", "if", "(", "mode", "!=", "SImode", "&&", "(", "!", "TARGET_POWERPC64", "||", "mode", "!=", "DImode", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", ")", "==", "MODE_CC", ")", "return", "false", ";", "condition_rtx", "=", "rs6000_generate_compare", "(", "op", ",", "mode", ")", ";", "cond_code", "=", "GET_CODE", "(", "condition_rtx", ")", ";", "cr", "=", "XEXP", "(", "condition_rtx", ",", "0", ")", ";", "signedp", "=", "GET_MODE", "(", "cr", ")", "==", "CCmode", ";", "isel_func", "=", "(", "mode", "==", "SImode", "?", "(", "signedp", "?", "gen_isel_signed_si", ":", "gen_isel_unsigned_si", ")", ":", "(", "signedp", "?", "gen_isel_signed_di", ":", "gen_isel_unsigned_di", ")", ")", ";", "switch", "(", "cond_code", ")", "{", "case", "LT", ":", "case", "GT", ":", "case", "LTU", ":", "case", "GTU", ":", "case", "EQ", ":", "break", ";", "default", ":", "{", "std", "::", "swap", "(", "false_cond", ",", "true_cond", ")", ";", "PUT_CODE", "(", "condition_rtx", ",", "reverse_condition", "(", "cond_code", ")", ")", ";", "}", "break", ";", "}", "false_cond", "=", "force_reg", "(", "mode", ",", "false_cond", ")", ";", "if", "(", "true_cond", "!=", "const0_rtx", ")", "true_cond", "=", "force_reg", "(", "mode", ",", "true_cond", ")", ";", "emit_insn", "(", "isel_func", "(", "dest", ",", "condition_rtx", ",", "true_cond", ",", "false_cond", ",", "cr", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Same", "as", "above", ",", "but", "for", "ints", "(", "isel", ")", "." ]

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

[]

[ "<s>", "static", "int", "ix86_mode_after", "(", "int", "entity", ",", "int", "mode", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "mode", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_after", "(", "mode", ",", "insn", ")", ";", "case", "I387_ROUNDEVEN", ":", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "mode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "mode", "that", "an", "insn", "results", "in", "." ]

[ "i386" ]

[]

[ "<s>", "enum", "mips_loadgp_style", "mips_current_loadgp_style", "(", "void", ")", "{", "if", "(", "!", "TARGET_USE_GOT", "||", "cfun", "->", "machine", "->", "global_pointer", "==", "INVALID_REGNUM", ")", "return", "LOADGP_NONE", ";", "if", "(", "TARGET_RTP_PIC", ")", "return", "LOADGP_RTP", ";", "if", "(", "TARGET_ABSOLUTE_ABICALLS", ")", "return", "LOADGP_ABSOLUTE", ";", "return", "TARGET_NEWABI", "?", "LOADGP_NEWABI", ":", "LOADGP_OLDABI", ";", "}", "</s>" ]

[ "Return", "the", "style", "of", "GP", "load", "sequence", "that", "is", "being", "used", "for", "the", "current", "function", "." ]

[ "mips" ]

[]

[ "<s>", "void", "aarch64_final_prescan_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "aarch64_madd_needs_nop", "(", "insn", ")", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tnop // between mem op and mult-accumulate\\n\"", ")", ";", "}", "</s>" ]

[ "Implement", "FINAL_PRESCAN_INSN", "." ]

[ "aarch64", "\"\\tnop // between mem op and mult-accumulate\\n\"" ]

[]

[ "<s>", "int", "arm_split_constant", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ",", "rtx", "insn", ",", "HOST_WIDE_INT", "val", ",", "rtx", "target", ",", "rtx", "source", ",", "int", "subtargets", ")", "{", "rtx", "cond", ";", "if", "(", "insn", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COND_EXEC", ")", "cond", "=", "COND_EXEC_TEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "else", "cond", "=", "NULL_RTX", ";", "if", "(", "subtargets", "||", "code", "==", "SET", "||", "(", "GET_CODE", "(", "target", ")", "==", "REG", "&&", "GET_CODE", "(", "source", ")", "==", "REG", "&&", "REGNO", "(", "target", ")", "!=", "REGNO", "(", "source", ")", ")", ")", "{", "if", "(", "!", "after_arm_reorg", "&&", "!", "cond", "&&", "(", "arm_gen_constant", "(", "code", ",", "mode", ",", "NULL_RTX", ",", "val", ",", "target", ",", "source", ",", "1", ",", "0", ")", ">", "arm_constant_limit", "+", "(", "code", "!=", "SET", ")", ")", ")", "{", "if", "(", "code", "==", "SET", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "GEN_INT", "(", "val", ")", ")", ")", ";", "return", "1", ";", "}", "else", "{", "rtx", "temp", "=", "subtargets", "?", "gen_reg_rtx", "(", "mode", ")", ":", "target", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "GEN_INT", "(", "val", ")", ")", ")", ";", "if", "(", "code", "==", "MINUS", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "gen_rtx_MINUS", "(", "mode", ",", "temp", ",", "source", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "source", ",", "temp", ")", ")", ")", ";", "return", "2", ";", "}", "}", "}", "return", "arm_gen_constant", "(", "code", ",", "mode", ",", "cond", ",", "val", ",", "target", ",", "source", ",", "subtargets", ",", "1", ")", ";", "}", "</s>" ]

[ "Emit", "a", "sequence", "of", "insns", "to", "handle", "a", "large", "constant", ".", "CODE", "is", "the", "code", "of", "the", "operation", "required", ",", "it", "can", "be", "any", "of", "SET", ",", "PLUS", ",", "IOR", ",", "AND", ",", "XOR", ",", "MINUS", ";", "MODE", "is", "the", "mode", "in", "which", "the", "operation", "is", "being", "performed", ";", "VAL", "is", "the", "integer", "to", "operate", "on", ";", "SOURCE", "is", "the", "other", "operand", "(", "a", "register", ",", "or", "a", "null-pointer", "for", "SET", ")", ";", "SUBTARGETS", "means", "it", "is", "safe", "to", "create", "scratch", "registers", "if", "that", "will", "either", "produce", "a", "simpler", "sequence", ",", "or", "we", "will", "want", "to", "cse", "the", "values", ".", "Return", "value", "is", "the", "number", "of", "insns", "emitted", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"LC3b DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "LC3b", "\"LC3b DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createX86LowerAMXIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createX86LowerAMXTypePass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createX86PreAMXConfigPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "addPass", "(", "createX86PartialReductionPass", "(", ")", ")", ";", "}", "addPass", "(", "createIndirectBrExpandPass", "(", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "{", "addPass", "(", "createCFGuardDispatchPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "set_src_needs_barrier", "(", "rtx", "x", ",", "struct", "reg_flags", "flags", ",", "int", "pred", ")", "{", "int", "need_barrier", "=", "0", ";", "rtx", "dst", ";", "rtx", "src", "=", "SET_SRC", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CALL", ")", "return", "rtx_needs_barrier", "(", "src", ",", "flags", ",", "pred", ")", ";", "else", "if", "(", "SET_DEST", "(", "x", ")", "==", "pc_rtx", ")", "{", "if", "(", "!", "ia64_spec_check_src_p", "(", "src", ")", ")", "flags", ".", "is_branch", "=", "1", ";", "return", "rtx_needs_barrier", "(", "src", ",", "flags", ",", "pred", ")", ";", "}", "if", "(", "ia64_spec_check_src_p", "(", "src", ")", ")", "{", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "src", ",", "2", ")", ")", ")", ";", "need_barrier", "=", "rtx_needs_barrier", "(", "XEXP", "(", "src", ",", "2", ")", ",", "flags", ",", "pred", ")", ";", "src", "=", "XEXP", "(", "src", ",", "1", ")", ";", "}", "need_barrier", "|=", "rtx_needs_barrier", "(", "src", ",", "flags", ",", "pred", ")", ";", "dst", "=", "SET_DEST", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "ZERO_EXTRACT", ")", "{", "need_barrier", "|=", "rtx_needs_barrier", "(", "XEXP", "(", "dst", ",", "1", ")", ",", "flags", ",", "pred", ")", ";", "need_barrier", "|=", "rtx_needs_barrier", "(", "XEXP", "(", "dst", ",", "2", ")", ",", "flags", ",", "pred", ")", ";", "}", "return", "need_barrier", ";", "}", "</s>" ]

[ "Subroutine", "of", "rtx_needs_barrier", ";", "this", "function", "determines", "whether", "the", "source", "of", "a", "given", "SET", "rtx", "found", "in", "X", "needs", "a", "barrier", ".", "FLAGS", "and", "PRED", "are", "as", "in", "rtx_needs_barrier", ".", "COND", "is", "an", "rtx", "that", "holds", "the", "condition", "for", "this", "insn", "." ]

[ "ia64", "0", "1", "2", "2", "1", "1", "2" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "Hexagon", "::", "ArchEnum", ">", "CpuTable", "{", "{", "\"generic\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv5\"", ",", "Hexagon", "::", "ArchEnum", "::", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "Hexagon", "::", "ArchEnum", "::", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv62\"", ",", "Hexagon", "::", "ArchEnum", "::", "V62", "}", ",", "{", "\"hexagonv65\"", ",", "Hexagon", "::", "ArchEnum", "::", "V65", "}", ",", "{", "\"hexagonv66\"", ",", "Hexagon", "::", "ArchEnum", "::", "V66", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "set", "(", "Hexagon", "::", "FeatureDuplex", ",", "false", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "\"generic\"", "Hexagon::ArchEnum", "\"hexagonv5\"", "Hexagon::ArchEnum", "\"hexagonv55\"", "Hexagon::ArchEnum", "\"hexagonv60\"", "Hexagon::ArchEnum", "\"hexagonv62\"", "Hexagon::ArchEnum", "\"hexagonv65\"", "Hexagon::ArchEnum", "\"hexagonv66\"", "Hexagon::ArchEnum", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

[ "<s>", "CCAssignFn", "*", "AMDGPUTargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "{", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "return", "CC_AMDGPU_Kernel", ";", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "return", "CC_AMDGPU", ";", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "\"Unsupported calling convention.\"" ]

[]

[ "<s>", "static", "tree", "csky_handle_isr_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "!", "TARGET_ISTACK", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored without %<-mistack%>\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "else", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "*", "node", ")", "==", "METHOD_TYPE", ")", "{", "if", "(", "csky_isr_value", "(", "args", ")", "==", "CSKY_FT_UNKNOWN", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "else", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "POINTER_TYPE", "&&", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "METHOD_TYPE", ")", "&&", "csky_isr_value", "(", "args", ")", "!=", "CSKY_FT_UNKNOWN", ")", "{", "*", "node", "=", "build_variant_type_copy", "(", "*", "node", ")", ";", "TREE_TYPE", "(", "*", "node", ")", "=", "build_type_attribute_variant", "(", "TREE_TYPE", "(", "*", "node", ")", ",", "tree_cons", "(", "name", ",", "args", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "flags", "&", "(", "(", "int", ")", "ATTR_FLAG_DECL_NEXT", "|", "(", "int", ")", "ATTR_FLAG_FUNCTION_NEXT", "|", "(", "int", ")", "ATTR_FLAG_ARRAY_NEXT", ")", ")", "{", "*", "no_add_attrs", "=", "true", ";", "return", "tree_cons", "(", "name", ",", "args", ",", "NULL_TREE", ")", ";", "}", "else", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored\"", ",", "name", ")", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt", "''", "or", "``", "isr", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "csky", "\"%qE attribute ignored without %<-mistack%>\"", "\"%qE attribute only applies to functions\"", "\"%qE attribute ignored\"", "\"%qE attribute ignored\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "X86", "::", "SUB64rm", ":", "case", "X86", "::", "SUB32rm", ":", "case", "X86", "::", "SUB16rm", ":", "case", "X86", "::", "SUB8rm", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64rr", ":", "case", "X86", "::", "SUB32rr", ":", "case", "X86", "::", "SUB16rr", ":", "case", "X86", "::", "SUB8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "SUB64ri8", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB32ri8", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB16ri8", ":", "case", "X86", "::", "SUB8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "X86", "::", "CMP64rr", ":", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP16rr", ":", "case", "X86", "::", "CMP8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "TEST8rr", ":", "case", "X86", "::", "TEST16rr", ":", "case", "X86", "::", "TEST32rr", ":", "case", "X86", "::", "TEST64rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "SrcReg", ")", "return", "false", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::CMP64ri32", "X86::CMP64ri8", "X86::CMP32ri", "X86::CMP32ri8", "X86::CMP16ri", "X86::CMP16ri8", "X86::CMP8ri", "0", "0", "0", "1", "X86::SUB64rm", "X86::SUB32rm", "X86::SUB16rm", "X86::SUB8rm", "1", "0", "0", "0", "X86::SUB64rr", "X86::SUB32rr", "X86::SUB16rr", "X86::SUB8rr", "1", "2", "0", "0", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "X86::SUB16ri", "X86::SUB16ri8", "X86::SUB8ri", "1", "0", "0", "2", "X86::CMP64rr", "X86::CMP32rr", "X86::CMP16rr", "X86::CMP8rr", "0", "1", "0", "0", "X86::TEST8rr", "X86::TEST16rr", "X86::TEST32rr", "X86::TEST64rr", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "or1k_compute_frame_layout", "(", "void", ")", "{", "HOST_WIDE_INT", "local_vars_size", ",", "args_size", ",", "save_reg_size", ";", "local_vars_size", "=", "get_frame_size", "(", ")", ";", "local_vars_size", "=", "ROUND_UP", "(", "local_vars_size", ",", "UNITS_PER_WORD", ")", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "args_size", "=", "ROUND_UP", "(", "args_size", ",", "UNITS_PER_WORD", ")", ";", "save_reg_size", "=", "0", ";", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "callee_saved_regno_p", "(", "regno", ")", ")", "save_reg_size", "+=", "UNITS_PER_WORD", ";", "cfun", "->", "machine", "->", "local_vars_size", "=", "local_vars_size", ";", "cfun", "->", "machine", "->", "args_size", "=", "args_size", ";", "cfun", "->", "machine", "->", "callee_saved_reg_size", "=", "save_reg_size", ";", "cfun", "->", "machine", "->", "total_size", "=", "save_reg_size", "+", "local_vars_size", "+", "args_size", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_COMPUTE_FRAME_LAYOUT", ".", "Compute", "and", "populate", "machine", "specific", "function", "attributes", "which", "are", "globally", "accessible", "via", "cfun-", ">", "machine", ".", "These", "include", "the", "sizes", "needed", "for", "stack", "stored", "local", "variables", ",", "callee", "saved", "registers", "and", "space", "for", "stack", "arguments", "which", "may", "be", "passed", "to", "a", "next", "function", ".", "The", "values", "are", "used", "for", "the", "epilogue", ",", "prologue", "and", "eliminations", ".", "OpenRISC", "stack", "grows", "downwards", "and", "contains", ":", "--", "--", "previous", "frame", "--", "--", "--", "--", "current", "func", "arg", "[", "n", "]", "current", "func", "arg", "[", "0", "]", "<", "--", "r2", "[", "HFP", ",", "AP", "]", "--", "--", "current", "stack", "frame", "--", "-", "^", "--", "-\\", "return", "address", "r9", "|", "|", "old", "frame", "pointer", "r2", "(", "+", ")", "|", "--", "machine-", ">", "total_size", "callee", "saved", "regs", "|", "|", ">", "machine-", ">", "callee_saved_reg_size", "local", "variables", "|", "|", ">", "machine-", ">", "local_vars_size", "<", "-FP", "next", "function", "args", "<", "--", "r1", "[", "SP", "]", "--", "-/", ">", "machine-", ">", "args_size", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "|", "(", "-", ")", "(", "future", ")", "|", "V", "All", "of", "these", "contents", "are", "optional", "." ]

[ "or1k", "0", "0" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "unsigned", "Alignment", ")", "{", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "\"Unexpected data type for Gather/Scatter\"", ")", ";", "unsigned", "VF", "=", "SrcVTy", "->", "getVectorNumElements", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "\"Unexpected type for Ptr argument\"", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "bool", "Scalarize", "=", "false", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "!", "isLegalMaskedGather", "(", "SrcVTy", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "!", "isLegalMaskedScatter", "(", "SrcVTy", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "VF", "==", "2", "||", "(", "VF", "==", "4", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "Scalarize", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "X86", "X86", "\"Unexpected data type for Gather/Scatter\"", "\"Unexpected type for Ptr argument\"", "2", "4" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "MF", "=", "&", "Func", ";", "const", "X86Subtarget", "&", "ST", "=", "Func", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "LEAusesAG", "(", ")", "&&", "!", "ST", ".", "slowLEA", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "Func", ".", "begin", "(", ")", ",", "E", "=", "Func", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "Func", ",", "I", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ")", "return", "false", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "&", "ST", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "const", "MachineOperand", "*", "BaseOp", ";", "int64_t", "Offset", ";", "bool", "OffsetIsScalable", ";", "if", "(", "TII", "->", "getMemOperandWithOffset", "(", "MI", ",", "BaseOp", ",", "Offset", ",", "OffsetIsScalable", ",", "TRI", ")", "&&", "BaseOp", "->", "isReg", "(", ")", ")", "{", "Register", "BaseReg", "=", "BaseOp", "->", "getReg", "(", ")", ";", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "return", "LowerCTTZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "return", "LowerCTTZ_ZERO_UNDEF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SUBE", ":", "return", "LowerSUBE", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "OR1K", "OR1K", "ISD::BR_CC", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC", "ISD::CTTZ", "ISD::CTTZ_ZERO_UNDEF", "ISD::CTLZ", "ISD::CTLZ_ZERO_UNDEF", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::SUBE", "\"unimplemented operand\"" ]

[]

[ "<s>", "void", "MipsOutgoingValueHandler", "::", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "{", "Register", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ExtReg", ")", ";", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "SystemZDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SystemZAddressingMode", "::", "AddrForm", "Form", ";", "SystemZAddressingMode", "::", "DispRange", "DispRange", ";", "SDValue", "Base", ",", "Disp", ",", "Index", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_R", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_S", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_T", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "}", "if", "(", "selectBDXAddr", "(", "Form", ",", "DispRange", ",", "Op", ",", "Base", ",", "Disp", ",", "Index", ")", ")", "{", "const", "TargetRegisterClass", "*", "TRC", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "*", "MF", ")", ";", "SDLoc", "DL", "(", "Base", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Base", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetFrameIndex", "&&", "Base", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "Register", ")", "{", "Base", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "DL", ",", "Base", ".", "getValueType", "(", ")", ",", "Base", ",", "RC", ")", ",", "0", ")", ";", "}", "if", "(", "Index", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "Register", ")", "{", "Index", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "DL", ",", "Index", ".", "getValueType", "(", ")", ",", "Index", ",", "RC", ")", ",", "0", ")", ";", "}", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Disp", ")", ";", "OutOps", ".", "push_back", "(", "Index", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZAddressingMode::AddrForm", "SystemZAddressingMode::DispRange", "\"Unexpected asm memory constraint\"", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp20Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp20Only", "MVT::i32", "ISD::TargetFrameIndex", "ISD::Register", "0", "ISD::Register", "0" ]

[]

[ "<s>", "void", "MipsInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Mips", "::", "RDHWR", ":", "case", "Mips", "::", "RDHWR64", ":", "O", "<<", "\"\\t.set\\tpush\\n\"", ";", "O", "<<", "\"\\t.set\\tmips32r2\\n\"", ";", "break", ";", "case", "Mips", "::", "Save16", ":", "O", "<<", "\"\\tsave\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\" # 16 bit inst\\n\"", ";", "return", ";", "case", "Mips", "::", "SaveX16", ":", "O", "<<", "\"\\tsave\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\"\\n\"", ";", "return", ";", "case", "Mips", "::", "Restore16", ":", "O", "<<", "\"\\trestore\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\" # 16 bit inst\\n\"", ";", "return", ";", "case", "Mips", "::", "RestoreX16", ":", "O", "<<", "\"\\trestore\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\"\\n\"", ";", "return", ";", "}", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", "&&", "!", "printAlias", "(", "*", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Mips", "::", "RDHWR", ":", "case", "Mips", "::", "RDHWR64", ":", "O", "<<", "\"\\n\\t.set\\tpop\"", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::RDHWR", "Mips::RDHWR64", "\"\\t.set\\tpush\\n\"", "\"\\t.set\\tmips32r2\\n\"", "Mips::Save16", "\"\\tsave\\t\"", "\" # 16 bit inst\\n\"", "Mips::SaveX16", "\"\\tsave\\t\"", "\"\\n\"", "Mips::Restore16", "\"\\trestore\\t\"", "\" # 16 bit inst\\n\"", "Mips::RestoreX16", "\"\\trestore\\t\"", "\"\\n\"", "Mips::RDHWR", "Mips::RDHWR64", "\"\\n\\t.set\\tpop\"" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "switch", "(", "Subtarget", ".", "getDarwinDirective", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "case", "PPC", "::", "DIR_PWR8", ":", "case", "PPC", "::", "DIR_PWR9", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "0", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "J", "=", "(", "*", "I", ")", "->", "begin", "(", ")", ",", "JE", "=", "(", "*", "I", ")", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "{", "LoopSize", "+=", "TII", "->", "GetInstSizeInBytes", "(", "*", "J", ")", ";", "if", "(", "LoopSize", ">", "32", ")", "break", ";", "}", "if", "(", "LoopSize", ">", "16", "&&", "LoopSize", "<=", "32", ")", "return", "5", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "PowerPC", "PPC", "PPC::DIR_970", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "PPC", "0", "32", "16", "32", "5" ]

[]

[ "<s>", "VSETVLIInfo", "merge", "(", "const", "VSETVLIInfo", "&", "Other", ")", "const", "{", "assert", "(", "isValid", "(", ")", "&&", "\"Can only merge with a valid VSETVLInfo\"", ")", ";", "if", "(", "!", "Other", ".", "isValid", "(", ")", ")", "return", "*", "this", ";", "if", "(", "isCompatible", "(", "Other", ")", ")", "return", "*", "this", ";", "return", "Other", ";", "}", "</s>" ]

[ "Merge", "target", "triples", "." ]

[ "RISCV", "\"Can only merge with a valid VSETVLInfo\"" ]

[]

[ "<s>", "static", "bool", "convertible_comparison_p", "(", "rtx_insn", "*", "insn", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_64BIT", "||", "mode", "!=", "DImode", ")", "return", "false", ";", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "def_set", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "def_set", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "src", ")", "==", "COMPARE", ")", ";", "if", "(", "GET_CODE", "(", "dst", ")", "!=", "REG", "||", "REGNO", "(", "dst", ")", "!=", "FLAGS_REG", "||", "GET_MODE", "(", "dst", ")", "!=", "CCZmode", ")", "return", "false", ";", "rtx", "op1", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "op2", "=", "XEXP", "(", "src", ",", "1", ")", ";", "if", "(", "op2", "!=", "CONST0_RTX", "(", "GET_MODE", "(", "op2", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "IOR", ")", "return", "false", ";", "op2", "=", "XEXP", "(", "op1", ",", "1", ")", ";", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "if", "(", "!", "SUBREG_P", "(", "op1", ")", "||", "!", "SUBREG_P", "(", "op2", ")", "||", "GET_MODE", "(", "op1", ")", "!=", "SImode", "||", "GET_MODE", "(", "op2", ")", "!=", "SImode", "||", "(", "(", "SUBREG_BYTE", "(", "op1", ")", "!=", "0", "||", "SUBREG_BYTE", "(", "op2", ")", "!=", "GET_MODE_SIZE", "(", "SImode", ")", ")", "&&", "(", "SUBREG_BYTE", "(", "op2", ")", "!=", "0", "||", "SUBREG_BYTE", "(", "op1", ")", "!=", "GET_MODE_SIZE", "(", "SImode", ")", ")", ")", ")", "return", "false", ";", "op1", "=", "SUBREG_REG", "(", "op1", ")", ";", "op2", "=", "SUBREG_REG", "(", "op2", ")", ";", "if", "(", "op1", "!=", "op2", "||", "!", "REG_P", "(", "op1", ")", "||", "GET_MODE", "(", "op1", ")", "!=", "DImode", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "comparison", "INSN", "may", "be", "transformed", "into", "vector", "comparison", ".", "Currently", "we", "transform", "equality/inequality", "checks", "which", "look", "like", ":", "(", "set", "(", "reg", ":", "CCZ", "17", "flags", ")", "(", "compare", ":", "CCZ", "(", "reg", ":", "TI", "x", ")", "(", "reg", ":", "TI", "y", ")", ")", ")" ]

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

[]

[ "<s>", "void", "m32c_emit_epilogue", "(", "void", ")", "{", "int", "popm_count", "=", "m32c_pushm_popm", "(", "PP_justcount", ")", ";", "if", "(", "popm_count", ">", "0", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", "emit_insn", "(", "gen_epilogue_start", "(", ")", ")", ";", "if", "(", "popm_count", ">", "0", ")", "m32c_pushm_popm", "(", "PP_popm", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "{", "machine_mode", "spmode", "=", "TARGET_A16", "?", "HImode", ":", "PSImode", ";", "if", "(", "!", "cfun", "->", "machine", "->", "use_rts", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "spmode", ",", "A0_REGNO", ")", ",", "gen_rtx_REG", "(", "spmode", ",", "FP_REGNO", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "spmode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "spmode", ",", "A0_REGNO", ")", ")", ";", "if", "(", "TARGET_A16", ")", "emit_insn", "(", "gen_pophi_16", "(", "gen_rtx_REG", "(", "HImode", ",", "FP_REGNO", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_poppsi", "(", "gen_rtx_REG", "(", "PSImode", ",", "FP_REGNO", ")", ")", ")", ";", "}", "if", "(", "!", "bank_switch_p", "(", "cfun", "->", "decl", ")", "&&", "cfun", "->", "machine", "->", "intr_pushm", ")", "emit_insn", "(", "gen_popm", "(", "GEN_INT", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", ")", ")", ";", "if", "(", "fast_interrupt_p", "(", "cfun", "->", "decl", ")", ")", "{", "if", "(", "TARGET_A24", ")", "{", "emit_jump_insn", "(", "gen_epilogue_freit", "(", ")", ")", ";", "}", "else", "{", "warning", "(", "OPT_Wattributes", ",", "\"%<fast_interrupt%> attribute directive ignored\"", ")", ";", "emit_jump_insn", "(", "gen_epilogue_reit_16", "(", ")", ")", ";", "}", "}", "else", "if", "(", "TARGET_A16", ")", "emit_jump_insn", "(", "gen_epilogue_reit_16", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_epilogue_reit_24", "(", ")", ")", ";", "}", "else", "if", "(", "cfun", "->", "machine", "->", "use_rts", ")", "emit_jump_insn", "(", "gen_epilogue_rts", "(", ")", ")", ";", "else", "if", "(", "TARGET_A16", ")", "emit_jump_insn", "(", "gen_epilogue_exitd_16", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_epilogue_exitd_24", "(", ")", ")", ";", "}", "</s>" ]

[ "Likewise", ",", "for", "the", "epilogue", ".", "The", "only", "exception", "is", "that", ",", "for", "interrupts", ",", "we", "must", "manually", "unwind", "the", "frame", "as", "the", "REIT", "opcode", "does", "n't", "do", "that", "." ]

[ "m32c", "0", "0", "\"%<fast_interrupt%> attribute directive ignored\"" ]

[]

[ "<s>", "bool", "AArch64LoadStoreOpt", "::", "isCandidateToMergeOrPair", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "!", "getLdStOffsetOp", "(", "MI", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "unsigned", "BaseReg", "=", "getLdStBaseOp", "(", "MI", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", "->", "modifiesRegister", "(", "BaseReg", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "TII", "->", "isLdStPairSuppressed", "(", "MI", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "load/store", "that", "can", "be", "potentially", "paired/merged", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "SDNode", "*", "getInt64", "(", "SelectionDAG", "*", "CurDAG", ",", "const", "SDLoc", "&", "dl", ",", "int64_t", "Imm", ")", "{", "unsigned", "Count", "=", "getInt64CountDirect", "(", "Imm", ")", ";", "if", "(", "Count", "==", "1", ")", "return", "getInt64Direct", "(", "CurDAG", ",", "dl", ",", "Imm", ")", ";", "unsigned", "RMin", "=", "0", ";", "int64_t", "MatImm", ";", "unsigned", "MaskEnd", ";", "for", "(", "unsigned", "r", "=", "1", ";", "r", "<", "63", ";", "++", "r", ")", "{", "uint64_t", "RImm", "=", "Rot64", "(", "Imm", ",", "r", ")", ";", "unsigned", "RCount", "=", "getInt64CountDirect", "(", "RImm", ")", "+", "1", ";", "if", "(", "RCount", "<", "Count", ")", "{", "Count", "=", "RCount", ";", "RMin", "=", "r", ";", "MatImm", "=", "RImm", ";", "MaskEnd", "=", "63", ";", "}", "unsigned", "LS", "=", "findLastSet", "(", "RImm", ")", ";", "if", "(", "LS", "!=", "r", "-", "1", ")", "continue", ";", "uint64_t", "OnesMask", "=", "-", "(", "int64_t", ")", "(", "UINT64_C", "(", "1", ")", "<<", "(", "LS", "+", "1", ")", ")", ";", "uint64_t", "RImmWithOnes", "=", "RImm", "|", "OnesMask", ";", "RCount", "=", "getInt64CountDirect", "(", "RImmWithOnes", ")", "+", "1", ";", "if", "(", "RCount", "<", "Count", ")", "{", "Count", "=", "RCount", ";", "RMin", "=", "r", ";", "MatImm", "=", "RImmWithOnes", ";", "MaskEnd", "=", "LS", ";", "}", "}", "if", "(", "!", "RMin", ")", "return", "getInt64Direct", "(", "CurDAG", ",", "dl", ",", "Imm", ")", ";", "auto", "getI32Imm", "=", "[", "CurDAG", ",", "dl", "]", "(", "unsigned", "Imm", ")", "{", "return", "CurDAG", "->", "getTargetConstant", "(", "Imm", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "}", ";", "SDValue", "Val", "=", "SDValue", "(", "getInt64Direct", "(", "CurDAG", ",", "dl", ",", "MatImm", ")", ",", "0", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "RLDICR", ",", "dl", ",", "MVT", "::", "i64", ",", "Val", ",", "getI32Imm", "(", "64", "-", "RMin", ")", ",", "getI32Imm", "(", "MaskEnd", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "constant", "64-bit", "value", "." ]

[ "PowerPC", "1", "0", "1", "63", "1", "63", "1", "1", "1", "1", "MVT::i32", "0", "PPC::RLDICR", "MVT::i64", "64" ]

[]

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

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

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

[]