Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "mips_cprestore_address_p", "(", "rtx", "x", ",", "bool", "load_p", ")", "{", "rtx", "given_base", ",", "required_base", ";", "HOST_WIDE_INT", "given_offset", ",", "required_offset", ";", "mips_split_plus", "(", "x", ",", "&", "given_base", ",", "&", "given_offset", ")", ";", "mips_get_cprestore_base_and_offset", "(", "&", "required_base", ",", "&", "required_offset", ",", "load_p", ")", ";", "return", "given_base", "==", "required_base", "&&", "given_offset", "==", "required_offset", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "the", "load", "or", "store", "address", "of", "the", "cprestore", "slot", ";", "LOAD_P", "says", "which", "." ]

[ "mips" ]

[]

[ "<s>", "aarch64_print_operand_address", "(", "STREAM", ",", "X", ")", "{", "\\", "rtx", "fun", ",", "lr", ";", "\\", "lr", "=", "get_hard_reg_initial_val", "(", "Pmode", ",", "LR_REGNUM", ")", ";", "\\", "fun", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "MCOUNT_NAME", ")", ";", "\\", "emit_library_call", "(", "fun", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "lr", ",", "Pmode", ")", ";", "\\", "}", "</s>" ]

[ "Print", "address", "'", "x", "'", "of", "a", "memory", "access", "with", "mode", "'mode", "'", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "void", "X86WinCOFFStreamer", "::", "finishImpl", "(", ")", "{", "emitFrames", "(", "nullptr", ")", ";", "EmitWindowsUnwindTables", "(", ")", ";", "MCWinCOFFStreamer", "::", "finishImpl", "(", ")", ";", "}", "</s>" ]

[ "Streamer", "specific", "finalization", "." ]

[ "X86", "X86" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "!", "MCID", ".", "isCommutable", "(", ")", ")", "return", "false", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "Src0Idx", "==", "-", "1", ")", "return", "false", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "Src0Idx", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "false", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "Src1Idx", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "if", "(", "hasModifiersSet", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", "||", "hasModifiersSet", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ")", "return", "false", ";", "SrcOpIdx1", "=", "Src0Idx", ";", "SrcOpIdx2", "=", "Src1Idx", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "R600", "SI", "1", "1" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitLoadLinked", "(", "IRBuilderBase", "&", "Builder", ",", "Type", "*", "ValueTy", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValueTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "arm_ldaexd", ":", "Intrinsic", "::", "arm_ldrexd", ";", "Function", "*", "Ldrex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldrex", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValueTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValueTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValueTy", ",", "32", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "arm_ldaex", ":", "Intrinsic", "::", "arm_ldrex", ";", "Function", "*", "Ldrex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "CallInst", "*", "CI", "=", "Builder", ".", "CreateCall", "(", "Ldrex", ",", "Addr", ")", ";", "CI", "->", "addParamAttr", "(", "0", ",", "Attribute", "::", "get", "(", "M", "->", "getContext", "(", ")", ",", "Attribute", "::", "ElementType", ",", "ValueTy", ")", ")", ";", "return", "Builder", ".", "CreateTruncOrBitCast", "(", "CI", ",", "ValueTy", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_ldaexd", "Intrinsic::arm_ldrexd", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "32", "\"val64\"", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex", "Intrinsic::getDeclaration", "0" ]

[]

[ "<s>", "void", "SNESInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "SNES", "::", "LDDRdPtrQ", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "SNES", "::", "LDDWRdYQ", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot load this register from a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "0", "MVT::i8", "SNES::LDDRdPtrQ", "MVT::i16", "SNES::LDDWRdYQ", "\"Cannot load this register from a stack slot!\"", "0" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "{", "if", "(", "isGPRAsmReg", "(", ")", "&&", "RegIdx", ".", "Index", "==", "0", ")", "return", "true", ";", "return", "Kind", "==", "k_PhysRegister", ";", "}", "</s>" ]

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

