Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "X86FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MFI", "->", "hasInlineAsmWithSPAdjust", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getForceFramePointer", "(", ")", "||", "MMI", ".", "callsUnwindInit", "(", ")", "||", "MMI", ".", "callsEHReturn", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "XtensaSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "AlphaBSel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MFI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", "->", "begin", "(", ")", ",", "EE", "=", "MBB", "->", "end", "(", ")", ";", "MBBI", "!=", "EE", ";", "++", "MBBI", ")", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "COND_BRANCH_I", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "COND_BRANCH_F", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MBBI", "->", "setDesc", "(", "TII", "->", "get", "(", "MBBI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::COND_BRANCH_I", "Alpha::COND_BRANCH_F", "0" ]

[]

[ "<s>", "void", "X86AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "X86MCInstLower", "MCInstLowering", "(", "*", "MF", ",", "*", "this", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "llvm_unreachable", "(", "\"Should be handled target independently\"", ")", ";", "case", "X86", "::", "Int_MemBarrier", ":", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\"\\t#MEMBARRIER\"", ")", ")", ";", "return", ";", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "OutStreamer", ".", "AddComment", "(", "StringRef", "(", "\"eh_return, addr: %\"", ")", "+", "X86ATTInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ")", ";", "break", ";", "}", "case", "X86", "::", "TAILJMPr", ":", "case", "X86", "::", "TAILJMPd", ":", "case", "X86", "::", "TAILJMPd64", ":", "OutStreamer", ".", "AddComment", "(", "\"TAILCALL\"", ")", ";", "break", ";", "case", "X86", "::", "TLS_addr32", ":", "case", "X86", "::", "TLS_addr64", ":", "case", "X86", "::", "TLS_base_addr32", ":", "case", "X86", "::", "TLS_base_addr64", ":", "return", "LowerTlsAddr", "(", "OutStreamer", ",", "MCInstLowering", ",", "*", "MI", ")", ";", "case", "X86", "::", "MOVPC32r", ":", "{", "MCSymbol", "*", "PICBase", "=", "MF", "->", "getPICBaseSymbol", "(", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "CALLpcrel32", ")", ".", "addExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "PICBase", ",", "OutContext", ")", ")", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "PICBase", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "POP32r", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "return", ";", "}", "case", "X86", "::", "ADD32ri", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getTargetFlags", "(", ")", "!=", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", "break", ";", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "CreateTempSymbol", "(", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "DotSym", ")", ";", "MCSymbol", "*", "OpSym", "=", "MCInstLowering", ".", "GetSymbolFromOperand", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "Create", "(", "DotSym", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PICBase", "=", "MCSymbolRefExpr", "::", "Create", "(", "MF", "->", "getPICBaseSymbol", "(", ")", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateSub", "(", "DotExpr", ",", "PICBase", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "MCSymbolRefExpr", "::", "Create", "(", "OpSym", ",", "OutContext", ")", ",", "DotExpr", ",", "OutContext", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "ADD32ri", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addExpr", "(", "DotExpr", ")", ")", ";", "return", ";", "}", "case", "TargetOpcode", "::", "STACKMAP", ":", "return", "LowerSTACKMAP", "(", "OutStreamer", ",", "MCInstLowering", ",", "SM", ",", "*", "MI", ")", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "LowerPATCHPOINT", "(", "OutStreamer", ",", "MCInstLowering", ",", "SM", ",", "*", "MI", ")", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Should be handled target independently\"", "X86::Int_MemBarrier", "\"\\t#MEMBARRIER\"", "X86::EH_RETURN", "X86::EH_RETURN64", "0", "\"eh_return, addr: %\"", "X86", "X86::TAILJMPr", "X86::TAILJMPd", "X86::TAILJMPd64", "\"TAILCALL\"", "X86::TLS_addr32", "X86::TLS_addr64", "X86::TLS_base_addr32", "X86::TLS_base_addr64", "X86::MOVPC32r", "X86::CALLpcrel32", "X86::POP32r", "0", "X86::ADD32ri", "2", "X86II::MO_GOT_ABSOLUTE_ADDRESS", "2", "X86::ADD32ri", "0", "1" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "rewriteFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "void", "m32r_expand_epilogue", "(", "void", ")", "{", "int", "regno", ";", "int", "noepilogue", "=", "FALSE", ";", "int", "total_size", ";", "gcc_assert", "(", "current_frame_info", ".", "initialized", ")", ";", "total_size", "=", "current_frame_info", ".", "total_size", ";", "if", "(", "total_size", "==", "0", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "if", "(", "insn", "&&", "NOTE_P", "(", "insn", ")", ")", "insn", "=", "prev_nonnote_insn", "(", "insn", ")", ";", "if", "(", "insn", "&&", "BARRIER_P", "(", "insn", ")", ")", "noepilogue", "=", "TRUE", ";", "}", "if", "(", "!", "noepilogue", ")", "{", "unsigned", "int", "var_size", "=", "current_frame_info", ".", "var_size", ";", "unsigned", "int", "args_size", "=", "current_frame_info", ".", "args_size", ";", "unsigned", "int", "gmask", "=", "current_frame_info", ".", "gmask", ";", "int", "can_trust_sp_p", "=", "!", "cfun", "->", "calls_alloca", ";", "if", "(", "flag_exceptions", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "can_trust_sp_p", ")", "{", "unsigned", "int", "reg_offset", "=", "var_size", "+", "args_size", ";", "if", "(", "reg_offset", "==", "0", ")", ";", "else", "if", "(", "reg_offset", "<", "32768", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "reg_offset", ")", ")", ")", ";", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "GEN_INT", "(", "reg_offset", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "}", "}", "else", "if", "(", "frame_pointer_needed", ")", "{", "unsigned", "int", "reg_offset", "=", "var_size", "+", "args_size", ";", "if", "(", "reg_offset", "==", "0", ")", "emit_insn", "(", "gen_movsi", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ")", ";", "else", "if", "(", "reg_offset", "<", "32768", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ",", "GEN_INT", "(", "reg_offset", ")", ")", ")", ";", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "GEN_INT", "(", "reg_offset", ")", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "current_frame_info", ".", "save_lr", ")", "pop", "(", "RETURN_ADDR_REGNUM", ")", ";", "gmask", "&=", "~", "(", "FRAME_POINTER_MASK", "|", "RETURN_ADDR_MASK", ")", ";", "for", "(", "regno", "=", "M32R_MAX_INT_REGS", "-", "1", ";", "regno", ">=", "0", ";", "--", "regno", ")", "{", "if", "(", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", "!=", "0", ")", "pop", "(", "regno", ")", ";", "}", "if", "(", "current_frame_info", ".", "save_fp", ")", "pop", "(", "FRAME_POINTER_REGNUM", ")", ";", "if", "(", "current_frame_info", ".", "pretend_size", "!=", "0", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "current_frame_info", ".", "pretend_size", ")", ")", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "the", "m32r", "epilogue", "as", "a", "series", "of", "insns", "." ]

[ "m32r", "0", "0", "32768", "0", "32768", "1", "0", "1L", "0", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "}", "</s>" ]

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

[ "R600" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "frv_init_machine_status", "(", "void", ")", "{", "return", "ggc_alloc_cleared", "(", "sizeof", "(", "struct", "machine_function", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "set", "up", "the", "backend", "function", "structure", "." ]

[ "frv" ]

[]

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

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

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "M68kExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "M68kSubtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "M68k" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "unsigned", "Size", "=", "1", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "Value", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "(", "Size", "-", "i", "-", "1", ")", "*", "8", ")", ")", ";", "}", "</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", "." ]

[ "M680x0", "1", "\"Invalid fixup offset!\"", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "1", "8" ]

[]

[ "<s>", "const", "uint32_t", "*", "PPCRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_RegMask", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_RegMask", ":", "CSR_Darwin64_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_RegMask", ":", "CSR_Darwin32_RegMask", ")", ";", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "assert", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "\"Altivec is not implemented on AIX yet.\"", ")", ";", "return", "TM", ".", "isPPC64", "(", ")", "?", "CSR_AIX64_RegMask", ":", "CSR_AIX32_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "Cold", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR64_ColdCC_Altivec_RegMask", ":", "CSR_SVR64_ColdCC_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_RegMask", ":", "CSR_SVR32_ColdCC_RegMask", ")", ";", "}", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR464_Altivec_RegMask", ":", "CSR_SVR464_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_RegMask", ":", "CSR_SVR432_RegMask", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "\"Altivec is not implemented on AIX yet.\"", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This eliminateFrameIndex does not support Thumb1!\"", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", "=", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "if", "(", "FrameReg", "!=", "ARM", "::", "SP", ")", "SPAdj", "=", "0", ";", "Offset", "+=", "SPAdj", ";", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "}", "if", "(", "Done", ")", "return", "0", ";", "assert", "(", "(", "Offset", "||", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", "==", "ARMII", "::", "AddrMode4", "||", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", "==", "ARMII", "::", "AddrMode6", ")", "&&", "\"This code isn't needed if offset already handled!\"", ")", ";", "unsigned", "ScratchReg", "=", "0", ";", "int", "PIdx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "ARMCC", "::", "CondCodes", "Pred", "=", "(", "PIdx", "==", "-", "1", ")", "?", "ARMCC", "::", "AL", ":", "(", "ARMCC", "::", "CondCodes", ")", "MI", ".", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "PredReg", "=", "(", "PIdx", "==", "-", "1", ")", "?", "0", ":", "MI", ".", "getOperand", "(", "PIdx", "+", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "==", "0", ")", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "false", ")", ";", "else", "{", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "ARM", "::", "GPRRegisterClass", ")", ";", "if", "(", "Value", ")", "*", "Value", "=", "Offset", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "emitARMRegPlusImmediate", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "Pred", ",", "PredReg", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "emitT2RegPlusImmediate", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "Pred", ",", "PredReg", ",", "TII", ")", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "if", "(", "!", "ReuseFrameIndexVals", ")", "ScratchReg", "=", "0", ";", "}", "return", "ScratchReg", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "ARM", "ARM", "\"This eliminateFrameIndex does not support Thumb1!\"", "\"Instr doesn't have FrameIndex operand!\"", "ARM::SP", "0", "ARM", "0", "ARMII::AddrModeMask", "ARMII::AddrMode4", "ARMII::AddrModeMask", "ARMII::AddrMode6", "\"This code isn't needed if offset already handled!\"", "0", "ARMCC::CondCodes", "1", "ARMCC::AL", "ARMCC::CondCodes", "1", "0", "1", "0", "ARM::GPRRegisterClass", "ARM", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_mode_dependent_address", "(", "const_rtx", "addr", ")", "{", "bool", "ret", "=", "rs6000_mode_dependent_address", "(", "addr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_mode_dependent_address: ret = %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ")", ";", "debug_rtx", "(", "addr", ")", ";", "return", "ret", ";", "}", "</s>" ]

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

[ "rs6000", "\"\\nrs6000_mode_dependent_address: ret = %s\\n\"", "\"true\"", "\"false\"" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "SICTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_SIC", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "SIC", "SIC", "ISD::OutputArg", "16", "SIC" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "{", "PM", ".", "add", "(", "createSSEDomainFixPass", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PPCMCExpr", "::", "evaluateAsConstant", "(", "int64_t", "&", "Res", ")", "const", "{", "MCValue", "Value", ";", "if", "(", "!", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "Value", ",", "nullptr", ",", "nullptr", ")", ")", "return", "false", ";", "if", "(", "!", "Value", ".", "isAbsolute", "(", ")", ")", "return", "false", ";", "Res", "=", "evaluateAsInt64", "(", "Value", ".", "getConstant", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Evaluates", "the", "fixup", "as", "a", "constant", "value", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "int", "arm_attr_length_move_neon", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "reg", ",", "mem", ",", "addr", ";", "int", "load", ";", "machine_mode", "mode", ";", "extract_insn_cached", "(", "insn", ")", ";", "if", "(", "REG_P", "(", "recog_data", ".", "operand", "[", "0", "]", ")", "&&", "REG_P", "(", "recog_data", ".", "operand", "[", "1", "]", ")", ")", "{", "mode", "=", "GET_MODE", "(", "recog_data", ".", "operand", "[", "0", "]", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_EImode", ":", "case", "E_OImode", ":", "return", "8", ";", "case", "E_CImode", ":", "return", "12", ";", "case", "E_XImode", ":", "return", "16", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "load", "=", "REG_P", "(", "recog_data", ".", "operand", "[", "0", "]", ")", ";", "reg", "=", "recog_data", ".", "operand", "[", "!", "load", "]", ";", "mem", "=", "recog_data", ".", "operand", "[", "load", "]", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "LABEL_REF_P", "(", "addr", ")", "||", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "int", "insns", "=", "REG_NREGS", "(", "reg", ")", "/", "2", ";", "return", "insns", "*", "4", ";", "}", "else", "return", "4", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "length", "of", "neon_mov", "<", "mode", ">", ",", "where", "<", "mode", ">", "is", "one", "of", "VSTRUCT", "modes", ":", "EI", ",", "OI", ",", "CI", "or", "XI", "." ]

[ "arm", "0", "1", "0", "8", "12", "16", "0", "0", "0", "0", "2", "4", "4" ]

[]

[ "<s>", "static", "void", "vector_init_bshuffle", "(", "rtx", "target", ",", "rtx", "elt", ",", "machine_mode", "mode", ",", "machine_mode", "inner_mode", ")", "{", "rtx", "t1", ",", "final_insn", ",", "sel", ";", "int", "bmask", ";", "t1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "elt", "=", "convert_modes", "(", "SImode", ",", "inner_mode", ",", "elt", ",", "true", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "SImode", ",", "t1", ")", ",", "elt", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V2SImode", ":", "final_insn", "=", "gen_bshufflev2si_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x45674567", ";", "break", ";", "case", "E_V4HImode", ":", "final_insn", "=", "gen_bshufflev4hi_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x67676767", ";", "break", ";", "case", "E_V8QImode", ":", "final_insn", "=", "gen_bshufflev8qi_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x77777777", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sel", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "bmask", ")", ")", ";", "emit_insn", "(", "gen_bmasksi_vis", "(", "gen_reg_rtx", "(", "SImode", ")", ",", "sel", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "final_insn", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "sparc_expand_vector_init", ".", "Emit", "code", "to", "initialize", "all", "fields", "of", "TARGET", "to", "ELT", "by", "means", "of", "VIS2", "BSHUFFLE", "insn", ".", "MODE", "and", "INNER_MODE", "are", "the", "modes", "describing", "TARGET", "." ]

[ "sparc", "0x45674567", "0x67676767", "0x77777777" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "getOriginalFunctionArgs", "(", "DAG", ",", "MF", ".", "getFunction", "(", ")", ",", "Ins", ",", "LocalIns", ")", ";", "AnalyzeFormalArguments", "(", "CCInfo", ",", "LocalIns", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "MFI", "->", "getShaderType", "(", ")", "!=", "ShaderType", "::", "COMPUTE", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "AMDGPU", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "CONSTANT_BUFFER_0", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Offset", "=", "36", "+", "VA", ".", "getLocMemOffset", "(", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "Offset", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "false", ",", "true", ",", "true", ",", "4", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "MFI", "->", "ABIArgOffset", "=", "Offset", "+", "MemVT", ".", "getStoreSize", "(", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "R600", "ISD::InputArg", "16", "ISD::InputArg", "8", "0", "ISD::InputArg", "AMDGPUAS::CONSTANT_BUFFER_0", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "36", "ISD::UNINDEXED", "MVT::i32", "MVT::i32", "4" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "Val", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "false", ";", "EVT", "VT1", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "!", "VT1", ".", "isSimple", "(", ")", "||", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isSimple", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "switch", "(", "VT1", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ISD::LOAD", "MVT::i1", "MVT::i8", "MVT::i16" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createAArch64ExpandPseudoPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "}", "addPass", "(", "createAArch64SpeculationHardeningPass", "(", ")", ")", ";", "addPass", "(", "createAArch64IndirectThunks", "(", ")", ")", ";", "addPass", "(", "createAArch64SLSHardeningPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorHWPFFixPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "PPCRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "&", "PPC", "::", "G8RCRegClass", ";", "return", "&", "PPC", "::", "GPRCRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

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

[]

[ "<s>", "unsigned", "SystemZTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "Op", ".", "getResNo", "(", ")", "!=", "0", ")", "return", "1", ";", "unsigned", "Opcode", "=", "Op", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", ")", "{", "unsigned", "Id", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "Id", ")", "{", "case", "Intrinsic", "::", "s390_vpksh", ":", "case", "Intrinsic", "::", "s390_vpksf", ":", "case", "Intrinsic", "::", "s390_vpksg", ":", "case", "Intrinsic", "::", "s390_vpkshs", ":", "case", "Intrinsic", "::", "s390_vpksfs", ":", "case", "Intrinsic", "::", "s390_vpksgs", ":", "case", "Intrinsic", "::", "s390_vpklsh", ":", "case", "Intrinsic", "::", "s390_vpklsf", ":", "case", "Intrinsic", "::", "s390_vpklsg", ":", "case", "Intrinsic", "::", "s390_vpklshs", ":", "case", "Intrinsic", "::", "s390_vpklsfs", ":", "case", "Intrinsic", "::", "s390_vpklsgs", ":", "case", "Intrinsic", "::", "s390_vpdi", ":", "case", "Intrinsic", "::", "s390_vsldb", ":", "case", "Intrinsic", "::", "s390_vperm", ":", "return", "computeNumSignBitsBinOp", "(", "Op", ",", "DemandedElts", ",", "DAG", ",", "Depth", ",", "1", ")", ";", "case", "Intrinsic", "::", "s390_vuphb", ":", "case", "Intrinsic", "::", "s390_vuphh", ":", "case", "Intrinsic", "::", "s390_vuphf", ":", "case", "Intrinsic", "::", "s390_vuplb", ":", "case", "Intrinsic", "::", "s390_vuplhw", ":", "case", "Intrinsic", "::", "s390_vuplf", ":", "{", "SDValue", "PackedOp", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "APInt", "SrcDemE", "=", "getDemandedSrcElements", "(", "Op", ",", "DemandedElts", ",", "1", ")", ";", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "PackedOp", ",", "SrcDemE", ",", "Depth", "+", "1", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "unsigned", "VTBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "Tmp", "+=", "VTBits", "-", "PackedOp", ".", "getScalarValueSizeInBits", "(", ")", ";", "return", "Tmp", ";", "}", "default", ":", "break", ";", "}", "}", "else", "{", "switch", "(", "Opcode", ")", "{", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "return", "computeNumSignBitsBinOp", "(", "Op", ",", "DemandedElts", ",", "DAG", ",", "Depth", ",", "0", ")", ";", "default", ":", "break", ";", "}", "}", "return", "1", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "1", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::s390_vpksh", "Intrinsic::s390_vpksf", "Intrinsic::s390_vpksg", "Intrinsic::s390_vpkshs", "Intrinsic::s390_vpksfs", "Intrinsic::s390_vpksgs", "Intrinsic::s390_vpklsh", "Intrinsic::s390_vpklsf", "Intrinsic::s390_vpklsg", "Intrinsic::s390_vpklshs", "Intrinsic::s390_vpklsfs", "Intrinsic::s390_vpklsgs", "Intrinsic::s390_vpdi", "Intrinsic::s390_vsldb", "Intrinsic::s390_vperm", "1", "Intrinsic::s390_vuphb", "Intrinsic::s390_vuphh", "Intrinsic::s390_vuphf", "Intrinsic::s390_vuplb", "Intrinsic::s390_vuplhw", "Intrinsic::s390_vuplf", "1", "1", "1", "SystemZISD::SELECT_CCMASK", "0", "1" ]

[]

[ "<s>", "static", "void", "arm_function_arg_advance", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "aapcs_layout_arg", "(", "pcum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ")", ";", "if", "(", "pcum", "->", "aapcs_cprc_slot", ">=", "0", ")", "{", "aapcs_cp_arg_layout", "[", "pcum", "->", "aapcs_cprc_slot", "]", ".", "advance", "(", "pcum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "pcum", "->", "aapcs_cprc_slot", "=", "-", "1", ";", "}", "pcum", "->", "aapcs_arg_processed", "=", "false", ";", "pcum", "->", "aapcs_ncrn", "=", "pcum", "->", "aapcs_next_ncrn", ";", "pcum", "->", "aapcs_reg", "=", "NULL_RTX", ";", "pcum", "->", "aapcs_partial", "=", "0", ";", "}", "else", "{", "pcum", "->", "nargs", "+=", "1", ";", "if", "(", "arm_vector_mode_supported_p", "(", "arg", ".", "mode", ")", "&&", "pcum", "->", "named_count", ">", "pcum", "->", "nargs", "&&", "TARGET_IWMMXT_ABI", ")", "pcum", "->", "iwmmxt_nregs", "+=", "1", ";", "else", "pcum", "->", "nregs", "+=", "ARM_NUM_REGS2", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "}", "}", "</s>" ]

[ "Update", "the", "data", "in", "PCUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

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

[]

[ "<s>", "MCELFStreamer", "&", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "PowerPC" ]

[]

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

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "CAHP" ]

[]

[ "<s>", "bool", "HexagonStoreWidening", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFn", ")", "{", "if", "(", "skipFunction", "(", "*", "MFn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MF", "=", "&", "MFn", ";", "auto", "&", "ST", "=", "MFn", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MFn", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "B", ":", "MFn", ")", "Changed", "|=", "processBasicBlock", "(", "B", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "Twine", "(", "'@'", ")", "+", "MF", ".", "getName", "(", ")", "+", "Twine", "(", "':'", ")", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "const", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "ConfigSection", ")", ";", "const", "AMDGPUSubtarget", "&", "STM", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "SIProgramInfo", "KernelInfo", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "findNumUsedRegistersSI", "(", "MF", ",", "KernelInfo", ".", "NumSGPR", ",", "KernelInfo", ".", "NumVGPR", ")", ";", "EmitProgramInfoSI", "(", "MF", ",", "KernelInfo", ")", ";", "}", "else", "{", "EmitProgramInfoR600", "(", "MF", ")", ";", "}", "DisasmLines", ".", "clear", "(", ")", ";", "HexLines", ".", "clear", "(", ")", ";", "DisasmLineMaxLen", "=", "0", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "EmitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "const", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.csdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "CommentSection", ")", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "OutStreamer", ".", "emitRawComment", "(", "\" Kernel info:\"", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" NumSgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumSGPR", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" NumVgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumVGPR", ")", ",", "false", ")", ";", "}", "else", "{", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "Twine", "(", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "+", "Twine", "(", "MFI", "->", "StackSize", ")", ")", ")", ";", "}", "}", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "MF", ".", "dump", "(", ")", ";", "if", "(", "DisasmEnabled", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "Context", ".", "getELFSection", "(", "\".AMDGPU.disasm\"", ",", "ELF", "::", "SHT_NOTE", ",", "0", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "DisasmLines", ".", "size", "(", ")", ";", "++", "i", ")", "{", "std", "::", "string", "Comment", "(", "DisasmLineMaxLen", "-", "DisasmLines", "[", "i", "]", ".", "size", "(", ")", ",", "' '", ")", ";", "Comment", "+=", "\" ; \"", "+", "HexLines", "[", "i", "]", "+", "\"\\n\"", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "DisasmLines", "[", "i", "]", ")", ")", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "Comment", ")", ")", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "\".AMDGPU.config\"", "0", "SI", "SI", "SI", "0", "\".AMDGPU.csdata\"", "0", "\" Kernel info:\"", "\" NumSgprs: \"", "\" NumVgprs: \"", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "\".AMDGPU.disasm\"", "0", "0", "\" ; \"", "\"\\n\"" ]

[]

[ "<s>", "InstructionCost", "AArch64TTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "APInt", "ImmVal", "=", "Imm", ";", "if", "(", "BitSize", "&", "0x3f", ")", "ImmVal", "=", "Imm", ".", "sext", "(", "(", "BitSize", "+", "63", ")", "&", "~", "0x3fU", ")", ";", "InstructionCost", "Cost", "=", "0", ";", "for", "(", "unsigned", "ShiftVal", "=", "0", ";", "ShiftVal", "<", "BitSize", ";", "ShiftVal", "+=", "64", ")", "{", "APInt", "Tmp", "=", "ImmVal", ".", "ashr", "(", "ShiftVal", ")", ".", "sextOrTrunc", "(", "64", ")", ";", "int64_t", "Val", "=", "Tmp", ".", "getSExtValue", "(", ")", ";", "Cost", "+=", "getIntImmCost", "(", "Val", ")", ";", "}", "return", "std", "::", "max", "<", "InstructionCost", ">", "(", "1", ",", "Cost", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "0U", "0x3f", "63", "0x3fU", "0", "0", "64", "64", "1" ]

[]

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

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

[ "MOS" ]

[]

[ "<s>", "void", "WaitcntBrackets", "::", "print", "(", "raw_ostream", "&", "OS", ")", "{", "OS", "<<", "'\\n'", ";", "for", "(", "auto", "T", ":", "inst_counter_types", "(", ")", ")", "{", "unsigned", "LB", "=", "getScoreLB", "(", "T", ")", ";", "unsigned", "UB", "=", "getScoreUB", "(", "T", ")", ";", "switch", "(", "T", ")", "{", "case", "VM_CNT", ":", "OS", "<<", "\" VM_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "case", "LGKM_CNT", ":", "OS", "<<", "\" LGKM_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "case", "EXP_CNT", ":", "OS", "<<", "\" EXP_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "case", "VS_CNT", ":", "OS", "<<", "\" VS_CNT(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "default", ":", "OS", "<<", "\" UNKNOWN(\"", "<<", "UB", "-", "LB", "<<", "\"): \"", ";", "break", ";", "}", "if", "(", "LB", "<", "UB", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "VgprUB", ";", "J", "++", ")", "{", "unsigned", "RegScore", "=", "getRegScore", "(", "J", ",", "T", ")", ";", "if", "(", "RegScore", "<=", "LB", ")", "continue", ";", "unsigned", "RelScore", "=", "RegScore", "-", "LB", "-", "1", ";", "if", "(", "J", "<", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ")", "{", "OS", "<<", "RelScore", "<<", "\":v\"", "<<", "J", "<<", "\" \"", ";", "}", "else", "{", "OS", "<<", "RelScore", "<<", "\":ds \"", ";", "}", "}", "if", "(", "T", "==", "LGKM_CNT", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "SgprUB", ";", "J", "++", ")", "{", "unsigned", "RegScore", "=", "getRegScore", "(", "J", "+", "NUM_ALL_VGPRS", ",", "LGKM_CNT", ")", ";", "if", "(", "RegScore", "<=", "LB", ")", "continue", ";", "unsigned", "RelScore", "=", "RegScore", "-", "LB", "-", "1", ";", "OS", "<<", "RelScore", "<<", "\":s\"", "<<", "J", "<<", "\" \"", ";", "}", "}", "}", "OS", "<<", "'\\n'", ";", "}", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AMDGPU", "\" VM_CNT(\"", "\"): \"", "\" LGKM_CNT(\"", "\"): \"", "\" EXP_CNT(\"", "\"): \"", "\" VS_CNT(\"", "\"): \"", "\" UNKNOWN(\"", "\"): \"", "0", "1", "\":v\"", "\" \"", "\":ds \"", "0", "1", "\":s\"", "\" \"" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "{", "if", "(", "TLI", ".", "isPositionIndependent", "(", ")", ")", "return", "0", ";", "if", "(", "GV", "->", "isThreadLocal", "(", ")", ")", "return", "0", ";", "Register", "ResultReg", "=", "createResultReg", "(", "Subtarget", "->", "hasAddr64", "(", ")", "?", "&", "WebAssembly", "::", "I64RegClass", ":", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "unsigned", "Opc", "=", "Subtarget", "->", "hasAddr64", "(", ")", "?", "WebAssembly", "::", "CONST_I64", ":", "WebAssembly", "::", "CONST_I32", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addGlobalAddress", "(", "GV", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

[ "WebAssembly", "WebAssembly", "0", "0", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass", "WebAssembly::CONST_I64", "WebAssembly::CONST_I32", "0" ]

[]

[ "<s>", "void", "AArch64AppleInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "StringRef", "Layout", ",", "Mnemonic", ";", "bool", "IsTbx", ";", "if", "(", "isTblTbxInstruction", "(", "MI", "->", "getOpcode", "(", ")", ",", "Layout", ",", "IsTbx", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "(", "IsTbx", "?", "\"tbx\"", ":", "\"tbl\"", ")", "<<", "Layout", "<<", "'\\t'", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", "<<", "\", \"", ";", "unsigned", "ListOpNum", "=", "IsTbx", "?", "2", ":", "1", ";", "printVectorList", "(", "MI", ",", "ListOpNum", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "ListOpNum", "+", "1", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "const", "LdStNInstrDesc", "*", "LdStDesc", "=", "getLdStNInstrDesc", "(", "Opcode", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "LdStDesc", "->", "Mnemonic", "<<", "LdStDesc", "->", "Layout", "<<", "'\\t'", ";", "int", "OpNum", "=", "LdStDesc", "->", "ListOperand", ";", "printVectorList", "(", "MI", ",", "OpNum", "++", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "if", "(", "LdStDesc", "->", "HasLane", ")", "O", "<<", "'['", "<<", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getImm", "(", ")", "<<", "']'", ";", "unsigned", "AddrReg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "O", "<<", "\", [\"", "<<", "getRegisterName", "(", "AddrReg", ")", "<<", "']'", ";", "if", "(", "LdStDesc", "->", "NaturalOffset", "!=", "0", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "AArch64", "::", "XZR", ")", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "Reg", ")", ";", "else", "{", "assert", "(", "LdStDesc", "->", "NaturalOffset", "&&", "\"no offset on post-inc instruction?\"", ")", ";", "O", "<<", "\", #\"", "<<", "LdStDesc", "->", "NaturalOffset", ";", "}", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "AArch64InstPrinter", "::", "printInst", "(", "MI", ",", "O", ",", "Annot", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"\\t\"", "\"tbx\"", "\"tbl\"", "0", "AArch64::vreg", "\", \"", "2", "1", "\"\"", "\", \"", "1", "AArch64::vreg", "\"\\t\"", "\"\"", "\", [\"", "0", "AArch64::XZR", "\", \"", "\"no offset on post-inc instruction?\"", "\", #\"", "AArch64" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "FP", ")", "{", "unsigned", "FramePtr", "=", "XCore", "::", "R10", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "SETSP_1r", ")", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "FrameSize", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "FrameSize", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "FrameSize", ")", ")", "{", "report_fatal_error", "(", "\"emitEpilogue Frame size too big: \"", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "if", "(", "FrameSize", ")", "{", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "FPSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "R10", ",", "FPSpillOffset", ",", "dl", ")", ";", "}", "bool", "restoreLR", "=", "XFI", "->", "getUsesLR", "(", ")", ";", "if", "(", "restoreLR", "&&", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "!=", "0", ")", "{", "int", "LRSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "LRSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "LR", ",", "LRSpillOffset", ",", "dl", ")", ";", "restoreLR", "=", "false", ";", "}", "if", "(", "restoreLR", ")", "{", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_u6", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_lu6", ")", ";", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "RETSP_u6", ":", "XCore", "::", "RETSP_lu6", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "LDAWSP_ru6_RRegs", ":", "XCore", "::", "LDAWSP_lru6_RRegs", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::R10", "XCore::SETSP_1r", "4", "0", "\"Misaligned frame size\"", "4", "\"emitEpilogue Frame size too big: \"", "XCore", "XCore", "4", "XCore::R10", "0", "4", "XCore::LR", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::LDAWSP_ru6_RRegs", "XCore::LDAWSP_lru6_RRegs", "XCore::SP" ]

[]

[ "<s>", "static", "void", "output_decl_chunk", "(", "void", ")", "{", "begin_decl_field", "(", ")", ";", "output_address", "(", "gen_int_mode", "(", "init_part", ",", "decl_chunk_mode", ")", ")", ";", "init_part", "=", "0", ";", "}", "</s>" ]

[ "Output", "the", "currently", "stored", "chunk", "as", "an", "initializer", "value", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "int", "memory_address_length", "(", "rtx", "addr", ",", "bool", "lea", ")", "{", "struct", "ix86_address", "parts", ";", "rtx", "base", ",", "index", ",", "disp", ";", "int", "len", ";", "int", "ok", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "addr", ")", "==", "POST_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", "||", "GET_CODE", "(", "addr", ")", "==", "POST_MODIFY", ")", "return", "0", ";", "ok", "=", "ix86_decompose_address", "(", "addr", ",", "&", "parts", ")", ";", "gcc_assert", "(", "ok", ")", ";", "len", "=", "(", "parts", ".", "seg", "==", "ADDR_SPACE_GENERIC", ")", "?", "0", ":", "1", ";", "if", "(", "TARGET_64BIT", "&&", "!", "lea", "&&", "(", "SImode_address_operand", "(", "addr", ",", "VOIDmode", ")", "||", "(", "parts", ".", "base", "&&", "GET_MODE", "(", "parts", ".", "base", ")", "==", "SImode", ")", "||", "(", "parts", ".", "index", "&&", "GET_MODE", "(", "parts", ".", "index", ")", "==", "SImode", ")", ")", ")", "len", "++", ";", "base", "=", "parts", ".", "base", ";", "index", "=", "parts", ".", "index", ";", "disp", "=", "parts", ".", "disp", ";", "if", "(", "base", "&&", "SUBREG_P", "(", "base", ")", ")", "base", "=", "SUBREG_REG", "(", "base", ")", ";", "if", "(", "index", "&&", "SUBREG_P", "(", "index", ")", ")", "index", "=", "SUBREG_REG", "(", "index", ")", ";", "gcc_assert", "(", "base", "==", "NULL_RTX", "||", "REG_P", "(", "base", ")", ")", ";", "gcc_assert", "(", "index", "==", "NULL_RTX", "||", "REG_P", "(", "index", ")", ")", ";", "if", "(", "base", "&&", "!", "index", "&&", "!", "disp", ")", "{", "if", "(", "base", "==", "arg_pointer_rtx", "||", "base", "==", "frame_pointer_rtx", "||", "REGNO", "(", "base", ")", "==", "SP_REG", "||", "REGNO", "(", "base", ")", "==", "BP_REG", "||", "REGNO", "(", "base", ")", "==", "R12_REG", "||", "REGNO", "(", "base", ")", "==", "R13_REG", ")", "len", "++", ";", "}", "else", "if", "(", "disp", "&&", "!", "base", "&&", "!", "index", ")", "{", "len", "+=", "4", ";", "if", "(", "rip_relative_addr_p", "(", "&", "parts", ")", ")", "len", "++", ";", "}", "else", "{", "if", "(", "disp", ")", "{", "if", "(", "base", "&&", "satisfies_constraint_K", "(", "disp", ")", ")", "len", "+=", "1", ";", "else", "len", "+=", "4", ";", "}", "else", "if", "(", "base", "&&", "(", "REGNO", "(", "base", ")", "==", "BP_REG", "||", "REGNO", "(", "base", ")", "==", "R13_REG", ")", ")", "len", "++", ";", "if", "(", "index", "||", "base", "==", "arg_pointer_rtx", "||", "base", "==", "frame_pointer_rtx", "||", "(", "base", "&&", "(", "REGNO", "(", "base", ")", "==", "SP_REG", "||", "REGNO", "(", "base", ")", "==", "R12_REG", ")", ")", ")", "len", "++", ";", "}", "return", "len", ";", "}", "</s>" ]

[ "Calculate", "the", "length", "of", "the", "memory", "address", "in", "the", "instruction", "encoding", ".", "Does", "not", "include", "the", "one-byte", "modrm", ",", "opcode", ",", "or", "prefix", "." ]

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

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ")", ")", "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", "." ]

[ "RISCV", "RISCV", "RISCV", "\"unexpected token\"" ]

[]

[ "<s>", "static", "int", "ix86_adjust_cost", "(", "rtx", "insn", ",", "rtx", "link", ",", "rtx", "dep_insn", ",", "int", "cost", ")", "{", "enum", "attr_type", "insn_type", ",", "dep_insn_type", ";", "enum", "attr_memory", "memory", ";", "rtx", "set", ",", "set2", ";", "int", "dep_insn_code_number", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "!=", "0", ")", "return", "0", ";", "dep_insn_code_number", "=", "recog_memoized", "(", "dep_insn", ")", ";", "if", "(", "dep_insn_code_number", "<", "0", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "cost", ";", "insn_type", "=", "get_attr_type", "(", "insn", ")", ";", "dep_insn_type", "=", "get_attr_type", "(", "dep_insn", ")", ";", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_PENTIUM", ":", "if", "(", "ix86_agi_dependant", "(", "insn", ",", "dep_insn", ",", "insn_type", ")", ")", "cost", "+=", "1", ";", "if", "(", "ix86_flags_dependant", "(", "insn", ",", "dep_insn", ",", "insn_type", ")", ")", "cost", "=", "0", ";", "if", "(", "insn_type", "==", "TYPE_FMOV", "&&", "get_attr_memory", "(", "insn", ")", "==", "MEMORY_STORE", "&&", "!", "ix86_agi_dependant", "(", "insn", ",", "dep_insn", ",", "insn_type", ")", ")", "cost", "+=", "1", ";", "break", ";", "case", "PROCESSOR_PENTIUMPRO", ":", "memory", "=", "get_attr_memory", "(", "insn", ")", ";", "if", "(", "get_attr_fp_int_src", "(", "dep_insn", ")", ")", "cost", "+=", "5", ";", "if", "(", "insn_type", "==", "TYPE_FMOV", "&&", "(", "set", "=", "single_set", "(", "dep_insn", ")", ")", "!=", "NULL_RTX", "&&", "(", "set2", "=", "single_set", "(", "insn", ")", ")", "!=", "NULL_RTX", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "set2", ")", ")", "&&", "GET_CODE", "(", "SET_DEST", "(", "set2", ")", ")", "==", "MEM", ")", "cost", "+=", "1", ";", "if", "(", "(", "memory", "==", "MEMORY_LOAD", "||", "memory", "==", "MEMORY_BOTH", ")", "&&", "!", "ix86_agi_dependant", "(", "insn", ",", "dep_insn", ",", "insn_type", ")", ")", "{", "if", "(", "dep_insn_type", "==", "TYPE_IMOV", "||", "dep_insn_type", "==", "TYPE_FMOV", ")", "cost", "=", "1", ";", "else", "if", "(", "cost", ">", "1", ")", "cost", "--", ";", "}", "break", ";", "case", "PROCESSOR_K6", ":", "memory", "=", "get_attr_memory", "(", "insn", ")", ";", "if", "(", "(", "insn_type", "==", "TYPE_PUSH", "||", "insn_type", "==", "TYPE_POP", ")", "&&", "(", "dep_insn_type", "==", "TYPE_PUSH", "||", "dep_insn_type", "==", "TYPE_POP", ")", ")", "return", "1", ";", "if", "(", "get_attr_fp_int_src", "(", "dep_insn", ")", ")", "cost", "+=", "5", ";", "if", "(", "(", "memory", "==", "MEMORY_LOAD", "||", "memory", "==", "MEMORY_BOTH", ")", "&&", "!", "ix86_agi_dependant", "(", "insn", ",", "dep_insn", ",", "insn_type", ")", ")", "{", "if", "(", "dep_insn_type", "==", "TYPE_IMOV", "||", "dep_insn_type", "==", "TYPE_FMOV", ")", "cost", "=", "1", ";", "else", "if", "(", "cost", ">", "2", ")", "cost", "-=", "2", ";", "else", "cost", "=", "1", ";", "}", "break", ";", "case", "PROCESSOR_ATHLON", ":", "case", "PROCESSOR_K8", ":", "memory", "=", "get_attr_memory", "(", "insn", ")", ";", "if", "(", "(", "memory", "==", "MEMORY_LOAD", "||", "memory", "==", "MEMORY_BOTH", ")", "&&", "!", "ix86_agi_dependant", "(", "insn", ",", "dep_insn", ",", "insn_type", ")", ")", "{", "enum", "attr_unit", "unit", "=", "get_attr_unit", "(", "insn", ")", ";", "int", "loadcost", "=", "3", ";", "if", "(", "unit", "==", "UNIT_INTEGER", "||", "unit", "==", "UNIT_UNKNOWN", ")", "loadcost", "=", "3", ";", "else", "loadcost", "=", "TARGET_ATHLON", "?", "2", ":", "0", ";", "if", "(", "cost", ">=", "loadcost", ")", "cost", "-=", "loadcost", ";", "else", "cost", "=", "0", ";", "}", "default", ":", "break", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "This", "function", "corrects", "the", "value", "of", "COST", "(", "latency", ")", "based", "on", "the", "relationship", "between", "INSN", "and", "DEP_INSN", "through", "a", "dependence", "of", "type", "DEP_TYPE", ",", "and", "strength", "DW", ".", "It", "should", "return", "the", "new", "value", ".", "On", "x86", "CPUs", "this", "is", "most", "commonly", "used", "to", "model", "the", "fact", "that", "valus", "of", "registers", "used", "to", "compute", "address", "of", "memory", "operand", "needs", "to", "be", "ready", "earlier", "than", "values", "of", "registers", "used", "in", "the", "actual", "operation", "." ]

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

[]

[ "<s>", "void", "assignValueToReg", "(", "unsigned", "ValVReg", ",", "unsigned", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", "<=", "32", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "==", "32", "&&", "\"Unsupported location size\"", ")", ";", "assert", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "SExt", "&&", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "ZExt", "&&", "\"ABI extensions not supported yet\"", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ValVReg", ")", ";", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "</s>" ]

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

[ "ARM", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "32", "\"Unsupported value size\"", "32", "\"Unsupported location size\"", "\"ABI extensions not supported yet\"" ]

[]

[ "<s>", "int", "AArch64LoadStoreOpt", "::", "getMemSize", "(", "MachineInstr", "*", "MemMI", ")", "{", "switch", "(", "MemMI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode has unknown size!\"", ")", ";", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STURSi", ":", "return", "4", ";", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STURDi", ":", "return", "8", ";", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STURQi", ":", "return", "16", ";", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STURWi", ":", "return", "4", ";", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STURXi", ":", "return", "8", ";", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDURSi", ":", "return", "4", ";", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDURDi", ":", "return", "8", ";", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDURQi", ":", "return", "16", ";", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDURWi", ":", "return", "4", ";", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDURXi", ":", "return", "8", ";", "case", "AArch64", "::", "LDRSWui", ":", "case", "AArch64", "::", "LDURSWi", ":", "return", "4", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "memory", "access", "." ]

[ "AArch64", "AArch64", "\"Opcode has unknown size!\"", "AArch64::STRSui", "AArch64::STURSi", "4", "AArch64::STRDui", "AArch64::STURDi", "8", "AArch64::STRQui", "AArch64::STURQi", "16", "AArch64::STRWui", "AArch64::STURWi", "4", "AArch64::STRXui", "AArch64::STURXi", "8", "AArch64::LDRSui", "AArch64::LDURSi", "4", "AArch64::LDRDui", "AArch64::LDURDi", "8", "AArch64::LDRQui", "AArch64::LDURQi", "16", "AArch64::LDRWui", "AArch64::LDURWi", "4", "AArch64::LDRXui", "AArch64::LDURXi", "8", "AArch64::LDRSWui", "AArch64::LDURSWi", "4" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".cpload\"", ")", "return", "parseDirectiveCPLoad", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".dword\"", ")", "{", "parseDataDirective", "(", "8", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".nan\"", ")", "return", "parseDirectiveNaN", "(", ")", ";", "if", "(", "IDVal", "==", "\".gpword\"", ")", "{", "parseDirectiveGpWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".gpdword\"", ")", "{", "parseDirectiveGpDWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".word\"", ")", "{", "parseDataDirective", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".option\"", ")", "return", "parseDirectiveOption", "(", ")", ";", "if", "(", "IDVal", "==", "\".abicalls\"", ")", "{", "getTargetStreamer", "(", ")", ".", "emitDirectiveAbiCalls", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"unexpected token in directive\"", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "}", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".cpsetup\"", ")", "return", "parseDirectiveCPSetup", "(", ")", ";", "if", "(", "IDVal", "==", "\".module\"", ")", "return", "parseDirectiveModule", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\".cpload\"", "\".dword\"", "8", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".nan\"", "\".gpword\"", "\".gpdword\"", "\".word\"", "4", "\".option\"", "\".abicalls\"", "\"unexpected token in directive\"", "\".cpsetup\"", "\".module\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "XCoreTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ",", "DenseMap", "<", "MachineBasicBlock", "*", ",", "MachineBasicBlock", "*", ">", "*", "EM", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "SELECT_CC", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "BRFT_lru6", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "I", "=", "BB", "->", "succ_begin", "(", ")", ",", "E", "=", "BB", "->", "succ_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "EM", "->", "insert", "(", "std", "::", "make_pair", "(", "*", "I", ",", "sinkMBB", ")", ")", ";", "sinkMBB", "->", "addSuccessor", "(", "*", "I", ")", ";", "}", "while", "(", "!", "BB", "->", "succ_empty", "(", ")", ")", "BB", "->", "removeSuccessor", "(", "BB", "->", "succ_begin", "(", ")", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "F", "->", "DeleteMachineInstr", "(", "MI", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::SELECT_CC", "\"Unexpected instr type to insert\"", "XCore::BRFT_lru6", "1", "XCore::PHI", "0", "3", "2" ]

[]

[ "<s>", "bool", "ARM64InstrInfo", "::", "isGPRZero", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM64", "::", "MOVZWi", ":", "case", "ARM64", "::", "MOVZXi", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"invalid MOVZi operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "case", "ARM64", "::", "ANDWri", ":", "return", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "ARM64", "::", "WZR", ";", "case", "ARM64", "::", "ANDXri", ":", "return", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "ARM64", "::", "XZR", ";", "case", "TargetOpcode", "::", "COPY", ":", "return", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "ARM64", "::", "WZR", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "set", "its", "full", "destination", "register", "to", "zero", "?" ]

[ "ARM64", "ARM64", "ARM64::MOVZWi", "ARM64::MOVZXi", "1", "1", "0", "3", "2", "0", "\"invalid MOVZi operands\"", "ARM64::ANDWri", "1", "ARM64::WZR", "ARM64::ANDXri", "1", "ARM64::XZR", "1", "ARM64::WZR" ]

[]

[ "<s>", "unsigned", "SNESInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "SNES", "::", "RJMPk", "&&", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", "==", "SNESCC", "::", "COND_INVALID", ")", "{", "break", ";", "}", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "SNES", "SNES", "0", "0", "SNES::RJMPk", "SNESCC::COND_INVALID" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_runtime_metadata\"", ")", "return", "ParseDirectiveRuntimeMetadata", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsatext\"", ")", "return", "ParseSectionDirectiveHSAText", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_kernel\"", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_module_global\"", ")", "return", "ParseDirectiveAMDGPUHsaModuleGlobal", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_program_global\"", ")", "return", "ParseDirectiveAMDGPUHsaProgramGlobal", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsadata_global_agent\"", ")", "return", "ParseSectionDirectiveHSADataGlobalAgent", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsadata_global_program\"", ")", "return", "ParseSectionDirectiveHSADataGlobalProgram", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsarodata_readonly_agent\"", ")", "return", "ParseSectionDirectiveHSARodataReadonlyAgent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amdgpu_runtime_metadata\"", "\".amd_kernel_code_t\"", "\".hsatext\"", "\".amdgpu_hsa_kernel\"", "AMDGPU", "\".amdgpu_hsa_module_global\"", "AMDGPU", "\".amdgpu_hsa_program_global\"", "AMDGPU", "\".hsadata_global_agent\"", "\".hsadata_global_program\"", "\".hsarodata_readonly_agent\"" ]

[]

[ "<s>", "static", "void", "output_init_frag", "(", "rtx", "sym", ")", "{", "fprintf", "(", "asm_out_file", ",", "init_frag", ".", "started", "?", "\", \"", ":", "\" = { \"", ")", ";", "unsigned", "HOST_WIDE_INT", "val", "=", "init_frag", ".", "val", ";", "init_frag", ".", "started", "=", "true", ";", "init_frag", ".", "val", "=", "0", ";", "init_frag", ".", "offset", "=", "0", ";", "init_frag", ".", "remaining", "--", ";", "if", "(", "sym", ")", "{", "bool", "function", "=", "(", "SYMBOL_REF_DECL", "(", "sym", ")", "&&", "(", "TREE_CODE", "(", "SYMBOL_REF_DECL", "(", "sym", ")", ")", "==", "FUNCTION_DECL", ")", ")", ";", "if", "(", "!", "function", ")", "fprintf", "(", "asm_out_file", ",", "\"generic(\"", ")", ";", "output_address", "(", "VOIDmode", ",", "sym", ")", ";", "if", "(", "!", "function", ")", "fprintf", "(", "asm_out_file", ",", "\")\"", ")", ";", "if", "(", "val", ")", "fprintf", "(", "asm_out_file", ",", "\" + \"", ")", ";", "}", "if", "(", "!", "sym", "||", "val", ")", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "val", ")", ";", "}", "</s>" ]

[ "The", "current", "fragment", "is", "full", ",", "write", "it", "out", ".", "SYM", "may", "provide", "a", "symbolic", "reference", "we", "should", "output", ",", "in", "which", "case", "the", "fragment", "value", "is", "the", "addend", "." ]

[ "nvptx", "\", \"", "\" = { \"", "0", "0", "\"generic(\"", "\")\"", "\" + \"" ]

[]

[ "<s>", "void", "cris_target_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", ")", "{", "if", "(", "!", "TARGET_ELF", ")", "default_no_named_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "else", "default_elf_asm_named_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "}", "</s>" ]

[ "The", "TARGET_ASM_NAMED_SECTION", "worker", ".", "We", "just", "dispatch", "to", "the", "functions", "for", "ELF", "and", "a.out", "." ]

[ "cris" ]

[]

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

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

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

[]

[ "<s>", "int", "addr32_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "rtx", "sym", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "TARGET_ADDR32", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "sym", "=", "op", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "!", "flag_pic", ")", "sym", "=", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "else", "return", "0", ";", "return", "(", "!", "addr24_operand", "(", "sym", ",", "mode", ")", "&&", "!", "small_data_operand", "(", "sym", ",", "mode", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "symbol", "that", "needs", "32", "bit", "addressing", "." ]

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

[]

[ "<s>", "void", "initialize", "(", "Attributor", "&", "A", ")", "override", "{", "Function", "*", "F", "=", "getAssociatedFunction", "(", ")", ";", "const", "bool", "NeedsImplicit", "=", "funcRequiresImplicitArgPtr", "(", "*", "F", ")", ";", "if", "(", "NeedsImplicit", ")", "removeAssumedBits", "(", "IMPLICIT_ARG_PTR", ")", ";", "for", "(", "auto", "Attr", ":", "ImplicitAttrs", ")", "{", "if", "(", "NeedsImplicit", "&&", "Attr", ".", "first", "==", "IMPLICIT_ARG_PTR", ")", "continue", ";", "if", "(", "F", "->", "hasFnAttribute", "(", "Attr", ".", "second", ")", ")", "addKnownBits", "(", "Attr", ".", "first", ")", ";", "}", "if", "(", "F", "->", "isDeclaration", "(", ")", ")", "return", ";", "if", "(", "AMDGPU", "::", "isGraphics", "(", "F", "->", "getCallingConv", "(", ")", ")", ")", "{", "indicatePessimisticFixpoint", "(", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "AMDGPU", "AMDGPU::isGraphics" ]

[]

[ "<s>", "static", "unsigned", "size", "(", "const", "MCallSubGraph", "&", "G", ")", "{", "return", "G", ".", "Nodes", ".", "size", "(", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "bool", "PatmosFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STC", ".", "getInstrInfo", "(", ")", ";", "PatmosMachineFunctionInfo", "&", "PMFI", "=", "*", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "spilledSize", "=", "0", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "if", "(", "Reg", "==", "Patmos", "::", "S0", "&&", "PMFI", ".", "getS0SpillReg", "(", ")", ")", "{", "TII", ".", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "PMFI", ".", "getS0SpillReg", "(", ")", ",", "Reg", ",", "true", ")", ";", "std", "::", "prev", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "continue", ";", "}", "if", "(", "Patmos", "::", "SRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "TII", ".", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "Patmos", "::", "R9", ",", "Reg", ",", "true", ")", ";", "std", "::", "prev", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Reg", "=", "Patmos", "::", "R9", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "std", "::", "prev", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "spilledSize", "+=", "4", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "Patmos", "0", "0", "1", "Patmos::PRegsRegClass", "Patmos::S0", "Patmos::SRegsRegClass", "Patmos::R9", "Patmos::R9", "1", "4" ]

[]

[ "<s>", "static", "bool", "nvptx_shared_propagate", "(", "bool", "pre_p", ",", "bool", "is_call", ",", "basic_block", "block", ",", "rtx_insn", "*", "insn", ",", "bool", "vector", ")", "{", "broadcast_data_t", "data", ";", "data", ".", "base", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "data", ".", "offset", "=", "0", ";", "data", ".", "ptr", "=", "NULL_RTX", ";", "bool", "empty", "=", "nvptx_propagate", "(", "is_call", ",", "block", ",", "insn", ",", "pre_p", "?", "PM_read", ":", "PM_write", ",", "shared_prop_gen", ",", "&", "data", ",", "vector", ")", ";", "gcc_assert", "(", "empty", "==", "!", "data", ".", "offset", ")", ";", "if", "(", "data", ".", "offset", ")", "{", "rtx", "bcast_sym", "=", "oacc_bcast_sym", ";", "if", "(", "vector", "&&", "nvptx_mach_max_workers", "(", ")", ">", "1", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "bcast_partition", ")", "{", "cfun", "->", "machine", "->", "bcast_partition", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "}", "if", "(", "!", "cfun", "->", "machine", "->", "sync_bar", ")", "cfun", "->", "machine", "->", "sync_bar", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "bcast_sym", "=", "cfun", "->", "machine", "->", "bcast_partition", ";", "}", "rtx", "init", "=", "gen_rtx_SET", "(", "data", ".", "base", ",", "bcast_sym", ")", ";", "emit_insn_after", "(", "init", ",", "insn", ")", ";", "unsigned", "int", "psize", "=", "ROUND_UP", "(", "data", ".", "offset", ",", "oacc_bcast_align", ")", ";", "unsigned", "int", "pnum", "=", "(", "nvptx_mach_vector_length", "(", ")", ">", "PTX_WARP_SIZE", "?", "nvptx_mach_max_workers", "(", ")", "+", "1", ":", "1", ")", ";", "oacc_bcast_partition", "=", "MAX", "(", "oacc_bcast_partition", ",", "psize", ")", ";", "oacc_bcast_size", "=", "MAX", "(", "oacc_bcast_size", ",", "psize", "*", "pnum", ")", ";", "}", "return", "empty", ";", "}", "</s>" ]

[ "Spill", "or", "fill", "live", "state", "that", "is", "live", "at", "start", "of", "BLOCK", ".", "PRE_P", "indicates", "if", "this", "is", "just", "before", "partitioned", "mode", "(", "do", "spill", ")", ",", "or", "just", "after", "it", "starts", "(", "do", "fill", ")", ".", "Sequence", "is", "inserted", "just", "after", "INSN", ".", "IS_CALL", "and", "return", "as", "for", "nvptx_propagate", "." ]

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

[]

[ "<s>", "bool", "ldstwm_operation_p", "(", "rtx", "op", ",", "bool", "load_p", ")", "{", "int", "start", ",", "i", ",", "end", "=", "XVECLEN", "(", "op", ",", "0", ")", "-", "1", ",", "last_regno", "=", "-", "1", ";", "unsigned", "int", "regset", "=", "0", ";", "rtx", "base_reg", ",", "offset", ";", "rtx", "first_elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "bool", "inc_p", "=", "true", ";", "bool", "wb_p", "=", "base_reg_adjustment_p", "(", "first_elt", ",", "&", "base_reg", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "0", ",", "end", ")", ")", "==", "RETURN", ")", "end", "--", ";", "start", "=", "wb_p", "?", "1", ":", "0", ";", "for", "(", "i", "=", "start", ";", "i", "<=", "end", ";", "i", "++", ")", "{", "int", "regno", ";", "rtx", "reg", ",", "mem", ",", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", ")", "return", "false", ";", "reg", "=", "load_p", "?", "SET_DEST", "(", "elt", ")", ":", "SET_SRC", "(", "elt", ")", ";", "mem", "=", "load_p", "?", "SET_SRC", "(", "elt", ")", ":", "SET_DEST", "(", "elt", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "!", "nios2_ldstwm_regset_p", "(", "regno", ",", "&", "regset", ")", ")", "return", "false", ";", "if", "(", "wb_p", ")", "inc_p", "=", "INTVAL", "(", "offset", ")", ">", "0", ";", "else", "if", "(", "i", "==", "start", ")", "{", "rtx", "first_base", ",", "first_offset", ";", "if", "(", "!", "split_mem_address", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "first_base", ",", "&", "first_offset", ")", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "first_base", ")", "||", "!", "CONST_INT_P", "(", "first_offset", ")", ")", "return", "false", ";", "base_reg", "=", "first_base", ";", "inc_p", "=", "INTVAL", "(", "first_offset", ")", ">=", "0", ";", "}", "if", "(", "load_p", "&&", "regno", "==", "(", "int", ")", "REGNO", "(", "base_reg", ")", ")", "return", "false", ";", "if", "(", "last_regno", ">=", "0", ")", "{", "if", "(", "inc_p", "&&", "last_regno", ">=", "regno", ")", "return", "false", ";", "if", "(", "!", "inc_p", "&&", "last_regno", "<=", "regno", ")", "return", "false", ";", "}", "last_regno", "=", "regno", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Main", "function", "to", "implement", "ldwm_operation/stwm_operation", "predicates", "that", "check", "ldwm/stwm", "insn", "pattern", "integrity", "." ]

[ "nios2", "0", "1", "1", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "unsigned", "int", "aarch64_function_arg_alignment", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "unsigned", "int", "*", "abi_break", ")", "{", "*", "abi_break", "=", "0", ";", "if", "(", "!", "type", ")", "return", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "return", "0", ";", "gcc_assert", "(", "TYPE_MODE", "(", "type", ")", "==", "mode", ")", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "TYPE_ALIGN", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "unsigned", "int", "alignment", "=", "0", ";", "unsigned", "int", "bitfield_alignment", "=", "0", ";", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "{", "alignment", "=", "std", "::", "max", "(", "alignment", ",", "DECL_ALIGN", "(", "field", ")", ")", ";", "if", "(", "DECL_BIT_FIELD_TYPE", "(", "field", ")", ")", "bitfield_alignment", "=", "std", "::", "max", "(", "bitfield_alignment", ",", "TYPE_ALIGN", "(", "DECL_BIT_FIELD_TYPE", "(", "field", ")", ")", ")", ";", "}", "if", "(", "bitfield_alignment", ">", "alignment", ")", "{", "*", "abi_break", "=", "alignment", ";", "return", "bitfield_alignment", ";", "}", "return", "alignment", ";", "}", "</s>" ]

[ "Given", "MODE", "and", "TYPE", "of", "a", "function", "argument", ",", "return", "the", "alignment", "in", "bits", ".", "The", "idea", "is", "to", "suppress", "any", "stronger", "alignment", "requested", "by", "the", "user", "and", "opt", "for", "the", "natural", "alignment", "(", "specified", "in", "AAPCS64", "\\S", "4.1", ")", ".", "This", "is", "a", "helper", "function", "for", "local", "use", "only", "." ]

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

[]

[ "<s>", "TargetLoweringBase", "::", "AtomicExpansionKind", "ARMTargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "bool", "has64BitAtomicStore", ";", "if", "(", "Subtarget", "->", "isMClass", "(", ")", ")", "has64BitAtomicStore", "=", "false", ";", "else", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "has64BitAtomicStore", "=", "Subtarget", "->", "hasV7Ops", "(", ")", ";", "else", "has64BitAtomicStore", "=", "Subtarget", "->", "hasV6Ops", "(", ")", ";", "unsigned", "Size", "=", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "Size", "==", "64", "&&", "has64BitAtomicStore", "?", "AtomicExpansionKind", "::", "Expand", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "store", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "into", "." ]

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

[]

[ "<s>", "void", "MBlazeRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "adjustMBlazeStackFrame", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "hasCalls", "(", ")", ")", "return", ";", "if", "(", "StackSize", "<", "28", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "StackSize", "=", "28", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDI", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R15", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "28", "28", "MBlaze", "MBlaze", "MBlaze::ADDI", "MBlaze::R1", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R15", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::ADD", "MBlaze::R19", "MBlaze::R1", "MBlaze::R0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Optimize addressing mode of load/store\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Optimize addressing mode of load/store\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "FoldImmediate", "(", "MachineInstr", "*", "UseMI", ",", "MachineInstr", "*", "DefMI", ",", "unsigned", "Reg", ",", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "unsigned", "DefOpc", "=", "DefMI", "->", "getOpcode", "(", ")", ";", "if", "(", "DefOpc", "!=", "PPC", "::", "LI", "&&", "DefOpc", "!=", "PPC", "::", "LI8", ")", "return", "false", ";", "if", "(", "!", "DefMI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "if", "(", "DefMI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "!=", "0", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "UseMCID", "=", "UseMI", "->", "getDesc", "(", ")", ";", "if", "(", "UseMCID", ".", "isPseudo", "(", ")", ")", "return", "false", ";", "unsigned", "UseIdx", ";", "for", "(", "UseIdx", "=", "0", ";", "UseIdx", "<", "UseMI", "->", "getNumOperands", "(", ")", ";", "++", "UseIdx", ")", "if", "(", "UseMI", "->", "getOperand", "(", "UseIdx", ")", ".", "isReg", "(", ")", "&&", "UseMI", "->", "getOperand", "(", "UseIdx", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "break", ";", "assert", "(", "UseIdx", "<", "UseMI", "->", "getNumOperands", "(", ")", "&&", "\"Cannot find Reg in UseMI\"", ")", ";", "assert", "(", "UseIdx", "<", "UseMCID", ".", "getNumOperands", "(", ")", "&&", "\"No operand description for Reg\"", ")", ";", "const", "MCOperandInfo", "*", "UseInfo", "=", "&", "UseMCID", ".", "OpInfo", "[", "UseIdx", "]", ";", "if", "(", "UseInfo", "->", "isLookupPtrRegClass", "(", ")", ")", "{", "if", "(", "UseInfo", "->", "RegClass", "!=", "1", ")", "return", "false", ";", "}", "else", "{", "if", "(", "UseInfo", "->", "RegClass", "!=", "PPC", "::", "GPRC_NOR0RegClassID", "&&", "UseInfo", "->", "RegClass", "!=", "PPC", "::", "G8RC_NOX0RegClassID", ")", "return", "false", ";", "}", "if", "(", "UseInfo", "->", "Constraints", "!=", "0", ")", "return", "false", ";", "unsigned", "ZeroReg", ";", "if", "(", "UseInfo", "->", "isLookupPtrRegClass", "(", ")", ")", "{", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "ZeroReg", "=", "isPPC64", "?", "PPC", "::", "ZERO8", ":", "PPC", "::", "ZERO", ";", "}", "else", "{", "ZeroReg", "=", "UseInfo", "->", "RegClass", "==", "PPC", "::", "G8RC_NOX0RegClassID", "?", "PPC", "::", "ZERO8", ":", "PPC", "::", "ZERO", ";", "}", "bool", "DeleteDef", "=", "MRI", "->", "hasOneNonDBGUse", "(", "Reg", ")", ";", "UseMI", "->", "getOperand", "(", "UseIdx", ")", ".", "setReg", "(", "ZeroReg", ")", ";", "if", "(", "DeleteDef", ")", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Reg", "is", "known", "to", "be", "defined", "by", "a", "move", "immediate", "instruction", ",", "try", "to", "fold", "the", "immediate", "into", "the", "use", "instruction", "." ]

[ "PowerPC", "PPC", "PPC::LI", "PPC::LI8", "1", "1", "0", "0", "\"Cannot find Reg in UseMI\"", "\"No operand description for Reg\"", "1", "PPC::GPRC_NOR0RegClassID", "PPC::G8RC_NOX0RegClassID", "0", "PPC", "PPC", "PPC", "PPC::ZERO8", "PPC::ZERO", "PPC::G8RC_NOX0RegClassID", "PPC::ZERO8", "PPC::ZERO" ]

[]

[ "<s>", "void", "SPUTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "char", "ConstraintLetter", ",", "bool", "hasMemory", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "ConstraintLetter", ",", "hasMemory", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Form memory clauses\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Form memory clauses\"" ]

[]

[ "<s>", "int", "ix86_reg_parm_stack_space", "(", "const_tree", "fndecl", ")", "{", "enum", "calling_abi", "call_abi", "=", "SYSV_ABI", ";", "if", "(", "fndecl", "!=", "NULL_TREE", "&&", "TREE_CODE", "(", "fndecl", ")", "==", "FUNCTION_DECL", ")", "call_abi", "=", "ix86_function_abi", "(", "fndecl", ")", ";", "else", "call_abi", "=", "ix86_function_type_abi", "(", "fndecl", ")", ";", "if", "(", "TARGET_64BIT", "&&", "call_abi", "==", "MS_ABI", ")", "return", "32", ";", "return", "0", ";", "}", "</s>" ]

[ "It", "returns", "the", "size", ",", "in", "bytes", ",", "of", "the", "area", "reserved", "for", "arguments", "passed", "in", "registers", "for", "the", "function", "represented", "by", "fndecl", "dependent", "to", "the", "used", "abi", "format", "." ]

[ "i386", "32", "0" ]

[]

[ "<s>", "bool", "X86Subtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_CRITICAL", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "return", "PostRAScheduler", "&&", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "X86", "X86" ]

[]

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

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

[ "WDC65816" ]

[]

[ "<s>", "static", "int", "count_num_restricted", "(", "rtx_insn", "*", "insn", ",", "dispatch_windows", "*", "window_list", ")", "{", "enum", "dispatch_group", "group", "=", "get_insn_group", "(", "insn", ")", ";", "int", "imm_size", ";", "int", "num_imm_operand", ";", "int", "num_imm32_operand", ";", "int", "num_imm64_operand", ";", "if", "(", "group", "==", "disp_no_group", ")", "return", "0", ";", "if", "(", "group", "==", "disp_imm", ")", "{", "imm_size", "=", "get_num_immediates", "(", "insn", ",", "&", "num_imm_operand", ",", "&", "num_imm32_operand", ",", "&", "num_imm64_operand", ")", ";", "if", "(", "window_list", "->", "imm_size", "+", "imm_size", ">", "MAX_IMM_SIZE", "||", "num_imm_operand", "+", "window_list", "->", "num_imm", ">", "MAX_IMM", "||", "(", "num_imm32_operand", ">", "0", "&&", "(", "window_list", "->", "num_imm_32", "+", "num_imm32_operand", ">", "MAX_IMM_32", "||", "window_list", "->", "num_imm_64", "*", "2", "+", "num_imm32_operand", ">", "MAX_IMM_32", ")", ")", "||", "(", "num_imm64_operand", ">", "0", "&&", "(", "window_list", "->", "num_imm_64", "+", "num_imm64_operand", ">", "MAX_IMM_64", "||", "window_list", "->", "num_imm_32", "+", "num_imm64_operand", "*", "2", ">", "MAX_IMM_32", ")", ")", "||", "(", "window_list", "->", "imm_size", "+", "imm_size", "==", "MAX_IMM_SIZE", "&&", "num_imm64_operand", ">", "0", "&&", "(", "(", "window_list", "->", "num_imm_64", ">", "0", "&&", "window_list", "->", "num_insn", ">=", "2", ")", "||", "window_list", "->", "num_insn", ">=", "3", ")", ")", ")", "return", "BIG", ";", "return", "1", ";", "}", "if", "(", "(", "group", "==", "disp_load_store", "&&", "(", "window_list", "->", "num_loads", ">=", "MAX_LOAD", "||", "window_list", "->", "num_stores", ">=", "MAX_STORE", ")", ")", "||", "(", "(", "group", "==", "disp_load", "||", "group", "==", "disp_prefetch", ")", "&&", "window_list", "->", "num_loads", ">=", "MAX_LOAD", ")", "||", "(", "group", "==", "disp_store", "&&", "window_list", "->", "num_stores", ">=", "MAX_STORE", ")", ")", "return", "BIG", ";", "return", "1", ";", "}", "</s>" ]

[ "Count", "number", "of", "GROUP", "restricted", "instructions", "in", "a", "dispatch", "window", "WINDOW_LIST", "." ]

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

[]

[ "<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "DLX" ]

[]

[ "<s>", "ArrayRef", "<", "MCPhysReg", ">", "SIRegisterInfo", "::", "getAllSGPR32", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "makeArrayRef", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "begin", "(", ")", ",", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ")", ";", "}", "</s>" ]

[ "Return", "all", "SGPR32", "which", "satisfy", "the", "waves", "per", "execution", "unit", "requirement", "of", "the", "subtarget", "." ]

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

[]

[ "<s>", "static", "inline", "VConstraintType", "getConstraint", "(", "uint64_t", "TSFlags", ")", "{", "return", "static_cast", "<", "VConstraintType", ">", "(", "(", "TSFlags", "&", "ConstraintMask", ")", ">>", "ConstraintShift", ")", ";", "}", "</s>" ]

[ "Fetch", "condition", "in", "the", "form", "of", "PredicateConstraint", ",", "if", "possible", "." ]

[ "RISCV" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "requiresVirtualBaseRegisters", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "EnableLocalStackAlloc", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "the", "LocalStackAllocation", "pass", "to", "be", "run", "and", "virtual", "base", "registers", "used", "for", "more", "efficient", "stack", "access", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "X86LoadValueInjectionRetHardeningPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" *****\\n\"", ")", ";", "const", "X86Subtarget", "*", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "useLVIControlFlowIntegrity", "(", ")", "||", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "false", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "hasOptNone", "(", ")", "&&", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "++", "NumFunctionsConsidered", ";", "const", "X86RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MBBI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MBBI", ")", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "!=", "X86", "::", "RETQ", ")", "continue", ";", "unsigned", "ClobberReg", "=", "TRI", "->", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ")", ";", "if", "(", "ClobberReg", "!=", "X86", "::", "NoRegister", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "POP64r", ")", ")", ".", "addReg", "(", "ClobberReg", ",", "RegState", "::", "Define", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "JMP64r", ")", ")", ".", "addReg", "(", "ClobberReg", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "MachineInstr", "*", "Fence", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "Fence", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "SHL64mi", ")", ")", ",", "X86", "::", "RSP", ",", "false", ",", "0", ")", ".", "addImm", "(", "0", ")", "->", "addRegisterDead", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ";", "}", "++", "NumFences", ";", "Modified", "=", "true", ";", "break", ";", "}", "}", "if", "(", "Modified", ")", "++", "NumFunctionsMitigated", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"***** \"", "\" : \"", "\" *****\\n\"", "X86", "X86", "X86", "X86", "X86::RETQ", "X86::NoRegister", "X86::POP64r", "X86::LFENCE", "X86::JMP64r", "X86::LFENCE", "X86::SHL64mi", "X86::RSP", "0", "0", "X86::EFLAGS" ]

[]

[ "<s>", "RAInfo", "::", "LocType", "getType", "(", ")", "const", "{", "return", "type", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "Patmos" ]

[]

[ "<s>", "SDValue", "Z80TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "return", "Chain", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "ISD::InputArg" ]

[]

[ "<s>", "MachineInstr", "*", "SystemZInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "MachineInstr", "*", "LoadMI", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "return", "nullptr", ";", "}", "</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" ]

[]

[ "<s>", "bool", "HexagonTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createHexagonRemoveExtendOps", "(", "*", "this", ")", ")", ";", "PM", ".", "add", "(", "createHexagonISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "addPredicate", "(", "MachineInstr", "*", "MI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM Loops: Adding VPT Predicate: \"", "<<", "*", "MI", ")", ";", "CurrentPredicates", ".", "insert", "(", "MI", ")", ";", "}", "</s>" ]

[ "Adds", "a", "new", "predicate", "." ]

[ "ARM", "\"ARM Loops: Adding VPT Predicate: \"" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "usesConstantBus", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpIdx", ")", "{", "const", "MCOperand", "&", "MO", "=", "Inst", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "!", "isInlineConstant", "(", "Inst", ",", "OpIdx", ")", ";", "}", "return", "!", "MO", ".", "isReg", "(", ")", "||", "isSGPR", "(", "mc2PseudoReg", "(", "MO", ".", "getReg", "(", ")", ")", ",", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

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

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

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

[]

[ "<s>", "static", "int", "arc_verify_short", "(", "rtx_insn", "*", "insn", ",", "int", ",", "int", "check_attr", ")", "{", "enum", "attr_iscompact", "iscompact", ";", "if", "(", "check_attr", ">", "0", ")", "{", "iscompact", "=", "get_attr_iscompact", "(", "insn", ")", ";", "if", "(", "iscompact", "==", "ISCOMPACT_FALSE", ")", "return", "0", ";", "}", "return", "(", "get_attr_length", "(", "insn", ")", "&", "2", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "INSN", "should", "be", "output", "as", "a", "short", "insn", ".", "UNALIGN", "is", "zero", "if", "the", "current", "insn", "is", "aligned", "to", "a", "4-byte-boundary", ",", "two", "otherwise", ".", "If", "CHECK_ATTR", "is", "greater", "than", "0", ",", "check", "the", "iscompact", "attribute", "first", "." ]

[ "arc", "0", "0", "2", "0" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "TM", ".", "getDataLayout", "(", ")", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "const", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "const", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetFnStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "EmitFunctionStubs", "(", "Stubs", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", "&&", "MMI", ")", "{", "const", "std", "::", "vector", "<", "const", "Function", "*", ">", "&", "Personalities", "=", "MMI", "->", "getPersonalities", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "const", "Function", "*", ">", "::", "const_iterator", "I", "=", "Personalities", ".", "begin", "(", ")", ",", "E", "=", "Personalities", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "*", "I", ")", "{", "MCSymbol", "*", "NLPSym", "=", "GetSymbolWithGlobalValueBase", "(", "*", "I", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Mang", "->", "getSymbol", "(", "*", "I", ")", ",", "true", ")", ";", "}", "}", "}", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "MCSym", "=", "Stubs", "[", "i", "]", ".", "second", ";", "OutStreamer", ".", "EmitSymbolAttribute", "(", "MCSym", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", ".", "EmitIntValue", "(", "0", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "else", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetHiddenGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", ".", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "\"$non_lazy_ptr\"", "PPC", "3", "2", "0", "0", "PPC", "8", "4", "PPC", "8", "4", "PPC", "3", "2", "0", "PPC", "8", "4" ]

[]

[ "<s>", "bool", "NVVMReflect", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "return", "runNVVMReflect", "(", "F", ",", "SmVersion", ")", ";", "}", "</s>" ]

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

[ "NVPTX" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "X86AsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "{", "unsigned", "Type", ";", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "{", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "\"BFD_RELOC_NONE\"", ",", "ELF", "::", "R_X86_64_NONE", ")", ".", "Case", "(", "\"BFD_RELOC_8\"", ",", "ELF", "::", "R_X86_64_8", ")", ".", "Case", "(", "\"BFD_RELOC_16\"", ",", "ELF", "::", "R_X86_64_16", ")", ".", "Case", "(", "\"BFD_RELOC_32\"", ",", "ELF", "::", "R_X86_64_32", ")", ".", "Case", "(", "\"BFD_RELOC_64\"", ",", "ELF", "::", "R_X86_64_64", ")", ".", "Default", "(", "-", "1u", ")", ";", "}", "else", "{", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "\"BFD_RELOC_NONE\"", ",", "ELF", "::", "R_386_NONE", ")", ".", "Case", "(", "\"BFD_RELOC_8\"", ",", "ELF", "::", "R_386_8", ")", ".", "Case", "(", "\"BFD_RELOC_16\"", ",", "ELF", "::", "R_386_16", ")", ".", "Case", "(", "\"BFD_RELOC_32\"", ",", "ELF", "::", "R_386_32", ")", ".", "Default", "(", "-", "1u", ")", ";", "}", "if", "(", "Type", "==", "-", "1u", ")", "return", "None", ";", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "return", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "X86", "X86", "\"BFD_RELOC_NONE\"", "X86", "\"BFD_RELOC_8\"", "X86", "\"BFD_RELOC_16\"", "X86", "\"BFD_RELOC_32\"", "X86", "\"BFD_RELOC_64\"", "X86", "1u", "\"BFD_RELOC_NONE\"", "\"BFD_RELOC_8\"", "\"BFD_RELOC_16\"", "\"BFD_RELOC_32\"", "1u", "1u" ]

[]

[ "<s>", "static", "void", "set_reg_plus_d", "(", "int", "reg", ",", "int", "base", ",", "HOST_WIDE_INT", "disp", ",", "int", "note", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "VAL_14_BITS_P", "(", "disp", ")", ")", "{", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "plus_constant", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ",", "disp", ")", ")", ";", "}", "else", "if", "(", "TARGET_64BIT", "&&", "!", "VAL_32_BITS_P", "(", "disp", ")", ")", "{", "rtx", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "delta", ")", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "tmpreg", ",", "basereg", ")", ")", ";", "if", "(", "DO_FRAME_NOTES", ")", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "delta", ")", ")", ")", ";", "}", "else", "{", "rtx", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "delta", ")", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "tmpreg", ",", "delta", ")", ")", ";", "}", "if", "(", "DO_FRAME_NOTES", "&&", "note", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "set", "REG", "to", "the", "value", "specified", "by", "BASE+DISP", ".", "Handle", "case", "where", "DISP", ">", "8k", "by", "using", "the", "add_high_const", "patterns", ".", "Note", "in", "DISP", ">", "8k", "case", ",", "we", "will", "leave", "the", "high", "part", "of", "the", "address", "in", "%", "r1", ".", "There", "is", "code", "in", "expand_hppa_", "{", "prologue", ",", "epilogue", "}", "that", "knows", "this", "." ]

[ "pa", "1", "1", "1" ]

[]

[ "<s>", "rtx", "xtensa_copy_incoming_a7", "(", "rtx", "opnd", ")", "{", "rtx", "entry_insns", "=", "0", ";", "rtx", "reg", ",", "tmp", ";", "enum", "machine_mode", "mode", ";", "if", "(", "!", "cfun", "->", "machine", "->", "need_a7_copy", ")", "return", "opnd", ";", "gcc_assert", "(", "!", "cfun", "->", "machine", "->", "set_frame_ptr_insn", ")", ";", "mode", "=", "GET_MODE", "(", "opnd", ")", ";", "reg", "=", "opnd", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg", ")", "!=", "REG", "||", "REGNO", "(", "reg", ")", ">", "A7_REG", "||", "REGNO", "(", "reg", ")", "+", "HARD_REGNO_NREGS", "(", "A7_REG", ",", "mode", ")", "<=", "A7_REG", ")", "return", "opnd", ";", "gcc_assert", "(", "REGNO", "(", "reg", ")", "+", "HARD_REGNO_NREGS", "(", "A7_REG", ",", "mode", ")", "-", "1", "==", "A7_REG", ")", ";", "cfun", "->", "machine", "->", "need_a7_copy", "=", "false", ";", "push_to_sequence", "(", "entry_insns", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "switch", "(", "mode", ")", "{", "case", "DFmode", ":", "case", "DImode", ":", "emit_insn", "(", "gen_movsi_internal", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "tmp", ",", "0", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "A7_REG", "-", "1", ")", ")", ")", ";", "emit_insn", "(", "gen_movsi_internal", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "tmp", ",", "4", ")", ",", "gen_raw_REG", "(", "SImode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "SFmode", ":", "emit_insn", "(", "gen_movsf_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_movsi_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_movhi_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "case", "QImode", ":", "emit_insn", "(", "gen_movqi_internal", "(", "tmp", ",", "gen_raw_REG", "(", "mode", ",", "A7_REG", ")", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "cfun", "->", "machine", "->", "set_frame_ptr_insn", "=", "emit_insn", "(", "gen_set_frame_ptr", "(", ")", ")", ";", "entry_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "vararg_a7", ")", "{", "emit_insn", "(", "entry_insns", ")", ";", "}", "else", "{", "push_topmost_sequence", "(", ")", ";", "emit_insn_after", "(", "entry_insns", ",", "get_insns", "(", ")", ")", ";", "pop_topmost_sequence", "(", ")", ";", "}", "return", "tmp", ";", "}", "</s>" ]

[ "Check", "if", "an", "incoming", "argument", "in", "a7", "is", "expected", "to", "be", "used", "soon", "and", "if", "OPND", "is", "a", "register", "or", "register", "pair", "that", "includes", "a7", ".", "If", "so", ",", "create", "a", "new", "pseudo", "and", "copy", "a7", "into", "that", "pseudo", "at", "the", "very", "beginning", "of", "the", "function", ",", "followed", "by", "the", "special", "``", "set_frame_ptr", "''", "unspec_volatile", "insn", ".", "The", "return", "value", "is", "either", "the", "original", "operand", ",", "if", "it", "is", "not", "a7", ",", "or", "the", "new", "pseudo", "containing", "a", "copy", "of", "the", "incoming", "argument", ".", "This", "is", "necessary", "because", "the", "register", "allocator", "will", "ignore", "conflicts", "with", "a7", "and", "may", "either", "assign", "some", "other", "pseudo", "to", "a7", "or", "use", "a7", "as", "the", "hard_frame_pointer", ",", "clobbering", "the", "incoming", "argument", "in", "a7", ".", "By", "copying", "the", "argument", "out", "of", "a7", "as", "the", "very", "first", "thing", ",", "and", "then", "immediately", "following", "that", "with", "an", "unspec_volatile", "to", "keep", "the", "scheduler", "away", ",", "we", "should", "avoid", "any", "problems", ".", "Putting", "the", "set_frame_ptr", "insn", "at", "the", "beginning", ",", "with", "only", "the", "a7", "copy", "before", "it", ",", "also", "makes", "it", "easier", "for", "the", "prologue", "expander", "to", "initialize", "the", "frame", "pointer", "after", "the", "a7", "copy", "and", "to", "fix", "up", "the", "a7", "copy", "to", "use", "the", "stack", "pointer", "instead", "of", "the", "frame", "pointer", "." ]

[ "xtensa", "0", "0", "1", "0", "1", "4" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getMemOperandWithOffset", "(", "MachineInstr", "&", "LdSt", ",", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "AccessSize", "=", "0", ";", "BaseOp", "=", "getBaseAndOffset", "(", "LdSt", ",", "Offset", ",", "AccessSize", ")", ";", "assert", "(", "(", "!", "BaseOp", "||", "BaseOp", "->", "isReg", "(", ")", ")", "&&", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"", ")", ";", "return", "BaseOp", "!=", "nullptr", ";", "}", "</s>" ]

[ "Get", "the", "base", "operand", "and", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

[ "Hexagon", "Hexagon", "0", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"" ]

[]

[ "<s>", "static", "void", "arm_option_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "int", "flags", "=", "ptr", "->", "x_target_flags", ";", "const", "struct", "arm_fpu_desc", "*", "fpu_desc", "=", "&", "all_fpus", "[", "ptr", "->", "x_arm_fpu_index", "]", ";", "fprintf", "(", "file", ",", "\"%*sselected arch %s\\n\"", ",", "indent", ",", "\"\"", ",", "TARGET_THUMB2_P", "(", "flags", ")", "?", "\"thumb2\"", ":", "TARGET_THUMB_P", "(", "flags", ")", "?", "\"thumb1\"", ":", "\"arm\"", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected fpu %s\\n\"", ",", "indent", ",", "\"\"", ",", "fpu_desc", "->", "name", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_PRINT", "." ]

[ "arm", "\"%*sselected arch %s\\n\"", "\"\"", "\"thumb2\"", "\"thumb1\"", "\"arm\"", "\"%*sselected fpu %s\\n\"", "\"\"" ]

[]

[ "<s>", "static", "tree", "pa_d_handle_target_object_format", "(", "void", ")", "{", "const", "char", "*", "objfmt", "=", "NULL", ";", "if", "(", "TARGET_SOM", ")", "objfmt", "=", "\"som\"", ";", "if", "(", "objfmt", "==", "NULL", ")", "return", "NULL_TREE", ";", "return", "build_string_literal", "(", "strlen", "(", "objfmt", ")", "+", "1", ",", "objfmt", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "objectFormat", "''", ")", "'", "." ]

[ "pa", "\"som\"", "1" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "FrameIndexValue", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "int", "Offset", "=", "(", "(", "spOffset", "<", "0", ")", "?", "(", "stackSize", "+", "(", "-", "(", "spOffset", "+", "4", ")", ")", ")", ":", "(", "spOffset", ")", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "4", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "1", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "frv_dwarf_store", "(", "rtx", "reg", ",", "int", "offset", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "GET_MODE", "(", "reg", ")", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "Generate", "a", "frame-related", "expression", ":", "(", "set", "REG", "(", "mem", "(", "plus", "(", "sp", ")", "(", "const_int", "OFFSET", ")", ")", ")", ")", ".", "Such", "expressions", "are", "used", "in", "FRAME_RELATED_EXPR", "notes", "for", "more", "complex", "instructions", ".", "Marking", "the", "expressions", "as", "frame-related", "is", "superfluous", "if", "the", "note", "contains", "just", "a", "single", "set", ".", "But", "if", "the", "note", "contains", "a", "PARALLEL", "or", "SEQUENCE", "that", "has", "several", "sets", ",", "each", "set", "must", "be", "individually", "marked", "as", "frame-related", "." ]

[ "frv", "1" ]

[]

[ "<s>", "static", "bool", "expand_vselect_vconcat", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ")", "{", "machine_mode", "v2mode", ";", "rtx", "x", ";", "if", "(", "!", "GET_MODE_2XWIDER_MODE", "(", "GET_MODE", "(", "op0", ")", ")", ".", "exists", "(", "&", "v2mode", ")", ")", "return", "false", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "v2mode", ",", "op0", ",", "op1", ")", ";", "return", "expand_vselect", "(", "target", ",", "x", ",", "perm", ",", "nelt", ")", ";", "}", "</s>" ]

[ "Similar", ",", "but", "generate", "a", "vec_concat", "from", "op0", "and", "op1", "as", "well", "." ]

[ "ia64" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isCheapToSpeculateCtlz", "(", ")", "const", "{", "return", "Subtarget", ".", "hasStdExtZbb", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "msp430_split_movsi", "(", "rtx", "*", "operands", ")", "{", "rtx", "op00", ",", "op02", ",", "op10", ",", "op12", ";", "op00", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "SImode", ",", "0", ")", ";", "op02", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "SImode", ",", "2", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "SYMBOL_REF", ")", "{", "op10", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "op10", "=", "gen_rtx_CONST", "(", "HImode", ",", "op10", ")", ";", "op12", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "16", ")", ")", ";", "op12", "=", "gen_rtx_CONST", "(", "HImode", ",", "op12", ")", ";", "}", "else", "{", "op10", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "SImode", ",", "0", ")", ";", "op12", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "SImode", ",", "2", ")", ";", "}", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "operands", "[", "2", "]", "=", "op02", ";", "operands", "[", "4", "]", "=", "op12", ";", "operands", "[", "3", "]", "=", "op00", ";", "operands", "[", "5", "]", "=", "op10", ";", "}", "else", "if", "(", "rtx_equal_p", "(", "op00", ",", "op12", ")", "||", "(", "REG_P", "(", "op00", ")", "&&", "reg_mentioned_p", "(", "op00", ",", "op10", ")", ")", "||", "(", "REG_P", "(", "op10", ")", "&&", "reg_mentioned_p", "(", "op10", ",", "op00", ")", ")", ")", "{", "operands", "[", "2", "]", "=", "op02", ";", "operands", "[", "4", "]", "=", "op12", ";", "operands", "[", "3", "]", "=", "op00", ";", "operands", "[", "5", "]", "=", "op10", ";", "}", "else", "{", "operands", "[", "2", "]", "=", "op00", ";", "operands", "[", "4", "]", "=", "op10", ";", "operands", "[", "3", "]", "=", "op02", ";", "operands", "[", "5", "]", "=", "op12", ";", "}", "}", "</s>" ]

[ "Called", "by", "movsi_x", "to", "generate", "the", "HImode", "operands", "." ]

[ "msp430", "0", "0", "0", "2", "1", "1", "1", "16", "0", "1", "16", "16", "1", "0", "1", "2", "0", "1", "2", "4", "3", "5", "2", "4", "3", "5", "2", "4", "3", "5" ]

[]

[ "<s>", "bool", "bfin_expand_movmem", "(", "rtx", "dst", ",", "rtx", "src", ",", "rtx", "count_exp", ",", "rtx", "align_exp", ")", "{", "rtx", "srcreg", ",", "destreg", ",", "countreg", ";", "HOST_WIDE_INT", "align", "=", "0", ";", "unsigned", "HOST_WIDE_INT", "count", "=", "0", ";", "if", "(", "GET_CODE", "(", "align_exp", ")", "==", "CONST_INT", ")", "align", "=", "INTVAL", "(", "align_exp", ")", ";", "if", "(", "GET_CODE", "(", "count_exp", ")", "==", "CONST_INT", ")", "{", "count", "=", "INTVAL", "(", "count_exp", ")", ";", "if", "(", "!", "TARGET_INLINE_ALL_STRINGOPS", "&&", "count", ">", "64", ")", "return", "false", ";", "}", "if", "(", "optimize_size", ")", "{", "if", "(", "count", "==", "2", "&&", "align", "<", "2", ")", "return", "false", ";", "if", "(", "count", "==", "4", "&&", "align", "<", "4", ")", "return", "false", ";", "if", "(", "count", "!=", "1", "&&", "count", "!=", "2", "&&", "count", "!=", "4", ")", "return", "false", ";", "}", "if", "(", "align", "<", "2", "&&", "count", "!=", "1", ")", "return", "false", ";", "destreg", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "dst", ",", "0", ")", ")", ";", "if", "(", "destreg", "!=", "XEXP", "(", "dst", ",", "0", ")", ")", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "destreg", ")", ";", "srcreg", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "0", ")", ")", ";", "if", "(", "srcreg", "!=", "XEXP", "(", "src", ",", "0", ")", ")", "src", "=", "replace_equiv_address_nv", "(", "src", ",", "srcreg", ")", ";", "if", "(", "count", "!=", "0", "&&", "align", ">=", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "align", ">=", "4", ")", "{", "if", "(", "(", "count", "&", "~", "3", ")", "==", "4", ")", "{", "single_move_for_movmem", "(", "dst", ",", "src", ",", "SImode", ",", "offset", ")", ";", "offset", "=", "4", ";", "}", "else", "if", "(", "count", "&", "~", "3", ")", "{", "HOST_WIDE_INT", "new_count", "=", "(", "(", "count", ">>", "2", ")", "&", "0x3fffffff", ")", "-", "1", ";", "countreg", "=", "copy_to_mode_reg", "(", "Pmode", ",", "GEN_INT", "(", "new_count", ")", ")", ";", "emit_insn", "(", "gen_rep_movsi", "(", "destreg", ",", "srcreg", ",", "countreg", ",", "destreg", ",", "srcreg", ")", ")", ";", "cfun", "->", "machine", "->", "has_loopreg_clobber", "=", "true", ";", "}", "if", "(", "count", "&", "2", ")", "{", "single_move_for_movmem", "(", "dst", ",", "src", ",", "HImode", ",", "offset", ")", ";", "offset", "+=", "2", ";", "}", "}", "else", "{", "if", "(", "(", "count", "&", "~", "1", ")", "==", "2", ")", "{", "single_move_for_movmem", "(", "dst", ",", "src", ",", "HImode", ",", "offset", ")", ";", "offset", "=", "2", ";", "}", "else", "if", "(", "count", "&", "~", "1", ")", "{", "HOST_WIDE_INT", "new_count", "=", "(", "(", "count", ">>", "1", ")", "&", "0x7fffffff", ")", "-", "1", ";", "countreg", "=", "copy_to_mode_reg", "(", "Pmode", ",", "GEN_INT", "(", "new_count", ")", ")", ";", "emit_insn", "(", "gen_rep_movhi", "(", "destreg", ",", "srcreg", ",", "countreg", ",", "destreg", ",", "srcreg", ")", ")", ";", "cfun", "->", "machine", "->", "has_loopreg_clobber", "=", "true", ";", "}", "}", "if", "(", "count", "&", "1", ")", "{", "single_move_for_movmem", "(", "dst", ",", "src", ",", "QImode", ",", "offset", ")", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "a", "string", "move", "operation", "of", "COUNT_EXP", "bytes", "from", "SRC", "to", "DST", ",", "with", "alignment", "ALIGN_EXP", ".", "Return", "true", "if", "successful", ",", "false", "if", "we", "should", "fall", "back", "on", "a", "different", "method", "." ]

[ "bfin", "0", "0", "64", "2", "2", "4", "4", "1", "2", "4", "2", "1", "0", "0", "0", "0", "0", "2", "0", "4", "3", "4", "4", "3", "2", "0x3fffffff", "1", "2", "2", "1", "2", "2", "1", "1", "0x7fffffff", "1", "1" ]

[]

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

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

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

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "SubsumesPredicate", "(", "ArrayRef", "<", "MachineOperand", ">", "Pred1", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred2", ")", "const", "{", "if", "(", "Pred1", ".", "size", "(", ")", ">", "2", "||", "Pred2", ".", "size", "(", ")", ">", "2", ")", "return", "false", ";", "ARMCC", "::", "CondCodes", "CC1", "=", "(", "ARMCC", "::", "CondCodes", ")", "Pred1", "[", "0", "]", ".", "getImm", "(", ")", ";", "ARMCC", "::", "CondCodes", "CC2", "=", "(", "ARMCC", "::", "CondCodes", ")", "Pred2", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "CC1", "==", "CC2", ")", "return", "true", ";", "switch", "(", "CC1", ")", "{", "default", ":", "return", "false", ";", "case", "ARMCC", "::", "AL", ":", "return", "true", ";", "case", "ARMCC", "::", "HS", ":", "return", "CC2", "==", "ARMCC", "::", "HI", ";", "case", "ARMCC", "::", "LS", ":", "return", "CC2", "==", "ARMCC", "::", "LO", "||", "CC2", "==", "ARMCC", "::", "EQ", ";", "case", "ARMCC", "::", "GE", ":", "return", "CC2", "==", "ARMCC", "::", "GT", ";", "case", "ARMCC", "::", "LE", ":", "return", "CC2", "==", "ARMCC", "::", "LT", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "ARM", "ARM", "2", "2", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "ARMCC::AL", "ARMCC::HS", "ARMCC::HI", "ARMCC::LS", "ARMCC::LO", "ARMCC::EQ", "ARMCC::GE", "ARMCC::GT", "ARMCC::LE", "ARMCC::LT" ]

[]

[ "<s>", "bool", "emit", "(", "MCInst", "&", "Inst", ",", "SMLoc", "const", "&", "Loc", ",", "MCStreamer", "&", "Out", ")", "const", "{", "Inst", ".", "setLoc", "(", "Loc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

[ "MOS" ]

[]