[ "Mips", "0" ]

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "ADJCALLSTACKDOWN", ")", "Size", "=", "-", "Size", ";", "if", "(", "Size", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ADDri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "Size", ")", ";", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "0", "SP::ADJCALLSTACKDOWN", "SP::ADDri", "SP::O6", "SP::O6" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "useColdCCForColdCall", "(", "Function", "&", "F", ")", "{", "return", "EnablePPCColdCC", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "input", "function", "which", "is", "cold", "at", "all", "call", "sites", ",", "should", "use", "coldcc", "calling", "convention", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "PPCRegisterInfo", "*", ">", "(", "Subtarget", ".", "getRegisterInfo", "(", ")", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "FI", "->", "setMustSaveLR", "(", "MustSaveLR", "(", "MF", ",", "LR", ")", ")", ";", "SavedRegs", ".", "reset", "(", "LR", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "bool", "isDarwinABI", "=", "Subtarget", ".", "isDarwinABI", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "FPSI", "&&", "needsFP", "(", "MF", ")", ")", "{", "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", "->", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", "->", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "FI", "->", "getPICBasePointerSaveIndex", "(", ")", ";", "PBPSI", "=", "MFI", "->", "CreateFixedObject", "(", "4", ",", "-", "8", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "int", "TCSPDelta", "=", "0", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "0", ")", "{", "MFI", "->", "CreateFixedObject", "(", "-", "1", "*", "TCSPDelta", ",", "TCSPDelta", ",", "true", ")", ";", "}", "if", "(", "!", "isPPC64", "&&", "!", "isDarwinABI", "&&", "(", "SavedRegs", ".", "test", "(", "PPC", "::", "CR2", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR3", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR4", ")", ")", ")", "{", "int", "FrameIdx", "=", "MFI", "->", "CreateFixedObject", "(", "(", "uint64_t", ")", "4", ",", "(", "int64_t", ")", "-", "4", ",", "true", ")", ";", "FI", "->", "setCRSpillFrameIndex", "(", "FrameIdx", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "8", "4", "PPC", "8", "4", "4", "8", "0", "0", "1", "PPC", "PPC::CR2", "PPC::CR3", "PPC::CR4", "4", "4" ]

[]

[ "<s>", "static", "void", "s390_register_info_stdarg_gpr", "(", ")", "{", "int", "i", ";", "int", "min_gpr", ";", "int", "max_gpr", ";", "if", "(", "!", "cfun", "->", "stdarg", "||", "!", "cfun", "->", "va_list_gpr_size", "||", "crtl", "->", "args", ".", "info", ".", "gprs", ">=", "GP_ARG_NUM_REG", ")", "return", ";", "min_gpr", "=", "crtl", "->", "args", ".", "info", ".", "gprs", ";", "max_gpr", "=", "min_gpr", "+", "cfun", "->", "va_list_gpr_size", ";", "if", "(", "max_gpr", ">", "GP_ARG_NUM_REG", ")", "max_gpr", "=", "GP_ARG_NUM_REG", ";", "for", "(", "i", "=", "min_gpr", ";", "i", "<", "max_gpr", ";", "i", "++", ")", "cfun_gpr_save_slot", "(", "2", "+", "i", ")", "=", "-", "1", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "lm32_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_INT", "&&", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "UNITS_PER_WORD", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

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

[ "lm32" ]

[]

[ "<s>", "void", "WebAssemblyTargetWasmStreamer", "::", "emitImportModule", "(", "MCSymbolWasm", "*", "Sym", ",", "StringRef", "ModuleName", ")", "{", "Sym", "->", "setModuleName", "(", "ModuleName", ")", ";", "}", "</s>" ]

[ ".import_module" ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "rtx_code_label", "*", "ix86_expand_aligntest", "(", "rtx", "variable", ",", "int", "value", ",", "bool", "epilogue", ")", "{", "rtx_code_label", "*", "label", "=", "gen_label_rtx", "(", ")", ";", "rtx", "tmpcount", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "variable", ")", ")", ";", "if", "(", "GET_MODE", "(", "variable", ")", "==", "DImode", ")", "emit_insn", "(", "gen_anddi3", "(", "tmpcount", ",", "variable", ",", "GEN_INT", "(", "value", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_andsi3", "(", "tmpcount", ",", "variable", ",", "GEN_INT", "(", "value", ")", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "tmpcount", ",", "const0_rtx", ",", "EQ", ",", "0", ",", "GET_MODE", "(", "variable", ")", ",", "1", ",", "label", ")", ";", "if", "(", "epilogue", ")", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "50", "/", "100", ")", ";", "else", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "90", "/", "100", ")", ";", "return", "label", ";", "}", "</s>" ]

[ "Helper", "function", "for", "the", "string", "operations", "below", ".", "Dest", "VARIABLE", "whether", "it", "is", "aligned", "to", "VALUE", "bytes", ".", "If", "true", ",", "jump", "to", "the", "label", "." ]

[ "i386", "0", "1", "50", "100", "90", "100" ]

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_emit_allocate_stack", "(", "HOST_WIDE_INT", "size", ",", "rtx", "copy_reg", ",", "int", "copy_off", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "stack_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "rtx", "todec", "=", "gen_int_mode", "(", "-", "size", ",", "Pmode", ")", ";", "if", "(", "INTVAL", "(", "todec", ")", "!=", "-", "size", ")", "{", "warning", "(", "0", ",", "\"stack frame too large\"", ")", ";", "emit_insn", "(", "gen_trap", "(", ")", ")", ";", "return", "0", ";", "}", "if", "(", "crtl", "->", "limit_stack", ")", "{", "if", "(", "REG_P", "(", "stack_limit_rtx", ")", "&&", "REGNO", "(", "stack_limit_rtx", ")", ">", "1", "&&", "REGNO", "(", "stack_limit_rtx", ")", "<=", "31", ")", "{", "rtx_insn", "*", "insn", "=", "gen_add3_insn", "(", "tmp_reg", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ";", "gcc_assert", "(", "insn", ")", ";", "emit_insn", "(", "insn", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "if", "(", "SYMBOL_REF_P", "(", "stack_limit_rtx", ")", "&&", "TARGET_32BIT", "&&", "DEFAULT_ABI", "==", "ABI_V4", "&&", "!", "flag_pic", ")", "{", "rtx", "toload", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_elf_high", "(", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_elf_low", "(", "tmp_reg", ",", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "warning", "(", "0", ",", "\"stack limit expression is not supported\"", ")", ";", "}", "if", "(", "flag_stack_clash_protection", ")", "{", "if", "(", "size", "<", "get_stack_clash_protection_guard_size", "(", ")", ")", "dump_stack_clash_frame_info", "(", "NO_PROBE_SMALL_FRAME", ",", "true", ")", ";", "else", "{", "rtx_insn", "*", "insn", "=", "rs6000_emit_probe_stack_range_stack_clash", "(", "size", ",", "copy_reg", ")", ";", "if", "(", "copy_reg", "&&", "copy_off", ")", "emit_insn", "(", "gen_add3_insn", "(", "copy_reg", ",", "copy_reg", ",", "GEN_INT", "(", "copy_off", ")", ")", ")", ";", "return", "insn", ";", "}", "}", "if", "(", "copy_reg", ")", "{", "if", "(", "copy_off", "!=", "0", ")", "emit_insn", "(", "gen_add3_insn", "(", "copy_reg", ",", "stack_reg", ",", "GEN_INT", "(", "copy_off", ")", ")", ")", ";", "else", "emit_move_insn", "(", "copy_reg", ",", "stack_reg", ")", ";", "}", "insn", "=", "rs6000_emit_allocate_stack_1", "(", "size", ",", "stack_reg", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Emit", "the", "correct", "code", "for", "allocating", "stack", "space", ",", "as", "insns", ".", "If", "COPY_R12", ",", "make", "sure", "a", "copy", "of", "the", "old", "frame", "is", "left", "in", "r12", ".", "The", "generated", "code", "may", "use", "hard", "register", "0", "as", "a", "temporary", "." ]

[ "rs6000", "0", "0", "\"stack frame too large\"", "0", "1", "31", "0", "\"stack limit expression is not supported\"", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "rs6000_constant_alignment", "(", "const_tree", "exp", ",", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", "&&", "(", "STRICT_ALIGNMENT", "||", "!", "optimize_size", ")", ")", "return", "MAX", "(", "align", ",", "BITS_PER_WORD", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "rtx", "aarch64_convert_mult_to_shift", "(", "rtx", "value", ",", "rtx_code", "&", "code", ")", "{", "if", "(", "GET_CODE", "(", "value", ")", "!=", "CONST_VECTOR", ")", "return", "NULL_RTX", ";", "rtx_vector_builder", "builder", ";", "if", "(", "!", "builder", ".", "new_unary_operation", "(", "GET_MODE", "(", "value", ")", ",", "value", ",", "false", ")", ")", "return", "NULL_RTX", ";", "scalar_mode", "int_mode", "=", "GET_MODE_INNER", "(", "GET_MODE", "(", "value", ")", ")", ";", "int", "negate", "=", "-", "1", ";", "unsigned", "int", "encoded_nelts", "=", "const_vector_encoded_nelts", "(", "value", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "encoded_nelts", ";", "++", "i", ")", "{", "rtx", "elt", "=", "CONST_VECTOR_ENCODED_ELT", "(", "value", ",", "i", ")", ";", "if", "(", "!", "CONST_SCALAR_INT_P", "(", "elt", ")", ")", "return", "NULL_RTX", ";", "rtx_mode_t", "val", "(", "elt", ",", "int_mode", ")", ";", "wide_int", "pow2", "=", "wi", "::", "neg", "(", "val", ")", ";", "if", "(", "val", "!=", "pow2", ")", "{", "if", "(", "negate", "==", "!", "wi", "::", "neg_p", "(", "val", ")", ")", "return", "NULL_RTX", ";", "negate", "=", "wi", "::", "neg_p", "(", "val", ")", ";", "if", "(", "!", "negate", ")", "pow2", "=", "val", ";", "}", "int", "shift", "=", "wi", "::", "exact_log2", "(", "pow2", ")", ";", "if", "(", "shift", "<", "0", ")", "return", "NULL_RTX", ";", "builder", ".", "quick_push", "(", "gen_int_mode", "(", "shift", ",", "int_mode", ")", ")", ";", "}", "if", "(", "negate", "==", "-", "1", ")", "code", "=", "PLUS", ";", "else", "if", "(", "negate", "==", "1", ")", "code", "=", "code", "==", "PLUS", "?", "MINUS", ":", "PLUS", ";", "return", "builder", ".", "build", "(", ")", ";", "}", "</s>" ]

[ "Check", "whether", "VALUE", "is", "a", "vector", "constant", "in", "which", "every", "element", "is", "either", "a", "power", "of", "2", "or", "a", "negated", "power", "of", "2", ".", "If", "so", ",", "return", "a", "constant", "vector", "of", "log2s", ",", "and", "flip", "CODE", "between", "PLUS", "and", "MINUS", "if", "VALUE", "contains", "negated", "powers", "of", "2", ".", "Return", "NULL_RTX", "otherwise", "." ]

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

[]

[ "<s>", "void", "AVRAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "&", "Asm", ".", "getContext", "(", ")", ")", ";", "if", "(", "Value", "==", "0", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "auto", "NumBits", "=", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ";", "auto", "NumBytes", "=", "(", "NumBits", "/", "8", ")", "+", "(", "(", "NumBits", "%", "8", ")", "==", "0", "?", "0", ":", "1", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "{", "uint8_t", "mask", "=", "(", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "mask", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "8", "8", "0", "0", "1", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "bool", "WebAssemblyDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "void", "arm_unwind_emit_set", "(", "FILE", "*", "out_file", ",", "rtx", "p", ")", "{", "rtx", "e0", ";", "rtx", "e1", ";", "unsigned", "reg", ";", "e0", "=", "XEXP", "(", "p", ",", "0", ")", ";", "e1", "=", "XEXP", "(", "p", ",", "1", ")", ";", "switch", "(", "GET_CODE", "(", "e0", ")", ")", "{", "case", "MEM", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "e0", ",", "0", ")", ")", "!=", "PRE_DEC", "||", "!", "REG_P", "(", "XEXP", "(", "XEXP", "(", "e0", ",", "0", ")", ",", "0", ")", ")", "||", "REGNO", "(", "XEXP", "(", "XEXP", "(", "e0", ",", "0", ")", ",", "0", ")", ")", "!=", "SP_REGNUM", ")", "abort", "(", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t.save \"", ")", ";", "if", "(", "IS_VFP_REGNUM", "(", "REGNO", "(", "e1", ")", ")", ")", "asm_fprintf", "(", "out_file", ",", "\"{d%d}\\n\"", ",", "(", "REGNO", "(", "e1", ")", "-", "FIRST_VFP_REGNUM", ")", "/", "2", ")", ";", "else", "asm_fprintf", "(", "out_file", ",", "\"{%r}\\n\"", ",", "REGNO", "(", "e1", ")", ")", ";", "break", ";", "case", "REG", ":", "if", "(", "REGNO", "(", "e0", ")", "==", "SP_REGNUM", ")", "{", "if", "(", "GET_CODE", "(", "e1", ")", "!=", "PLUS", "||", "!", "REG_P", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "||", "REGNO", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "!=", "SP_REGNUM", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ")", "abort", "(", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t.pad #%wd\\n\"", ",", "-", "INTVAL", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ")", ";", "}", "else", "if", "(", "REGNO", "(", "e0", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "HOST_WIDE_INT", "offset", ";", "if", "(", "GET_CODE", "(", "e1", ")", "==", "PLUS", ")", "{", "if", "(", "!", "REG_P", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ")", "abort", "(", ")", ";", "reg", "=", "REGNO", "(", "XEXP", "(", "e1", ",", "0", ")", ")", ";", "offset", "=", "INTVAL", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t.setfp %r, %r, #%wd\\n\"", ",", "HARD_FRAME_POINTER_REGNUM", ",", "reg", ",", "offset", ")", ";", "}", "else", "if", "(", "REG_P", "(", "e1", ")", ")", "{", "reg", "=", "REGNO", "(", "e1", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t.setfp %r, %r\\n\"", ",", "HARD_FRAME_POINTER_REGNUM", ",", "reg", ")", ";", "}", "else", "abort", "(", ")", ";", "}", "else", "if", "(", "REG_P", "(", "e1", ")", "&&", "REGNO", "(", "e1", ")", "==", "SP_REGNUM", ")", "{", "asm_fprintf", "(", "out_file", ",", "\"\\t.movsp %r\\n\"", ",", "REGNO", "(", "e0", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "e1", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "==", "SP_REGNUM", "&&", "CONST_INT_P", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ")", "{", "asm_fprintf", "(", "out_file", ",", "\"\\t.movsp %r, #%d\\n\"", ",", "REGNO", "(", "e0", ")", ",", "(", "int", ")", "INTVAL", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ")", ";", "}", "else", "if", "(", "REGNO", "(", "e0", ")", "==", "IP_REGNUM", "&&", "arm_current_function_pac_enabled_p", "(", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "pacspval_needed", ")", "asm_fprintf", "(", "out_file", ",", "\"\\t.pacspval\\n\"", ")", ";", "}", "else", "abort", "(", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "unwind", "directives", "for", "a", "SET", "." ]

[ "arm", "0", "1", "0", "0", "0", "0", "0", "\"\\t.save \"", "\"{d%d}\\n\"", "2", "\"{%r}\\n\"", "0", "0", "1", "\"\\t.pad #%wd\\n\"", "1", "0", "1", "0", "1", "\"\\t.setfp %r, %r, #%wd\\n\"", "\"\\t.setfp %r, %r\\n\"", "\"\\t.movsp %r\\n\"", "0", "0", "1", "\"\\t.movsp %r, #%d\\n\"", "1", "\"\\t.pacspval\\n\"" ]

[]

[ "<s>", "void", "X86AsmBackend", "::", "emitInstructionBegin", "(", "MCObjectStreamer", "&", "OS", ",", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "CanPadInst", "=", "canPadInst", "(", "Inst", ",", "OS", ")", ";", "if", "(", "!", "canPadBranches", "(", "OS", ")", ")", "return", ";", "if", "(", "!", "isMacroFused", "(", "PrevInst", ",", "Inst", ")", ")", "PendingBA", "=", "nullptr", ";", "if", "(", "!", "CanPadInst", ")", "return", ";", "if", "(", "PendingBA", "&&", "OS", ".", "getCurrentFragment", "(", ")", "->", "getPrevNode", "(", ")", "==", "PendingBA", ")", "{", "return", ";", "}", "if", "(", "needAlign", "(", "Inst", ")", "||", "(", "(", "AlignBranchType", "&", "X86", "::", "AlignBranchFused", ")", "&&", "isFirstMacroFusibleInst", "(", "Inst", ",", "*", "MCII", ")", ")", ")", "{", "OS", ".", "insert", "(", "PendingBA", "=", "new", "MCBoundaryAlignFragment", "(", "AlignBoundary", ",", "STI", ")", ")", ";", "}", "}", "</s>" ]

[ "Give", "the", "target", "a", "chance", "to", "manipulate", "state", "related", "to", "instruction", "alignment", "(", "e.g", "." ]

[ "X86", "X86", "X86::AlignBranchFused" ]

[]

[ "<s>", "int", "mmix_register_move_cost", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "enum", "reg_class", "from", ",", "enum", "reg_class", "to", ")", "{", "return", "(", "from", "==", "GENERAL_REGS", "&&", "from", "==", "to", ")", "?", "2", ":", "3", ";", "}", "</s>" ]

[ "REGISTER_MOVE_COST", "." ]

[ "mmix", "2", "3" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "MCS51", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "MCS51", "MCS51::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "isVariadic", "(", ")", ")", "for", "(", "unsigned", "i", "=", "Desc", ".", "getNumOperands", "(", ")", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "OS", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "i", ",", "OS", ")", ";", "}", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "unsigned", "NumDefs", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "getNumDefs", "(", ")", ";", "assert", "(", "NumDefs", "<=", "1", "&&", "\"Instructions with multiple result values not implemented\"", ")", ";", "if", "(", "NumDefs", "!=", "0", ")", "{", "unsigned", "WAReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "WAReg", "!=", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "OS", "<<", "\"\\n\"", "\"\\t\"", "\"set_local \"", "<<", "WAReg", "<<", "\", $pop\"", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\", \"", "1", "\"Instructions with multiple result values not implemented\"", "0", "0", "WebAssembly", "\"\\n\"", "\"\\t\"", "\"set_local \"", "\", $pop\"" ]

[]

[ "<s>", "int", "ix86_match_ccmode", "(", "rtx", "insn", ",", "enum", "machine_mode", "req_mode", ")", "{", "rtx", "set", ";", "enum", "machine_mode", "set_mode", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "PARALLEL", ")", "set", "=", "XVECEXP", "(", "set", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "COMPARE", ")", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "CCNOmode", ":", "if", "(", "req_mode", "!=", "CCNOmode", "&&", "(", "req_mode", "!=", "CCmode", "||", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "!=", "const0_rtx", ")", ")", "return", "0", ";", "break", ";", "case", "CCmode", ":", "if", "(", "req_mode", "==", "CCGCmode", ")", "return", "0", ";", "case", "CCGCmode", ":", "if", "(", "req_mode", "==", "CCGOCmode", "||", "req_mode", "==", "CCNOmode", ")", "return", "0", ";", "case", "CCGOCmode", ":", "if", "(", "req_mode", "==", "CCZmode", ")", "return", "0", ";", "case", "CCZmode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "or", "FALSE", "depending", "on", "whether", "the", "first", "SET", "in", "INSN", "has", "source", "and", "destination", "with", "matching", "CC", "modes", ",", "and", "that", "the", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

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

[]

[ "<s>", "static", "int", "m32c_memory_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "return", "COSTS_N_INSNS", "(", "10", ")", ";", "}", "</s>" ]

[ "Implements", "MEMORY_MOVE_COST", "." ]

[ "m32c", "10" ]

[]

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

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

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

[]

[ "<s>", "StringRef", "R600AsmPrinter", "::", "getPassName", "(", ")", "const", "{", "return", "\"R600 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"R600 Assembly Printer\"" ]

[]

[ "<s>", "void", "erase_if", "(", "T", "&&", "container", ",", "Pred", "p", ")", "{", "llvm", "::", "erase_if", "(", "std", "::", "forward", "<", "T", ">", "(", "container", ")", ",", "p", ")", ";", "}", "</s>" ]

[ "Erase", "items", "from", "the", "set", "vector", "based", "on", "a", "predicate", "function", "." ]

[ "Hexagon" ]

[]

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

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

[ "SystemZ", "SystemZ", "SystemZII::SimpleBDXStore" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "WebAssembly" ]

[]

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

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

[ "ECLair", "ECLair" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "createVR", "(", "MachineFunction", "*", "MF", ",", "MVT", "VT", ")", "const", "{", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", ";", "if", "(", "VT", "==", "MVT", "::", "i1", ")", "{", "TRC", "=", "Hexagon", "::", "PredRegsRegisterClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "{", "TRC", "=", "Hexagon", "::", "IntRegsRegisterClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "{", "TRC", "=", "Hexagon", "::", "DoubleRegsRegisterClass", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this register class\"", ")", ";", "}", "unsigned", "NewReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "TRC", ")", ";", "return", "NewReg", ";", "}", "</s>" ]

[ "HexagonInstrInfo", "specifics", "." ]

[ "Hexagon", "Hexagon", "MVT::i1", "Hexagon::PredRegsRegisterClass", "MVT::i32", "Hexagon::IntRegsRegisterClass", "MVT::i64", "Hexagon::DoubleRegsRegisterClass", "\"Cannot handle this register class\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Libcall overhead timing pass for the TMS320C64X target\"", ";", "}", "</s>" ]

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

[ "TMS320C64X", "\"Libcall overhead timing pass for the TMS320C64X target\"" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_arg", "(", "cumulative_args_t", "ARG_UNUSED", "(", "cum_v", ")", ",", "machine_mode", "mode", ",", "const_tree", ",", "bool", "named", ")", "{", "if", "(", "mode", "==", "VOIDmode", "||", "!", "named", ")", "return", "NULL_RTX", ";", "return", "gen_reg_rtx", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "HSAILMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "llvm_unreachable", "(", "\"When do we hit this?\"", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "\"When do we hit this?\"" ]

[]

[ "<s>", "static", "void", "s390_live_on_entry", "(", "bitmap", "regs", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_varargs_pointer", "!=", "NULL_RTX", ")", "{", "gcc_assert", "(", "flag_split_stack", ")", ";", "bitmap_set_bit", "(", "regs", ",", "1", ")", ";", "}", "}", "</s>" ]

[ "We", "may", "have", "to", "tell", "the", "dataflow", "pass", "that", "the", "split", "stack", "prologue", "is", "initializing", "a", "register", "." ]

[ "s390", "1" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "OPCODE", "(", "RET_FLAG", ")", ";", "OPCODE", "(", "CALL", ")", ";", "OPCODE", "(", "PCREL_WRAPPER", ")", ";", "OPCODE", "(", "Hi", ")", ";", "OPCODE", "(", "Lo", ")", ";", "OPCODE", "(", "FENCE", ")", ";", "OPCODE", "(", "SELECT_CC", ")", ";", "OPCODE", "(", "SMIN", ")", ";", "OPCODE", "(", "UMIN", ")", ";", "OPCODE", "(", "SMAX", ")", ";", "OPCODE", "(", "UMAX", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "RISCVMergeBaseOffsetOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "DeadInstrs", ".", "clear", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineInstr", "&", "HiLUI", ":", "MBB", ")", "{", "MachineInstr", "*", "LoADDI", "=", "nullptr", ";", "if", "(", "!", "detectLuiAddiGlobal", "(", "HiLUI", ",", "LoADDI", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Found lowered global address with one use: \"", "<<", "*", "LoADDI", "->", "getOperand", "(", "2", ")", ".", "getGlobal", "(", ")", "<<", "\"\\n\"", ")", ";", "detectAndFoldOffset", "(", "HiLUI", ",", "*", "LoADDI", ")", ";", "}", "}", "for", "(", "auto", "*", "MI", ":", "DeadInstrs", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "\"MBB: \"", "\"\\n\"", "\" Found lowered global address with one use: \"", "2", "\"\\n\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "AARCH64_COLLECT_LOH_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

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

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

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

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "Res", ";", "unsigned", "RelaxedOpcode", "=", "AMDGPU", "::", "getSOPPWithRelaxation", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "Res", ".", "setOpcode", "(", "RelaxedOpcode", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Inst", "=", "std", "::", "move", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::getSOPPWithRelaxation", "0" ]

[]

[ "<s>", "static", "bool", "expand_set_cint32_one_inst", "(", "rtx", "dest_reg", ",", "HOST_WIDE_INT", "val", ",", "bool", "three_wide_only", ")", "{", "val", "=", "trunc_int_for_mode", "(", "val", ",", "SImode", ")", ";", "if", "(", "val", "==", "trunc_int_for_mode", "(", "val", ",", "QImode", ")", ")", "{", "emit_move_insn", "(", "dest_reg", ",", "GEN_INT", "(", "val", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "!", "three_wide_only", ")", "{", "rtx", "imm_op", "=", "GEN_INT", "(", "val", ")", ";", "if", "(", "satisfies_constraint_J", "(", "imm_op", ")", "||", "satisfies_constraint_K", "(", "imm_op", ")", "||", "satisfies_constraint_N", "(", "imm_op", ")", "||", "satisfies_constraint_P", "(", "imm_op", ")", ")", "{", "emit_move_insn", "(", "dest_reg", ",", "imm_op", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "val", "can", "be", "moved", "into", "a", "register", "in", "one", "instruction", ".", "And", "if", "it", "can", ",", "it", "emits", "the", "code", "to", "move", "the", "constant", ".", "If", "three_wide_only", "is", "true", ",", "this", "insists", "on", "an", "instruction", "that", "works", "in", "a", "bundle", "containing", "three", "instructions", "." ]

[ "tilepro" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "bool", "Op0IsKill", ",", "unsigned", "Op1", ",", "bool", "Op1IsKill", ")", "{", "const", "TargetRegisterClass", "*", "UseRC", "=", "(", "RC", "==", "&", "PPC", "::", "GPRCRegClass", "?", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ":", "(", "RC", "==", "&", "PPC", "::", "G8RCRegClass", "?", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ":", "RC", ")", ")", ";", "return", "FastISel", "::", "fastEmitInst_rr", "(", "MachineInstOpcode", ",", "UseRC", ",", "Op0", ",", "Op0IsKill", ",", "Op1", ",", "Op1IsKill", ")", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "two", "register", "operands", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

[ "PowerPC", "PPC", "PPC::GPRCRegClass", "PPC::GPRC_and_GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_and_G8RC_NOX0RegClass" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "!", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "64", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "||", "VT", ".", "getVectorNumElements", "(", ")", ">", "64", ")", ")", "{", "RegisterVT", "=", "MVT", "::", "i8", ";", "IntermediateVT", "=", "MVT", "::", "i1", ";", "NumIntermediates", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "return", "NumIntermediates", ";", "}", "if", "(", "VT", "==", "MVT", "::", "v64i1", "&&", "Subtarget", ".", "hasBWI", "(", ")", "&&", "!", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "CC", "!=", "CallingConv", "::", "X86_RegCall", ")", "{", "RegisterVT", "=", "MVT", "::", "v32i8", ";", "IntermediateVT", "=", "MVT", "::", "v32i1", ";", "NumIntermediates", "=", "2", ";", "return", "2", ";", "}", "return", "TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "Context", ",", "CC", ",", "VT", ",", "IntermediateVT", ",", "NumIntermediates", ",", "RegisterVT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]

[ "X86", "X86", "MVT::i1", "64", "64", "MVT::i8", "MVT::i1", "MVT::v64i1", "X86", "MVT::v32i8", "MVT::v32i1", "2", "2" ]

[]

[ "<s>", "void", "split_double_concat", "(", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "lo", ",", "rtx", "hi", ")", "{", "rtx", "dlo", ",", "dhi", ";", "int", "deleted_move_count", "=", "0", ";", "split_double_mode", "(", "mode", ",", "&", "dst", ",", "1", ",", "&", "dlo", ",", "&", "dhi", ")", ";", "if", "(", "MEM_P", "(", "lo", ")", "&&", "rtx_equal_p", "(", "dlo", ",", "hi", ")", "&&", "reg_overlap_mentioned_p", "(", "dhi", ",", "lo", ")", ")", "{", "emit_move_insn", "(", "dhi", ",", "lo", ")", ";", "lo", "=", "dhi", ";", "}", "else", "if", "(", "MEM_P", "(", "hi", ")", "&&", "!", "MEM_P", "(", "lo", ")", "&&", "!", "rtx_equal_p", "(", "dlo", ",", "lo", ")", "&&", "reg_overlap_mentioned_p", "(", "dlo", ",", "hi", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "dhi", ",", "lo", ")", ")", "{", "emit_move_insn", "(", "dlo", ",", "hi", ")", ";", "hi", "=", "dlo", ";", "}", "else", "{", "emit_move_insn", "(", "dhi", ",", "hi", ")", ";", "hi", "=", "dhi", ";", "}", "}", "if", "(", "!", "rtx_equal_p", "(", "dlo", ",", "hi", ")", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dlo", ",", "lo", ")", ")", "emit_move_insn", "(", "dlo", ",", "lo", ")", ";", "else", "deleted_move_count", "++", ";", "if", "(", "!", "rtx_equal_p", "(", "dhi", ",", "hi", ")", ")", "emit_move_insn", "(", "dhi", ",", "hi", ")", ";", "else", "deleted_move_count", "++", ";", "}", "else", "if", "(", "!", "rtx_equal_p", "(", "lo", ",", "dhi", ")", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dhi", ",", "hi", ")", ")", "emit_move_insn", "(", "dhi", ",", "hi", ")", ";", "else", "deleted_move_count", "++", ";", "if", "(", "!", "rtx_equal_p", "(", "dlo", ",", "lo", ")", ")", "emit_move_insn", "(", "dlo", ",", "lo", ")", ";", "else", "deleted_move_count", "++", ";", "}", "else", "if", "(", "mode", "==", "TImode", ")", "emit_insn", "(", "gen_swapdi", "(", "dlo", ",", "dhi", ")", ")", ";", "else", "emit_insn", "(", "gen_swapsi", "(", "dlo", ",", "dhi", ")", ")", ";", "if", "(", "deleted_move_count", "==", "2", ")", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "}", "</s>" ]

[ "Emit", "the", "double", "word", "assignment", "DST", "=", "{", "LO", ",", "HI", "}", "." ]

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

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".hword\"", ")", "return", "parseDirectiveWord", "(", "2", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "parseDirectiveWord", "(", "4", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".xword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "return", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "return", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AArch64", "AArch64", "\".hword\"", "2", "\".word\"", "4", "\".xword\"", "8", "\".tlsdesccall\"" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", "&", "getPPCTargetMachine", "(", ")", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "TM", ",", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "RISCVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALLReg", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoTAIL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoJump", ")", "{", "expandFunctionCall", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "2", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoAddTPRel", ")", "{", "expandAddTPRel", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "1", ";", "return", ";", "}", "switch", "(", "Size", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled encodeInstruction length!\"", ")", ";", "case", "2", ":", "{", "uint16_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "case", "4", ":", "{", "uint32_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::PseudoCALLReg", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "RISCV::PseudoJump", "2", "RISCV::PseudoAddTPRel", "1", "\"Unhandled encodeInstruction length!\"", "2", "support::endian", "support::little", "4", "support::endian", "support::little" ]

[]

[ "<s>", "bool", "ELFAArch64AsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "if", "(", "(", "uint32_t", ")", "Fixup", ".", "getKind", "(", ")", "==", "AArch64", "::", "fixup_aarch64_pcrel_adrp_imm21", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::fixup_aarch64_pcrel_adrp_imm21" ]

[]

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

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

[ "AAP" ]

[]

[ "<s>", "void", "MipsRegisterBankInfo", "::", "setRegBank", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "Register", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_STORE", ":", "break", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_SELECT", ":", "case", "TargetOpcode", "::", "G_PHI", ":", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "{", "assert", "(", "MRI", ".", "getType", "(", "Dest", ")", "==", "LLT", "::", "scalar", "(", "32", ")", "&&", "\"Unexpected operand type.\"", ")", ";", "MRI", ".", "setRegBank", "(", "Dest", ",", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ")", ";", "break", ";", "}", "case", "TargetOpcode", "::", "G_GEP", ":", "{", "assert", "(", "MRI", ".", "getType", "(", "Dest", ")", ".", "isPointer", "(", ")", "&&", "\"Unexpected operand type.\"", ")", ";", "MRI", ".", "setRegBank", "(", "Dest", ",", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ")", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode.\"", ")", ";", "}", "}", "</s>" ]

[ "RegBankSelect", "determined", "that", "s64", "operand", "is", "better", "to", "be", "split", "into", "two", "s32", "operands", "in", "gprb", "." ]

[ "Mips", "Mips", "0", "32", "\"Unexpected operand type.\"", "Mips::GPRBRegBankID", "\"Unexpected operand type.\"", "Mips::GPRBRegBankID", "\"Unexpected opcode.\"" ]

[]

[ "<s>", "int", "shl_and_scr_length", "(", "rtx", "insn", ")", "{", "rtx", "set_src", "=", "SET_SRC", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", ";", "int", "len", "=", "shift_insns", "[", "INTVAL", "(", "XEXP", "(", "set_src", ",", "1", ")", ")", "]", ";", "rtx", "op", "=", "XEXP", "(", "set_src", ",", "0", ")", ";", "len", "+=", "shift_insns", "[", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", "]", "+", "1", ";", "op", "=", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "return", "len", "+", "shift_insns", "[", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", "]", ";", "}", "</s>" ]

[ "This", "is", "used", "in", "length", "attribute", "of", "the", "and_shl_scratch", "instruction", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "this_regno", "=", "R0_REGNUM", ";", "rtx", "this_rtx", ",", "temp0", ",", "temp1", ",", "addr", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "vcall_offset", "==", "0", ")", "aarch64_add_constant", "(", "this_regno", ",", "IP1_REGNUM", ",", "delta", ")", ";", "else", "{", "gcc_assert", "(", "(", "vcall_offset", "&", "(", "POINTER_BYTES", "-", "1", ")", ")", "==", "0", ")", ";", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "this_regno", ")", ";", "temp0", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP0_REGNUM", ")", ";", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP1_REGNUM", ")", ";", "addr", "=", "this_rtx", ";", "if", "(", "delta", "!=", "0", ")", "{", "if", "(", "delta", ">=", "-", "256", "&&", "delta", "<", "256", ")", "addr", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "this_rtx", ",", "plus_constant", "(", "Pmode", ",", "this_rtx", ",", "delta", ")", ")", ";", "else", "aarch64_add_constant", "(", "this_regno", ",", "IP1_REGNUM", ",", "delta", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_ZERO_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "if", "(", "vcall_offset", ">=", "-", "256", "&&", "vcall_offset", "<", "4096", "*", "POINTER_BYTES", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "temp0", ",", "vcall_offset", ")", ";", "else", "{", "(", "void", ")", "aarch64_build_constant", "(", "IP1_REGNUM", ",", "vcall_offset", ",", "true", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp0", ",", "temp1", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_SIGN_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ",", "NULL_RTX", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "aarch64", "1", "0", "1", "0", "0", "256", "256", "256", "4096", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "AllSGPRSpilledToVGPRs", "=", "false", ";", "if", "(", "TRI", ".", "spillSGPRToVGPR", "(", ")", "&&", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", "{", "AllSGPRSpilledToVGPRs", "=", "true", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "{", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "SIStackID", "::", "SGPR_SPILL", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "bool", "Spilled", "=", "TRI", ".", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "RS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "\"failed to spill SGPR to VGPR when allocated\"", ")", ";", "}", "else", "AllSGPRSpilledToVGPRs", "=", "false", ";", "}", "}", "}", "FuncInfo", "->", "removeSGPRToVGPRFrameIndices", "(", "MFI", ")", ";", "}", "if", "(", "FuncInfo", "->", "hasNonSpillStackObjects", "(", ")", "||", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "||", "!", "AllSGPRSpilledToVGPRs", "||", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "0", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "AMDGPU::OpName", "SIStackID::SGPR_SPILL", "\"failed to spill SGPR to VGPR when allocated\"", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "avr_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "strncmp", "(", "name", ",", "\".noinit\"", ",", "7", ")", "==", "0", ")", "{", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_INITIAL", "(", "decl", ")", "==", "NULL_TREE", ")", "flags", "|=", "SECTION_BSS", ";", "else", "warning", "(", "0", ",", "\"only uninitialized variables can be placed in the \"", "\".noinit section\"", ")", ";", "}", "return", "flags", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_SECTION_TYPE_FLAGS", "'", "." ]

[ "avr", "\".noinit\"", "7", "0", "0", "\"only uninitialized variables can be placed in the \"", "\".noinit section\"" ]

[]

[ "<s>", "unsigned", "MBlazeMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getMBlazeRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "return", "0", ";", "errs", "(", ")", "<<", "MO", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "TLSCLEANUP_PASS_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "SMAX", ")", "NODE_NAME_CASE", "(", "UMAX", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "SMIN", ")", "NODE_NAME_CASE", "(", "UMIN", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMPED", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "BREV", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "}", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "BPFAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "unsigned", "RegNo", "=", "MatchRegisterName", "(", "Name", ")", ";", "if", "(", "RegNo", "!=", "0", ")", "{", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "-", "1", ")", ";", "Operands", ".", "push_back", "(", "BPFOperand", "::", "createReg", "(", "RegNo", ",", "NameLoc", ",", "E", ")", ")", ";", "}", "else", "if", "(", "BPFOperand", "::", "isValidIdAtStart", "(", "Name", ")", ")", "Operands", ".", "push_back", "(", "BPFOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "else", "return", "true", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperandAsOperator", "(", "Operands", ")", "==", "MatchOperand_Success", ")", "continue", ";", "if", "(", "parseRegister", "(", "Operands", ")", "==", "MatchOperand_Success", ")", "continue", ";", "if", "(", "parseImmediate", "(", "Operands", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "0", "1", "BPFOperand::createReg", "BPFOperand::isValidIdAtStart", "BPFOperand::createToken", "\"unexpected token\"" ]

[]

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

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

[ "GBZ80" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "int", "incoming", ",", "int", "libcall", ",", "int", "n_named_args", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ",", "machine_mode", "return_mode", "ATTRIBUTE_UNUSED", ")", "{", "static", "CUMULATIVE_ARGS", "zero_cumulative", ";", "*", "cum", "=", "zero_cumulative", ";", "cum", "->", "words", "=", "0", ";", "cum", "->", "fregno", "=", "FP_ARG_MIN_REG", ";", "cum", "->", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "cum", "->", "prototype", "=", "(", "fntype", "&&", "prototype_p", "(", "fntype", ")", ")", ";", "cum", "->", "call_cookie", "=", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "libcall", ")", "?", "CALL_LIBCALL", ":", "CALL_NORMAL", ")", ";", "cum", "->", "sysv_gregno", "=", "GP_ARG_MIN_REG", ";", "cum", "->", "stdarg", "=", "stdarg_p", "(", "fntype", ")", ";", "cum", "->", "libcall", "=", "libcall", ";", "cum", "->", "nargs_prototype", "=", "0", ";", "if", "(", "incoming", "||", "cum", "->", "prototype", ")", "cum", "->", "nargs_prototype", "=", "n_named_args", ";", "if", "(", "(", "!", "fntype", "&&", "rs6000_default_long_calls", ")", "||", "(", "fntype", "&&", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "&&", "!", "lookup_attribute", "(", "\"shortcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", ")", "cum", "->", "call_cookie", "|=", "CALL_LONG", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "\"\\ninit_cumulative_args:\"", ")", ";", "if", "(", "fntype", ")", "{", "tree", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fprintf", "(", "stderr", ",", "\" ret code = %s,\"", ",", "get_tree_code_name", "(", "TREE_CODE", "(", "ret_type", ")", ")", ")", ";", "}", "if", "(", "cum", "->", "call_cookie", "&", "CALL_LONG", ")", "fprintf", "(", "stderr", ",", "\" longcall,\"", ")", ";", "fprintf", "(", "stderr", ",", "\" proto = %d, nargs = %d\\n\"", ",", "cum", "->", "prototype", ",", "cum", "->", "nargs_prototype", ")", ";", "}", "if", "(", "TARGET_ELF", "&&", "(", "TARGET_64BIT", "||", "DEFAULT_ABI", "==", "ABI_V4", ")", ")", "{", "cum", "->", "escapes", "=", "call_ABI_of_interest", "(", "fndecl", ")", ";", "if", "(", "cum", "->", "escapes", ")", "{", "tree", "return_type", ";", "if", "(", "fntype", ")", "{", "return_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "return_mode", "=", "TYPE_MODE", "(", "return_type", ")", ";", "}", "else", "return_type", "=", "lang_hooks", ".", "types", ".", "type_for_mode", "(", "return_mode", ",", "0", ")", ";", "if", "(", "return_type", "!=", "NULL", ")", "{", "if", "(", "TREE_CODE", "(", "return_type", ")", "==", "RECORD_TYPE", "&&", "TYPE_TRANSPARENT_AGGR", "(", "return_type", ")", ")", "{", "return_type", "=", "TREE_TYPE", "(", "first_field", "(", "return_type", ")", ")", ";", "return_mode", "=", "TYPE_MODE", "(", "return_type", ")", ";", "}", "if", "(", "AGGREGATE_TYPE_P", "(", "return_type", ")", "&&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "return_type", ")", "<=", "8", ")", ")", "rs6000_returns_struct", "=", "true", ";", "}", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "return_mode", ")", ")", "{", "rs6000_passes_float", "=", "true", ";", "if", "(", "(", "HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE", "||", "TARGET_64BIT", ")", "&&", "(", "FLOAT128_IBM_P", "(", "return_mode", ")", "||", "FLOAT128_IEEE_P", "(", "return_mode", ")", "||", "(", "return_type", "!=", "NULL", "&&", "(", "TYPE_MAIN_VARIANT", "(", "return_type", ")", "==", "long_double_type_node", ")", ")", ")", ")", "rs6000_passes_long_double", "=", "true", ";", "}", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "return_mode", ")", "||", "SPE_VECTOR_MODE", "(", "return_mode", ")", ")", "rs6000_passes_vector", "=", "true", ";", "}", "}", "if", "(", "fntype", "&&", "!", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", ")", ")", "{", "error", "(", "\"cannot return value in vector register because\"", "\" altivec instructions are disabled, use -maltivec\"", "\" to enable them\"", ")", ";", "}", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

[ "rs6000", "0", "0", "\"longcall\"", "\"shortcall\"", "\"\\ninit_cumulative_args:\"", "\" ret code = %s,\"", "\" longcall,\"", "\" proto = %d, nargs = %d\\n\"", "0", "8", "\"cannot return value in vector register because\"", "\" altivec instructions are disabled, use -maltivec\"", "\" to enable them\"" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", "fun", ")", "{", "if", "(", "avr_gasisr_prologues", "&&", "!", "fun", "->", "machine", "->", "is_no_gccisr", "&&", "(", "fun", "->", "machine", "->", "is_interrupt", "||", "fun", "->", "machine", "->", "is_signal", ")", "&&", "!", "cfun", "->", "machine", "->", "is_naked", "&&", "!", "cfun", "->", "calls_setjmp", "&&", "!", "cfun", "->", "has_nonlocal_label", "&&", "!", "cfun", "->", "has_forced_label_in_static", ")", "{", "compute_maybe_gasisr", "(", "fun", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "avr", "0" ]

[]

[ "<s>", "void", "XCorePassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createXCoreFrameToArgsOffsetEliminationPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "Sparc", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "Sparc", "Sparc::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "TPC" ]

[]

[ "<s>", "bool", "FixAllFDIVSQRT", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "SP", "::", "FSQRTD", "||", "Opcode", "==", "SP", "::", "FDIVD", ")", "{", "for", "(", "int", "InsertedCount", "=", "0", ";", "InsertedCount", "<", "5", ";", "InsertedCount", "++", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "SP", "::", "NOP", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "NMBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "for", "(", "int", "InsertedCount", "=", "0", ";", "InsertedCount", "<", "28", ";", "InsertedCount", "++", ")", "BuildMI", "(", "MBB", ",", "NMBBI", ",", "DL", ",", "TII", ".", "get", "(", "SP", "::", "NOP", ")", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::FSQRTD", "SP::FDIVD", "0", "5", "SP::NOP", "0", "28", "SP::NOP" ]

[]

[ "<s>", "static", "void", "rs6000_alloc_sdmode_stack_slot", "(", "void", ")", "{", "tree", "t", ";", "basic_block", "bb", ";", "gimple_stmt_iterator", "gsi", ";", "gcc_assert", "(", "cfun", "->", "machine", "->", "sdmode_stack_slot", "==", "NULL_RTX", ")", ";", "if", "(", "ira_use_lra_p", ")", "return", ";", "if", "(", "TARGET_NO_SDMODE_STACK", ")", "return", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "{", "tree", "ret", "=", "walk_gimple_op", "(", "gsi_stmt", "(", "gsi", ")", ",", "rs6000_check_sdmode", ",", "NULL", ")", ";", "if", "(", "ret", ")", "{", "rtx", "stack", "=", "assign_stack_local", "(", "DDmode", ",", "GET_MODE_SIZE", "(", "DDmode", ")", ",", "0", ")", ";", "cfun", "->", "machine", "->", "sdmode_stack_slot", "=", "adjust_address_nv", "(", "stack", ",", "SDmode", ",", "0", ")", ";", "return", ";", "}", "}", "for", "(", "t", "=", "DECL_ARGUMENTS", "(", "cfun", "->", "decl", ")", ";", "t", ";", "t", "=", "DECL_CHAIN", "(", "t", ")", ")", "{", "if", "(", "TREE_TYPE", "(", "t", ")", "==", "error_mark_node", ")", "continue", ";", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "t", ")", ")", "==", "SDmode", "||", "TYPE_MODE", "(", "DECL_ARG_TYPE", "(", "t", ")", ")", "==", "SDmode", ")", "{", "rtx", "stack", "=", "assign_stack_local", "(", "DDmode", ",", "GET_MODE_SIZE", "(", "DDmode", ")", ",", "0", ")", ";", "cfun", "->", "machine", "->", "sdmode_stack_slot", "=", "adjust_address_nv", "(", "stack", ",", "SDmode", ",", "0", ")", ";", "return", ";", "}", "}", "}", "</s>" ]

[ "Allocate", "a", "64-bit", "stack", "slot", "to", "be", "used", "for", "copying", "SDmode", "values", "through", "if", "this", "function", "has", "any", "SDmode", "references", ".", "If", "we", "are", "on", "a", "power7", "or", "later", ",", "we", "do", "n't", "need", "the", "64-bit", "stack", "slot", "since", "the", "LFIWZX", "and", "STIFWX", "instructions", "can", "load/store", "the", "value", "." ]

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

[]

[ "<s>", "static", "bool", "microblaze_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "(", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", "&&", "!", "leaf_function_p", "(", ")", ")", "||", "(", "to", "==", "MB_ABI_SUB_RETURN_ADDR_REGNUM", "&&", "leaf_function_p", "(", ")", ")", "||", "(", "from", "!=", "RETURN_ADDRESS_POINTER_REGNUM", "&&", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", "||", "(", "to", "==", "STACK_POINTER_REGNUM", "&&", "!", "frame_pointer_needed", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Make", "sure", "that", "we", "'re", "not", "trying", "to", "eliminate", "to", "the", "wrong", "hard", "frame", "pointer", "." ]

[ "microblaze" ]

[]

[ "<s>", "MCSection", "*", "RISCVELFTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "Align", "&", "Alignment", ")", "const", "{", "if", "(", "isConstantInSmallSection", "(", "DL", ",", "C", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ",", "Alignment", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

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

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

[ "RV16K", "RV16K" ]

[]

[ "<s>", "static", "inline", "built_in_function", "complex_divide_builtin_code", "(", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "IN_RANGE", "(", "mode", ",", "MIN_MODE_COMPLEX_FLOAT", ",", "MAX_MODE_COMPLEX_FLOAT", ")", ")", ";", "int", "func", "=", "BUILT_IN_COMPLEX_DIV_MIN", "+", "mode", "-", "MIN_MODE_COMPLEX_FLOAT", ";", "return", "(", "built_in_function", ")", "func", ";", "}", "</s>" ]

[ "Internal", "function", "to", "return", "the", "built-in", "function", "id", "for", "the", "complex", "divide", "operation", "for", "a", "given", "mode", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "int", "mips_address_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "return", "mips_address_insns", "(", "addr", ",", "mode", ",", "false", ")", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "." ]

[ "mips" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "MachineInstr", "*", "SystemZInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "SystemZ", "SystemZ", "0" ]

[]

[ "<s>", "int", "tls_symbolic_operand", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SYMBOL_REF", ")", "return", "0", ";", "return", "SYMBOL_REF_TLS_MODEL", "(", "op", ")", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "type", "for", "TLS", "symbols", ",", "0", "for", "otherwise", "." ]

[ "s390", "0" ]

[]

[ "<s>", "static", "inline", "bool", "s390_vector_bool_type_p", "(", "const_tree", "type", ")", "{", "return", "TYPE_VECTOR_OPAQUE", "(", "type", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "is", "a", "vector", "bool", "type", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "M680x0FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "M680x0MachineFunctionInfo", "*", "M680x0FI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "M680x0FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", ".", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "0" ]

[]

[ "<s>", "void", "ARMInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "switch", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported code model for lowering\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "{", "SDValue", "AddrHi", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "RISCVII", "::", "MO_HI", ")", ";", "SDValue", "AddrLo", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "RISCVII", "::", "MO_LO", ")", ";", "SDValue", "MNHi", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "LUI", ",", "DL", ",", "Ty", ",", "AddrHi", ")", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "ADDI", ",", "DL", ",", "Ty", ",", "MNHi", ",", "AddrLo", ")", ",", "0", ")", ";", "}", "case", "CodeModel", "::", "Medium", ":", "{", "SDValue", "Addr", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "PseudoLLA", ",", "DL", ",", "Ty", ",", "Addr", ")", ",", "0", ")", ";", "}", "}", "}", "</s>" ]

[ "Return", "the", "address", "accessed", "by", "this", "recipe", "." ]

[ "RISCV", "RISCV", "\"Unsupported code model for lowering\"", "RISCVII::MO_HI", "RISCVII::MO_LO", "RISCV::LUI", "0", "RISCV::ADDI", "0", "0", "RISCV::PseudoLLA", "0" ]

[]

[ "<s>", "SDValue", "ARCompactTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_ARCompact32", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "ARCompact", "ARC", "ISD::InputArg", "16", "ARC", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "initializePass", "(", ")", "override", "{", "pushTTIStack", "(", "this", ")", ";", "}", "</s>" ]

[ "initializePass", "-", "This", "method", "may", "be", "overriden", "by", "immutable", "passes", "to", "allow", "them", "to", "perform", "various", "initialization", "actions", "they", "require", "." ]

[ "ARM64" ]

[]

[ "<s>", "static", "rtx", "gen_rx_rtsd_vector", "(", "unsigned", "int", "adjust", ",", "unsigned", "int", "low", ",", "unsigned", "int", "high", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "bias", "=", "3", ";", "unsigned", "int", "count", "=", "(", "high", "-", "low", ")", "+", "bias", ";", "rtx", "vector", ";", "vector", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "adjust", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", "-", "2", ";", "i", "++", ")", "XVECEXP", "(", "vector", ",", "0", ",", "i", "+", "1", ")", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "SImode", ",", "low", "+", "i", ")", ",", "gen_rtx_MEM", "(", "SImode", ",", "i", "==", "0", "?", "stack_pointer_rtx", ":", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "i", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "count", "-", "1", ")", "=", "ret_rtx", ";", "return", "vector", ";", "}", "</s>" ]

[ "Generate", "a", "PARALLEL", "which", "will", "satisfy", "the", "rx_rtsd_vector", "predicate", "." ]

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

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "bool", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "SystemZ", "SystemZ", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "isConditionalBranch", "(", "Inst", ")", ")", "{", "int64_t", "Imm", ";", "if", "(", "Size", "==", "2", ")", "Imm", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "else", "Imm", "=", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", ";", "return", "true", ";", "}", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "C_JAL", "||", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "C_J", "||", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "C_CJAL", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "JAL", "||", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "CJAL", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "2", "1", "2", "RISCV::C_JAL", "RISCV::C_J", "RISCV::C_CJAL", "0", "RISCV::JAL", "RISCV::CJAL", "1" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "ARM", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "SrcReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_GPRwithAPSRnospRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_0", ",", "getKillRegState", "(", "isKill", ")", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_1", ",", "0", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::t2STRi12", "0", "ARMCC::AL", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_GPRwithAPSRnospRegClass", "ARM::t2STRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "0", "ARMCC::AL", "ARM" ]

[]

[ "<s>", "bool", "AMDGPUConvertToISAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AMDGPUInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AMDGPUInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "TII", "->", "convertToISA", "(", "MI", ",", "MF", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "static", "rtx", "move_acc_to_reg", "(", "rtx", "acc", ",", "int", "regno", ",", "rtx_insn", "*", "before", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "acc", ")", ";", "rtx", "reg", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "return", "gen_and_emit_move", "(", "reg", ",", "acc", ",", "before", ",", "true", ")", ";", "}", "</s>" ]

[ "Copy", "accumulator", "(", "A", "or", "AX", ")", "to", "REGNO", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "reg", "RTX", "." ]

[ "rl78" ]

[]

[ "<s>", "void", "ARMCodeEmitter", "::", "emitInstruction", "(", "const", "MachineInstr", "&", "MI", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JIT: \"", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "\":\\t\"", "<<", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "true", ")", ";", "++", "NumEmitted", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "{", "default", ":", "{", "llvm_unreachable", "(", "\"Unhandled instruction encoding format!\"", ")", ";", "break", ";", "}", "case", "ARMII", "::", "Pseudo", ":", "emitPseudoInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "DPFrm", ":", "case", "ARMII", "::", "DPSoRegFrm", ":", "emitDataProcessingInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdFrm", ":", "case", "ARMII", "::", "StFrm", ":", "emitLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdMiscFrm", ":", "case", "ARMII", "::", "StMiscFrm", ":", "emitMiscLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdStMulFrm", ":", "emitLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "MulFrm", ":", "emitMulFrmInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ExtFrm", ":", "emitExtendInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ArithMiscFrm", ":", "emitMiscArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "SatFrm", ":", "emitSaturateInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrFrm", ":", "emitBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrMiscFrm", ":", "emitMiscBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPUnaryFrm", ":", "case", "ARMII", "::", "VFPBinaryFrm", ":", "emitVFPArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPConv1Frm", ":", "case", "ARMII", "::", "VFPConv2Frm", ":", "case", "ARMII", "::", "VFPConv3Frm", ":", "case", "ARMII", "::", "VFPConv4Frm", ":", "case", "ARMII", "::", "VFPConv5Frm", ":", "emitVFPConversionInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStFrm", ":", "emitVFPLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStMulFrm", ":", "emitVFPLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPMiscFrm", ":", "emitMiscInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "NGetLnFrm", ":", "case", "ARMII", "::", "NSetLnFrm", ":", "emitNEONLaneInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "NDupFrm", ":", "emitNEONDupInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N1RegModImmFrm", ":", "emitNEON1RegModImmInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N2RegFrm", ":", "emitNEON2RegInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N3RegFrm", ":", "emitNEON3RegInstruction", "(", "MI", ")", ";", "break", ";", "}", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT: \"", "\":\\t\"", "ARMII::FormMask", "\"Unhandled instruction encoding format!\"", "ARMII::Pseudo", "ARMII::DPFrm", "ARMII::DPSoRegFrm", "ARMII::LdFrm", "ARMII::StFrm", "ARMII::LdMiscFrm", "ARMII::StMiscFrm", "ARMII::LdStMulFrm", "ARMII::MulFrm", "ARMII::ExtFrm", "ARMII::ArithMiscFrm", "ARMII::SatFrm", "ARMII::BrFrm", "ARMII::BrMiscFrm", "ARMII::VFPUnaryFrm", "ARMII::VFPBinaryFrm", "ARMII::VFPConv1Frm", "ARMII::VFPConv2Frm", "ARMII::VFPConv3Frm", "ARMII::VFPConv4Frm", "ARMII::VFPConv5Frm", "ARMII::VFPLdStFrm", "ARMII::VFPLdStMulFrm", "ARMII::VFPMiscFrm", "ARMII::NGetLnFrm", "ARMII::NSetLnFrm", "ARMII::NDupFrm", "ARMII::N1RegModImmFrm", "ARMII::N2RegFrm", "ARMII::N3RegFrm" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "withTargetFlags", "(", "SDValue", "Op", ",", "unsigned", "TF", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "const", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "SDLoc", "(", "GA", ")", ",", "GA", "->", "getValueType", "(", "0", ")", ",", "GA", "->", "getOffset", "(", ")", ",", "TF", ")", ";", "if", "(", "const", "ConstantPoolSDNode", "*", "CP", "=", "dyn_cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetConstantPool", "(", "CP", "->", "getConstVal", "(", ")", ",", "CP", "->", "getValueType", "(", "0", ")", ",", "CP", "->", "getAlign", "(", ")", ",", "CP", "->", "getOffset", "(", ")", ",", "TF", ")", ";", "if", "(", "const", "BlockAddressSDNode", "*", "BA", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetBlockAddress", "(", "BA", "->", "getBlockAddress", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "0", ",", "TF", ")", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetExternalSymbol", "(", "ES", "->", "getSymbol", "(", ")", ",", "ES", "->", "getValueType", "(", "0", ")", ",", "TF", ")", ";", "llvm_unreachable", "(", "\"Unhandled address SDNode\"", ")", ";", "}", "</s>" ]

[ "}", "Custom", "DAGCombine" ]

[ "Sparc", "Sparc", "0", "0", "0", "0", "\"Unhandled address SDNode\"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MBlazeTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "const", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "unsigned", "MSP430RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::FPW", "MSP430::SPW" ]

[]

[ "<s>", "vl_vtype_info", "(", ")", ":", "m_avl", "(", "avl_info", "(", ")", ")", ",", "m_sew", "(", "0", ")", ",", "m_vlmul", "(", "riscv_vector", "::", "LMUL_RESERVED", ")", ",", "m_ratio", "(", "0", ")", ",", "m_ta", "(", "0", ")", ",", "m_ma", "(", "0", ")", "{", "}", "</s>" ]

[ "Initialize", "VL/VTYPE", "information", "." ]

[ "riscv", "0", "riscv_vector::LMUL_RESERVED", "0", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", "||", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "OptimizeNone", ")", ")", "return", "false", ";", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "for", "(", "Type", "*", "ParamTy", ":", "FTy", "->", "params", "(", ")", ")", "{", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "ParamTy", ")", ";", "if", "(", "PtrTy", "&&", "PtrTy", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemAvailable", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "return", "false", ";", "}", "}", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ";", "LocalMemAvailable", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "if", "(", "LocalMemAvailable", "==", "0", ")", "return", "false", ";", "for", "(", "GlobalVariable", "&", "GV", ":", "Mod", "->", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "Use", "&", "U", ":", "GV", ".", "uses", "(", ")", ")", "{", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "LocalMemAvailable", "-=", "Mod", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "}", "}", "LocalMemAvailable", "=", "std", "::", "max", "(", "0", ",", "LocalMemAvailable", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "LocalMemAvailable", "<<", "\" bytes free in local memory.\\n\"", ")", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "for", "(", "auto", "I", "=", "EntryBB", ".", "begin", "(", ")", ",", "E", "=", "EntryBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "AI", ")", "handleAlloca", "(", "*", "AI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "AMDGPU", "AMDGPU", "0", "AMDGPU", "0", "\" bytes free in local memory.\\n\"" ]

[]

[ "<s>", "static", "void", "ix86_set_func_type", "(", "tree", "fndecl", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_UNKNOWN", ")", "{", "if", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ")", "{", "if", "(", "ix86_function_naked", "(", "fndecl", ")", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "fndecl", ")", ",", "\"interrupt and naked attributes are not compatible\"", ")", ";", "int", "nargs", "=", "0", ";", "for", "(", "tree", "arg", "=", "DECL_ARGUMENTS", "(", "fndecl", ")", ";", "arg", ";", "arg", "=", "TREE_CHAIN", "(", "arg", ")", ")", "nargs", "++", ";", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "true", ";", "cfun", "->", "machine", "->", "func_type", "=", "nargs", "==", "2", "?", "TYPE_EXCEPTION", ":", "TYPE_INTERRUPT", ";", "ix86_optimize_mode_switching", "[", "X86_DIRFLAG", "]", "=", "1", ";", "if", "(", "write_symbols", "!=", "NO_DEBUG", "&&", "write_symbols", "!=", "DWARF2_DEBUG", ")", "sorry", "(", "\"Only DWARF debug format is supported for interrupt \"", "\"service routine.\"", ")", ";", "}", "else", "{", "cfun", "->", "machine", "->", "func_type", "=", "TYPE_NORMAL", ";", "if", "(", "lookup_attribute", "(", "\"no_caller_saved_registers\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ")", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "true", ";", "}", "}", "}", "</s>" ]

[ "Set", "the", "func_type", "field", "from", "the", "function", "FNDECL", "." ]

[ "i386", "\"interrupt\"", "\"interrupt and naked attributes are not compatible\"", "0", "2", "1", "\"Only DWARF debug format is supported for interrupt \"", "\"service routine.\"", "\"no_caller_saved_registers\"" ]

[]