Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "assert", "(", "MI", ".", "isDebugOperand", "(", "&", "Op", ")", "&&", "\"Frame indices can only appear as a debug operand in a DBG_VALUE*\"", "\" machine instruction\"", ")", ";", "Register", "Reg", ";", "auto", "Offset", "=", "TFI", ".", "getFrameIndexReference", "(", "MF", ",", "Op", ".", "getIndex", "(", ")", ",", "Reg", ")", ";", "Op", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "const", "DIExpression", "*", "DIExpr", "=", "MI", ".", "getDebugExpression", "(", ")", ";", "if", "(", "MI", ".", "isNonListDebugValue", "(", ")", ")", "{", "DIExpr", "=", "TRI", ".", "prependOffsetExpression", "(", "MI", ".", "getDebugExpression", "(", ")", ",", "DIExpression", "::", "ApplyOffset", ",", "Offset", ")", ";", "}", "else", "{", "SmallVector", "<", "uint64_t", ",", "3", ">", "Ops", ";", "TRI", ".", "getOffsetOpcodes", "(", "Offset", ",", "Ops", ")", ";", "unsigned", "OpIdx", "=", "MI", ".", "getDebugOperandIndex", "(", "&", "Op", ")", ";", "DIExpr", "=", "DIExpression", "::", "appendOpsToArg", "(", "DIExpr", ",", "Ops", ",", "OpIdx", ")", ";", "}", "MI", ".", "getDebugExpressionOp", "(", ")", ".", "setMetadata", "(", "DIExpr", ")", ";", "continue", ";", "}", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ",", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReturnBlock", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "\"Frame indices can only appear as a debug operand in a DBG_VALUE*\"", "\" machine instruction\"", "3", "0" ]

[]

[ "<s>", "rtx", "alpha_legitimize_reload_address", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "HOST_WIDE_INT", "low", "=", "(", "(", "val", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "HOST_WIDE_INT", "high", "=", "(", "(", "(", "val", "-", "low", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "high", "+", "low", "!=", "val", ")", "return", "NULL_RTX", ";", "x", "=", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "GEN_INT", "(", "high", ")", ")", ",", "GEN_INT", "(", "low", ")", ")", ";", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "x", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Try", "a", "machine-dependent", "way", "of", "reloading", "an", "illegitimate", "address", "operand", ".", "If", "we", "find", "one", ",", "push", "the", "reload", "and", "return", "the", "new", "rtx", "." ]

[ "alpha", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "mips_symbol_binds_local_p", "(", "const_rtx", "x", ")", "{", "return", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL_REF", "X", "binds", "locally", "." ]

[ "mips" ]

[]

[ "<s>", "void", "VideoCore4FrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "alignment", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "SLsize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "Asize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "Asize", "=", "RoundUpToAlignment", "(", "Asize", ",", "alignment", ")", ";", "MFI", "->", "setMaxCallFrameSize", "(", "Asize", ")", ";", "unsigned", "SLAsize", "=", "SLsize", "+", "Asize", ";", "SLAsize", "=", "RoundUpToAlignment", "(", "SLAsize", ",", "alignment", ")", ";", "MFI", "->", "setStackSize", "(", "SLAsize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "VideoCore4", "VideoCore4" ]

[]

[ "<s>", "unsigned", "char", "M68kSubtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "M68kII", "::", "MO_NO_FLAG", ";", "auto", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "{", "return", "M68kII", "::", "MO_GOTPCREL", ";", "}", "return", "M68kII", "::", "MO_PLT", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "M68k", "M68k", "M68kII::MO_NO_FLAG", "M68kII::MO_GOTPCREL", "M68kII::MO_PLT" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "SystemZ", "::", "L128", ":", "splitMove", "(", "MI", ",", "SystemZ", "::", "LG", ")", ";", "return", "true", ";", "case", "SystemZ", "::", "ST128", ":", "splitMove", "(", "MI", ",", "SystemZ", "::", "STG", ")", ";", "return", "true", ";", "case", "SystemZ", "::", "LX", ":", "splitMove", "(", "MI", ",", "SystemZ", "::", "LD", ")", ";", "return", "true", ";", "case", "SystemZ", "::", "STX", ":", "splitMove", "(", "MI", ",", "SystemZ", "::", "STD", ")", ";", "return", "true", ";", "case", "SystemZ", "::", "ADJDYNALLOC", ":", "splitAdjDynAlloc", "(", "MI", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "SystemZ", "SystemZ", "SystemZ::L128", "SystemZ::LG", "SystemZ::ST128", "SystemZ::STG", "SystemZ::LX", "SystemZ::LD", "SystemZ::STX", "SystemZ::STD", "SystemZ::ADJDYNALLOC" ]

[]

[ "<s>", "static", "void", "workaround_arc_anomaly", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_hazard", "(", "insn", ",", "succ0", ")", ")", "{", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "succ0", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "same", "functionality", "as", "arc_hazard", ".", "It", "is", "called", "in", "machine", "reorg", "before", "any", "other", "optimization", ".", "Hence", ",", "the", "NOP", "size", "is", "taken", "into", "account", "when", "doing", "branch", "shortening", "." ]

[ "arc" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "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", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCAssignFnForNode", "(", "CallConv", ",", "true", ",", "isVarArg", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "addInst", "(", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SPAdjust", ",", "bool", "BeforeFPSet", "=", "false", ")", "{", "InstInfo", "Info", "=", "{", "I", ",", "SPAdjust", ",", "BeforeFPSet", "}", ";", "Insts", ".", "push_back", "(", "Info", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCInst", "operand", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "PPCDispatchGroupSBHazardRecognizer", "::", "RecedeCycle", "(", ")", "{", "llvm_unreachable", "(", "\"Bottom-up scheduling not supported\"", ")", ";", "}", "</s>" ]

[ "RecedeCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "bottom-up", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "PowerPC", "PPC", "\"Bottom-up scheduling not supported\"" ]

[]

[ "<s>", "static", "void", "rs6000_finish_atomic_subword", "(", "rtx", "narrow", ",", "rtx", "wide", ",", "rtx", "shift", ")", "{", "wide", "=", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "wide", ",", "shift", ",", "wide", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "emit_move_insn", "(", "narrow", ",", "gen_lowpart", "(", "GET_MODE", "(", "narrow", ")", ",", "wide", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "various", "atomic", "expanders", ".", "For", "sub-word", "operands", ",", "extract", "WIDE", "to", "NARROW", "via", "SHIFT", "." ]

[ "powerpcspe", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "supportsTailCall", "(", ")", ")", "return", "false", ";", "auto", "Attr", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "Attr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "return", "!", "Subtarget", "->", "isThumb1Only", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "ARM", "ARM", "\"disable-tail-calls\"", "\"true\"" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isBundle", "(", ")", ")", "{", "auto", "II", "=", "MI", ".", "getIterator", "(", ")", ";", "while", "(", "II", "->", "isBundledWithSucc", "(", ")", ")", "{", "++", "II", ";", "if", "(", "isPredicated", "(", "*", "II", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "int", "i", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "i", "!=", "-", "1", ")", "{", "unsigned", "preg", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "int", "flag", "=", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "return", "(", "preg", "!=", "Patmos", "::", "NoRegister", "&&", "preg", "!=", "Patmos", "::", "P0", ")", "||", "flag", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "1", "1", "Patmos::NoRegister", "Patmos::P0" ]

[]

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

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

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

[]

[ "<s>", "bool", "SparcFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "c4x_external_ref", "(", "const", "char", "*", "name", ")", "{", "struct", "name_list", "*", "p", ";", "p", "=", "extern_head", ";", "while", "(", "p", ")", "{", "if", "(", "strcmp", "(", "p", "->", "name", ",", "name", ")", "==", "0", ")", "return", ";", "p", "=", "p", "->", "next", ";", "}", "p", "=", "global_head", ";", "while", "(", "p", ")", "{", "if", "(", "strcmp", "(", "p", "->", "name", ",", "name", ")", "==", "0", ")", "return", ";", "p", "=", "p", "->", "next", ";", "}", "p", "=", "(", "struct", "name_list", "*", ")", "xmalloc", "(", "sizeof", "*", "p", ")", ";", "p", "->", "next", "=", "extern_head", ";", "p", "->", "name", "=", "name", ";", "extern_head", "=", "p", ";", "}", "</s>" ]

[ "Add", "NAME", "to", "list", "of", "external", "symbols", "." ]

[ "c4x", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::GR16RegClass", "MSP430::MOV16mr", "0", "MSP430::GR8RegClass", "MSP430::MOV8mr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "bool", "csky_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "if", "(", "to", "==", "FRAME_POINTER_REGNUM", ")", "return", "from", "!=", "ARG_POINTER_REGNUM", ";", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "!", "frame_pointer_needed", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_ELIMINATE", "." ]

[ "csky" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "BlackfinTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "typedef", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Pair", ";", "using", "namespace", "BF", ";", "if", "(", "Constraint", ".", "size", "(", ")", "!=", "1", ")", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "Pair", "(", "0U", ",", "VT", "==", "MVT", "::", "i16", "?", "D16RegisterClass", ":", "DPRegisterClass", ")", ";", "case", "'a'", ":", "return", "Pair", "(", "0U", ",", "PRegisterClass", ")", ";", "case", "'d'", ":", "return", "Pair", "(", "0U", ",", "DRegisterClass", ")", ";", "case", "'e'", ":", "return", "Pair", "(", "0U", ",", "AccuRegisterClass", ")", ";", "case", "'A'", ":", "return", "Pair", "(", "A0", ",", "AccuRegisterClass", ")", ";", "case", "'B'", ":", "return", "Pair", "(", "A1", ",", "AccuRegisterClass", ")", ";", "case", "'b'", ":", "return", "Pair", "(", "0U", ",", "IRegisterClass", ")", ";", "case", "'v'", ":", "return", "Pair", "(", "0U", ",", "BRegisterClass", ")", ";", "case", "'f'", ":", "return", "Pair", "(", "0U", ",", "MRegisterClass", ")", ";", "case", "'C'", ":", "return", "Pair", "(", "CC", ",", "JustCCRegisterClass", ")", ";", "case", "'x'", ":", "return", "Pair", "(", "0U", ",", "GRRegisterClass", ")", ";", "case", "'w'", ":", "return", "Pair", "(", "0U", ",", "ALLRegisterClass", ")", ";", "case", "'Z'", ":", "return", "Pair", "(", "P3", ",", "PRegisterClass", ")", ";", "case", "'Y'", ":", "return", "Pair", "(", "P1", ",", "PRegisterClass", ")", ";", "case", "'z'", ":", "return", "Pair", "(", "0U", ",", "zConsRegisterClass", ")", ";", "case", "'D'", ":", "return", "Pair", "(", "0U", ",", "DConsRegisterClass", ")", ";", "case", "'W'", ":", "return", "Pair", "(", "0U", ",", "WConsRegisterClass", ")", ";", "case", "'c'", ":", "return", "Pair", "(", "0U", ",", "cConsRegisterClass", ")", ";", "case", "'t'", ":", "return", "Pair", "(", "0U", ",", "tConsRegisterClass", ")", ";", "case", "'u'", ":", "return", "Pair", "(", "0U", ",", "uConsRegisterClass", ")", ";", "case", "'k'", ":", "return", "Pair", "(", "0U", ",", "kConsRegisterClass", ")", ";", "case", "'y'", ":", "return", "Pair", "(", "0U", ",", "yConsRegisterClass", ")", ";", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF", "1", "0", "0U", "MVT::i16", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U", "0U" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", "{", "OS", ".", "write_zeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Nyuzi" ]

[]

[ "<s>", "bool", "NVPTXLowerAggrCopies", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "SmallVector", "<", "LoadInst", "*", ",", "4", ">", "AggrLoads", ";", "SmallVector", "<", "MemIntrinsic", "*", ",", "4", ">", "MemCalls", ";", "const", "DataLayout", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "LLVMContext", "&", "Context", "=", "F", ".", "getParent", "(", ")", "->", "getContext", "(", ")", ";", "const", "TargetTransformInfo", "&", "TTI", "=", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "if", "(", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "!", "LI", "->", "hasOneUse", "(", ")", ")", "continue", ";", "if", "(", "DL", ".", "getTypeStoreSize", "(", "LI", "->", "getType", "(", ")", ")", "<", "MaxAggrCopySize", ")", "continue", ";", "if", "(", "StoreInst", "*", "SI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "LI", "->", "user_back", "(", ")", ")", ")", "{", "if", "(", "SI", "->", "getOperand", "(", "0", ")", "!=", "LI", ")", "continue", ";", "AggrLoads", ".", "push_back", "(", "LI", ")", ";", "}", "}", "else", "if", "(", "MemIntrinsic", "*", "IntrCall", "=", "dyn_cast", "<", "MemIntrinsic", ">", "(", "&", "I", ")", ")", "{", "if", "(", "ConstantInt", "*", "LenCI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "IntrCall", "->", "getLength", "(", ")", ")", ")", "{", "if", "(", "LenCI", "->", "getZExtValue", "(", ")", ">=", "MaxAggrCopySize", ")", "{", "MemCalls", ".", "push_back", "(", "IntrCall", ")", ";", "}", "}", "else", "{", "MemCalls", ".", "push_back", "(", "IntrCall", ")", ";", "}", "}", "}", "}", "if", "(", "AggrLoads", ".", "size", "(", ")", "==", "0", "&&", "MemCalls", ".", "size", "(", ")", "==", "0", ")", "{", "return", "false", ";", "}", "for", "(", "LoadInst", "*", "LI", ":", "AggrLoads", ")", "{", "auto", "*", "SI", "=", "cast", "<", "StoreInst", ">", "(", "*", "LI", "->", "user_begin", "(", ")", ")", ";", "Value", "*", "SrcAddr", "=", "LI", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "DstAddr", "=", "SI", "->", "getOperand", "(", "1", ")", ";", "unsigned", "NumLoads", "=", "DL", ".", "getTypeStoreSize", "(", "LI", "->", "getType", "(", ")", ")", ";", "ConstantInt", "*", "CopyLen", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "Context", ")", ",", "NumLoads", ")", ";", "createMemCpyLoopKnownSize", "(", "SI", ",", "SrcAddr", ",", "DstAddr", ",", "CopyLen", ",", "LI", "->", "getAlign", "(", ")", ",", "SI", "->", "getAlign", "(", ")", ",", "LI", "->", "isVolatile", "(", ")", ",", "SI", "->", "isVolatile", "(", ")", ",", "TTI", ")", ";", "SI", "->", "eraseFromParent", "(", ")", ";", "LI", "->", "eraseFromParent", "(", ")", ";", "}", "for", "(", "MemIntrinsic", "*", "MemCall", ":", "MemCalls", ")", "{", "if", "(", "MemCpyInst", "*", "Memcpy", "=", "dyn_cast", "<", "MemCpyInst", ">", "(", "MemCall", ")", ")", "{", "expandMemCpyAsLoop", "(", "Memcpy", ",", "TTI", ")", ";", "}", "else", "if", "(", "MemMoveInst", "*", "Memmove", "=", "dyn_cast", "<", "MemMoveInst", ">", "(", "MemCall", ")", ")", "{", "expandMemMoveAsLoop", "(", "Memmove", ")", ";", "}", "else", "if", "(", "MemSetInst", "*", "Memset", "=", "dyn_cast", "<", "MemSetInst", ">", "(", "MemCall", ")", ")", "{", "expandMemSetAsLoop", "(", "Memset", ")", ";", "}", "MemCall", "->", "eraseFromParent", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "AnalyzeArguments", "(", "CCState", "&", "State", ",", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "ArgLocs", ",", "const", "SmallVectorImpl", "<", "ArgT", ">", "&", "Args", ")", "{", "static", "const", "MCPhysReg", "RegList", "[", "]", "=", "{", "MSP430", "::", "R15W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R12W", "}", ";", "static", "const", "unsigned", "NbRegs", "=", "array_lengthof", "(", "RegList", ")", ";", "if", "(", "State", ".", "isVarArg", "(", ")", ")", "{", "AnalyzeVarArgs", "(", "State", ",", "Args", ")", ";", "return", ";", "}", "SmallVector", "<", "unsigned", ",", "4", ">", "ArgsParts", ";", "ParseFunctionArgs", "(", "Args", ",", "ArgsParts", ")", ";", "unsigned", "RegsLeft", "=", "NbRegs", ";", "bool", "UseStack", "=", "false", ";", "unsigned", "ValNo", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgsParts", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "MVT", "ArgVT", "=", "Args", "[", "ValNo", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Args", "[", "ValNo", "]", ".", "Flags", ";", "MVT", "LocVT", "=", "ArgVT", ";", "CCValAssign", "::", "LocInfo", "LocInfo", "=", "CCValAssign", "::", "Full", ";", "if", "(", "LocVT", "==", "MVT", "::", "i8", ")", "{", "LocVT", "=", "MVT", "::", "i16", ";", "if", "(", "ArgFlags", ".", "isSExt", "(", ")", ")", "LocInfo", "=", "CCValAssign", "::", "SExt", ";", "else", "if", "(", "ArgFlags", ".", "isZExt", "(", ")", ")", "LocInfo", "=", "CCValAssign", "::", "ZExt", ";", "else", "LocInfo", "=", "CCValAssign", "::", "AExt", ";", "}", "if", "(", "ArgFlags", ".", "isByVal", "(", ")", ")", "{", "State", ".", "HandleByVal", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "2", ",", "2", ",", "ArgFlags", ")", ";", "continue", ";", "}", "unsigned", "Parts", "=", "ArgsParts", "[", "i", "]", ";", "if", "(", "!", "UseStack", "&&", "Parts", "<=", "RegsLeft", ")", "{", "unsigned", "FirstVal", "=", "ValNo", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "{", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "RegList", ",", "NbRegs", ")", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", "++", ",", "ArgVT", ",", "Reg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "RegsLeft", "--", ";", "}", "SmallVectorImpl", "<", "CCValAssign", ">", "::", "iterator", "B", "=", "ArgLocs", ".", "begin", "(", ")", "+", "FirstVal", ";", "std", "::", "reverse", "(", "B", ",", "B", "+", "Parts", ")", ";", "}", "else", "{", "UseStack", "=", "true", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "CC_MSP430_AssignStack", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "ArgFlags", ",", "State", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "function", "will", "invoke", "AnalyzeCallOperands", "." ]

[ "MSP430", "MSP430::R15W", "MSP430::R14W", "MSP430::R13W", "MSP430::R12W", "4", "0", "0", "ISD::ArgFlagsTy", "MVT::i8", "MVT::i16", "2", "2", "0", "0", "MSP430" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "{", "return", "\"AVR dynalloca stack pointer save/restore\"", ";", "}", "</s>" ]

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

[ "AVR", "\"AVR dynalloca stack pointer save/restore\"" ]

[]

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

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "ix86_override_options_after_change", "(", "void", ")", "{", "ix86_default_align", "(", "&", "global_options", ")", ";", "ix86_recompute_optlev_based_flags", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "(", "OPTION_SET_P", "(", "flag_unroll_loops", ")", ")", "||", "(", "OPTION_SET_P", "(", "flag_unroll_all_loops", ")", "&&", "flag_unroll_all_loops", ")", ")", "{", "if", "(", "!", "OPTION_SET_P", "(", "ix86_unroll_only_small_loops", ")", ")", "ix86_unroll_only_small_loops", "=", "0", ";", "if", "(", "!", "OPTION_SET_P", "(", "flag_web", ")", ")", "flag_web", "=", "flag_unroll_loops", ";", "if", "(", "!", "OPTION_SET_P", "(", "flag_rename_registers", ")", ")", "flag_rename_registers", "=", "flag_unroll_loops", ";", "if", "(", "!", "OPTION_SET_P", "(", "flag_cunroll_grow_size", ")", ")", "flag_cunroll_grow_size", "=", "flag_unroll_loops", "||", "flag_peel_loops", "||", "optimize", ">=", "3", ";", "}", "else", "{", "if", "(", "!", "OPTION_SET_P", "(", "flag_cunroll_grow_size", ")", ")", "flag_cunroll_grow_size", "=", "flag_peel_loops", "||", "optimize", ">=", "3", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE", "hook", "." ]

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

[]

[ "<s>", "bool", "AArch64A53Fix835769", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "TargetMachine", "&", "TM", "=", "F", ".", "getTarget", "(", ")", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A53Fix835769 *****\\n\"", ")", ";", "TII", "=", "TM", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64A53Fix835769 *****\\n\"", "AArch64" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "LowerOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"READCYCLECOUNTER only has custom type legalization on riscv32\"", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "RCW", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "READ_CYCLE_WIDE", ",", "DL", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "RCW", ")", ";", "Results", ".", "push_back", "(", "RCW", ".", "getValue", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "RCW", ".", "getValue", "(", "2", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "UREM", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "||", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", ")", "return", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_X_ANYEXTW_RV64", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i32", ",", "FPConv", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "ISD::READCYCLECOUNTER", "\"READCYCLECOUNTER only has custom type legalization on riscv32\"", "MVT::i32", "MVT::i32", "MVT::Other", "RISCVISD::READ_CYCLE_WIDE", "0", "1", "2", "ISD::SHL", "ISD::SRA", "ISD::SRL", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "1", "ISD::Constant", "ISD::SDIV", "ISD::UDIV", "ISD::UREM", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "ISD::Constant", "1", "ISD::Constant", "ISD::BITCAST", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "RISCVISD::FMV_X_ANYEXTW_RV64", "MVT::i64", "ISD::TRUNCATE", "MVT::i32" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "if", "(", "isIndirectJump", "(", "Inst", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxIndirectJump", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "unsigned", "AddrIdx", "=", "0", ";", "bool", "IsStore", "=", "false", ";", "bool", "IsMemAccess", "=", "isBasePlusOffsetMemoryAccess", "(", "Inst", ".", "getOpcode", "(", ")", ",", "&", "AddrIdx", ",", "&", "IsStore", ")", ";", "bool", "IsSPFirstOperand", "=", "isStackPointerFirstOperand", "(", "Inst", ")", ";", "if", "(", "IsMemAccess", "||", "IsSPFirstOperand", ")", "{", "bool", "MaskBefore", "=", "(", "IsMemAccess", "&&", "baseRegNeedsLoadStoreMask", "(", "Inst", ".", "getOperand", "(", "AddrIdx", ")", ".", "getReg", "(", ")", ")", ")", ";", "bool", "MaskAfter", "=", "IsSPFirstOperand", "&&", "!", "IsStore", ";", "if", "(", "MaskBefore", "||", "MaskAfter", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxLoadStoreStackChange", "(", "Inst", ",", "AddrIdx", ",", "STI", ",", "MaskBefore", ",", "MaskAfter", ")", ";", "return", ";", "}", "}", "bool", "IsIndirectCall", ";", "if", "(", "isCall", "(", "Inst", ",", "&", "IsIndirectCall", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "EmitBundleLock", "(", "true", ")", ";", "if", "(", "IsIndirectCall", ")", "{", "unsigned", "TargetReg", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "emitMask", "(", "TargetReg", ",", "IndirectBranchMaskReg", ",", "STI", ")", ";", "}", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "PendingCall", "=", "true", ";", "return", ";", "}", "if", "(", "PendingCall", ")", "{", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "EmitBundleUnlock", "(", ")", ";", "PendingCall", "=", "false", ";", "return", ";", "}", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Mips", "\"Dangerous instruction in branch delay slot!\"", "0", "\"Dangerous instruction in branch delay slot!\"", "\"Dangerous instruction in branch delay slot!\"", "1", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "static", "bool", "mep_store_find_set", "(", "const_rtx", "x", ",", "const", "rtx_insn", "*", "prev", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "NONCONST", ")", "if", "(", "REG_P", "(", "x", ")", "&&", "reg_set_p", "(", "x", ",", "prev", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "contains", "a", "register", "that", "is", "set", "by", "insn", "PREV", "." ]

[ "mep" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "GCNSubtarget", "*", "CallerST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", ")", ";", "const", "GCNSubtarget", "*", "CalleeST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "CallerST", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "CalleeST", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";", "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";", "if", "(", "(", "RealCallerBits", "&", "RealCalleeBits", ")", "!=", "RealCalleeBits", ")", "return", "false", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CallerMode", "(", "*", "Caller", ")", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CalleeMode", "(", "*", "Callee", ")", ";", "return", "CallerMode", ".", "isInlineCompatible", "(", "CalleeMode", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "AMDGPU", "AMDGPU::SIModeRegisterDefaults", "AMDGPU::SIModeRegisterDefaults" ]

[]

[ "<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", "(", "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", "PPC", "PPC" ]

[]

[ "<s>", "void", "ix86_emit_fp_unordered_jump", "(", "rtx", "label", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "temp", ";", "emit_insn", "(", "gen_x86_fnstsw_1", "(", "reg", ")", ")", ";", "if", "(", "TARGET_SAHF", "&&", "(", "TARGET_USE_SAHF", "||", "optimize_insn_for_size_p", "(", ")", ")", ")", "{", "emit_insn", "(", "gen_x86_sahf_1", "(", "reg", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_UNORDERED", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_testqi_ext_1_ccno", "(", "reg", ",", "GEN_INT", "(", "0x04", ")", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "temp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "temp", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "temp", ")", ";", "emit_jump_insn", "(", "temp", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "10", "/", "100", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "conditional", "jump", "to", "LABEL", ",", "if", "C2", "flag", "in", "FP", "status", "register", "is", "set", "." ]

[ "i386", "0x04", "10", "100" ]

[]

[ "<s>", "void", "HexagonRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOp", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MB", ".", "getParent", "(", ")", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "HFI", "=", "*", "HST", ".", "getFrameLowering", "(", ")", ";", "unsigned", "BP", "=", "0", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "HFI", ".", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "BP", ")", ";", "int", "RealOffset", "=", "Offset", "+", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "getImm", "(", ")", ";", "bool", "IsKill", "=", "false", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "TFR_FIA", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "MI", ".", "RemoveOperand", "(", "FIOp", "+", "1", ")", ";", "return", ";", "case", "Hexagon", "::", "TFR_FI", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "break", ";", "}", "if", "(", "!", "HII", ".", "isValidOffset", "(", "Opc", ",", "RealOffset", ")", ")", "{", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "TmpR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MB", ",", "II", ",", "DL", ",", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ",", "TmpR", ")", ".", "addReg", "(", "BP", ")", ".", "addImm", "(", "RealOffset", ")", ";", "BP", "=", "TmpR", ";", "RealOffset", "=", "0", ";", "IsKill", "=", "true", ";", "}", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToRegister", "(", "BP", ",", "false", ",", "false", ",", "IsKill", ")", ";", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Unexpected\"", "Hexagon", "0", "1", "Hexagon::TFR_FIA", "Hexagon::A2_addi", "1", "Hexagon::TFR_FI", "Hexagon::A2_addi", "Hexagon::IntRegsRegClass", "Hexagon::A2_addi", "0", "1" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreSched2", "(", ")", "{", "}", "</s>" ]

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

[ "RI5CY", "RISCV" ]

[]

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

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

[ "AVR", "AVR", "AVR" ]

[]

[ "<s>", "bool", "operands_ok_ldrd_strd", "(", "rtx", "rt", ",", "rtx", "rt2", ",", "rtx", "rn", ",", "HOST_WIDE_INT", "offset", ",", "bool", "wback", ",", "bool", "load", ")", "{", "unsigned", "int", "t", ",", "t2", ",", "n", ";", "if", "(", "!", "reload_completed", ")", "return", "true", ";", "if", "(", "!", "offset_ok_for_ldrd_strd", "(", "offset", ")", ")", "return", "false", ";", "t", "=", "REGNO", "(", "rt", ")", ";", "t2", "=", "REGNO", "(", "rt2", ")", ";", "n", "=", "REGNO", "(", "rn", ")", ";", "if", "(", "(", "TARGET_THUMB2", ")", "&&", "(", "(", "wback", "&&", "(", "n", "==", "t", "||", "n", "==", "t2", ")", ")", "||", "(", "t", "==", "SP_REGNUM", ")", "||", "(", "t", "==", "PC_REGNUM", ")", "||", "(", "t2", "==", "SP_REGNUM", ")", "||", "(", "t2", "==", "PC_REGNUM", ")", "||", "(", "!", "load", "&&", "(", "n", "==", "PC_REGNUM", ")", ")", "||", "(", "load", "&&", "(", "t", "==", "t2", ")", ")", "||", "(", "!", "wback", "&&", "load", "&&", "fix_cm3_ldrd", "&&", "(", "n", "==", "t", ")", ")", ")", ")", "return", "false", ";", "if", "(", "(", "TARGET_ARM", ")", "&&", "(", "(", "wback", "&&", "(", "n", "==", "t", "||", "n", "==", "t2", ")", ")", "||", "(", "t2", "==", "PC_REGNUM", ")", "||", "(", "t", "%", "2", "!=", "0", ")", "||", "(", "t2", "!=", "t", "+", "1", ")", "||", "(", "n", "==", "PC_REGNUM", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "operands", "are", "valid", "for", "use", "in", "an", "LDRD/STRD", "instruction", ".", "Assumes", "that", "RT", ",", "RT2", ",", "and", "RN", "are", "REG", ".", "This", "is", "guaranteed", "by", "the", "patterns", ".", "Assumes", "that", "the", "address", "in", "the", "base", "register", "RN", "is", "word", "aligned", ".", "Pattern", "guarantees", "that", "both", "memory", "accesses", "use", "the", "same", "base", "register", ",", "the", "offsets", "are", "constants", "within", "the", "range", ",", "and", "the", "gap", "between", "the", "offsets", "is", "4", ".", "If", "preload", "complete", "then", "check", "that", "registers", "are", "legal", ".", "WBACK", "indicates", "whether", "address", "is", "updated", ".", "LOAD", "indicates", "whether", "memory", "access", "is", "load", "or", "store", "." ]

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

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "releaseSucc", "(", "SUnit", "*", "SU", ",", "SDep", "*", "SuccEdge", ")", "{", "SUnit", "*", "SuccSU", "=", "SuccEdge", "->", "getSUnit", "(", ")", ";", "if", "(", "SuccEdge", "->", "isWeak", "(", ")", ")", "{", "--", "SuccSU", "->", "WeakPredsLeft", ";", "return", ";", "}", "if", "(", "SuccSU", "->", "NumPredsLeft", "==", "0", ")", "{", "dbgs", "(", ")", "<<", "\"*** Scheduling failed! ***\\n\"", ";", "SuccSU", "->", "dumpAttributes", "(", ")", ";", "dbgs", "(", ")", "<<", "\" has been released too many times!\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "--", "SuccSU", "->", "NumPredsLeft", ";", "if", "(", "SuccSU", "->", "NumPredsLeft", "==", "0", "&&", "SuccSU", "!=", "&", "ExitSU", ")", "SchedImpl", "->", "releaseTopNode", "(", "SuccSU", ")", ";", "}", "</s>" ]

[ "ReleaseSucc", "-", "Decrement", "the", "NumPredsLeft", "count", "of", "a", "successor", "." ]

[ "Patmos", "0", "\"*** Scheduling failed! ***\\n\"", "\" has been released too many times!\\n\"", "0", "0" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "*", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "*", "Op", "=", "static_cast", "<", "ARMOperand", "*", ">", "(", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK__35_0", ":", "if", "(", "Op", "->", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", "->", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_ARMSOImm", ":", "if", "(", "Op", "->", "isImm", "(", ")", ")", "{", "const", "MCExpr", "*", "SOExpr", "=", "Op", "->", "getImm", "(", ")", ";", "int64_t", "Value", ";", "if", "(", "!", "SOExpr", "->", "EvaluateAsAbsolute", "(", "Value", ")", ")", "return", "Match_Success", ";", "assert", "(", "(", "Value", ">=", "INT32_MIN", "&&", "Value", "<=", "INT32_MAX", ")", "&&", "\"expression value must be representiable in 32 bits\"", ")", ";", "}", "break", ";", "case", "MCK_GPRPair", ":", "if", "(", "Op", "->", "isReg", "(", ")", "&&", "MRI", "->", "getRegClass", "(", "ARM", "::", "GPRRegClassID", ")", ".", "contains", "(", "Op", "->", "getReg", "(", ")", ")", ")", "return", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM", "\"expression value must be representiable in 32 bits\"", "ARM::GPRRegClassID" ]

[]

[ "<s>", "static", "rtx", "mips_force_temporary", "(", "rtx", "dest", ",", "rtx", "value", ")", "{", "if", "(", "can_create_pseudo_p", "(", ")", ")", "return", "force_reg", "(", "Pmode", ",", "value", ")", ";", "else", "{", "mips_emit_move", "(", "dest", ",", "value", ")", ";", "return", "dest", ";", "}", "}", "</s>" ]

[ "Copy", "VALUE", "to", "a", "register", "and", "return", "that", "register", ".", "If", "new", "psuedos", "are", "allowed", ",", "copy", "it", "into", "a", "new", "register", ",", "otherwise", "use", "DEST", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "aarch64_mode_valid_for_sched_fusion_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", "||", "(", "aarch64_vector_mode_supported_p", "(", "mode", ")", "&&", "(", "known_eq", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "8", ")", "||", "(", "known_eq", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "16", ")", "&&", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS", ")", "==", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "one", "of", "the", "modes", "for", "which", "we", "support", "LDP/STP", "operations", "." ]

[ "aarch64", "8", "16", "0" ]

[]

[ "<s>", "static", "MipsOperand", "*", "CreateMem", "(", "unsigned", "Base", ",", "const", "MCExpr", "*", "Off", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "MipsOperand", "*", "Op", "=", "new", "MipsOperand", "(", "k_Memory", ")", ";", "Op", "->", "Mem", ".", "Base", "=", "Base", ";", "Op", "->", "Mem", ".", "Off", "=", "Off", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AVRTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "LD8loRegClass", ")", ";", "case", "'b'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "PTRDISPREGSRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "LD8RegClass", ")", ";", "case", "'l'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPR8loRegClass", ")", ";", "case", "'e'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'q'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPRSPRegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPR8RegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i16", "&&", "\"inline asm constraint too large\"", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "DREGSRegClass", ")", ";", "case", "'t'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R0", ")", ",", "&", "AVR", "::", "GPR8RegClass", ")", ";", "case", "'w'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "IWREGSRegClass", ")", ";", "case", "'x'", ":", "case", "'X'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R27R26", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'y'", ":", "case", "'Y'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R29R28", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'z'", ":", "case", "'Z'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R31R30", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Subtarget", ".", "getRegisterInfo", "(", ")", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "1", "0", "0U", "AVR::LD8loRegClass", "0U", "AVR::PTRDISPREGSRegClass", "0U", "AVR::LD8RegClass", "0U", "AVR::GPR8loRegClass", "0U", "AVR::PTRREGSRegClass", "0U", "AVR::GPRSPRegClass", "MVT::i8", "0U", "AVR::GPR8RegClass", "MVT::i16", "\"inline asm constraint too large\"", "0U", "AVR::DREGSRegClass", "AVR::R0", "AVR::GPR8RegClass", "0U", "AVR::IWREGSRegClass", "AVR::R27R26", "AVR::PTRREGSRegClass", "AVR::R29R28", "AVR::PTRREGSRegClass", "AVR::R31R30", "AVR::PTRREGSRegClass" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getSqrtInputTest", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "const", "DenormalMode", "&", "Mode", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "!", "isTypeLegal", "(", "MVT", "::", "i1", ")", "||", "(", "VT", "!=", "MVT", "::", "f64", "&&", "(", "(", "VT", "!=", "MVT", "::", "v2f64", "&&", "VT", "!=", "MVT", "::", "v4f32", ")", "||", "!", "Subtarget", ".", "hasVSX", "(", ")", ")", ")", ")", "return", "TargetLowering", "::", "getSqrtInputTest", "(", "Op", ",", "DAG", ",", "Mode", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "FTSQRT", "=", "DAG", ".", "getNode", "(", "PPCISD", "::", "FTSQRT", ",", "DL", ",", "MVT", "::", "i32", ",", "Op", ")", ";", "SDValue", "SRIdxVal", "=", "DAG", ".", "getTargetConstant", "(", "PPC", "::", "sub_eq", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "EXTRACT_SUBREG", ",", "DL", ",", "MVT", "::", "i1", ",", "FTSQRT", ",", "SRIdxVal", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "a", "target-dependent", "comparison", "result", "if", "the", "input", "operand", "is", "suitable", "for", "use", "with", "a", "square", "root", "estimate", "calculation", "." ]

[ "PowerPC", "PPC", "MVT::i1", "MVT::f64", "MVT::v2f64", "MVT::v4f32", "PPCISD::FTSQRT", "MVT::i32", "PPC::sub_eq", "MVT::i32", "MVT::i1", "0" ]

[]

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

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "XCore", "MVT::i32" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_PPC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "VT", "=", "VA", ".", "getValVT", "(", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::InputArg", "16", "PPC", "0", "\"Can only return in registers!\"", "1", "0", "2" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "(", "void", ")", "Opc", ";", "assert", "(", "(", "Opc", "==", "Hexagon", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "Hexagon", "::", "ADJCALLSTACKUP", ")", "&&", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::ADJCALLSTACKDOWN", "Hexagon::ADJCALLSTACKUP", "\"Cannot handle this call frame pseudo instruction\"" ]

[]

[ "<s>", "static", "bool", "mips_vectorize_vec_perm_const_ok", "(", "machine_mode", "vmode", ",", "const", "unsigned", "char", "*", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "unsigned", "int", "i", ",", "nelt", ",", "which", ";", "bool", "ret", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "d", ".", "testing_p", "=", "true", ";", "memcpy", "(", "d", ".", "perm", ",", "sel", ",", "nelt", ")", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "char", "e", "=", "d", ".", "perm", "[", "i", "]", ";", "gcc_assert", "(", "e", "<", "2", "*", "nelt", ")", ";", "which", "|=", "(", "e", "<", "nelt", "?", "1", ":", "2", ")", ";", "}", "if", "(", "which", "==", "2", ")", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "-=", "nelt", ";", "d", ".", "one_vector_p", "=", "(", "which", "!=", "3", ")", ";", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "if", "(", "!", "d", ".", "one_vector_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "3", ")", ";", "start_sequence", "(", ")", ";", "ret", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST_OK", "." ]

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

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "createSIMemoryLegalizerPass", "(", ")", ")", ";", "if", "(", "EnableSIInsertWaitcntsPass", ")", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "else", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mn10300_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "FP_REGS", "||", "REGNO_REG_CLASS", "(", "regno", ")", "==", "FP_ACC_REGS", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "(", "(", "regno", "&", "1", ")", "==", "0", ")", ";", "if", "(", "!", "TARGET_AM33", "&&", "REGNO_REG_CLASS", "(", "regno", ")", "==", "EXTENDED_REGS", ")", "return", "false", ";", "if", "(", "(", "(", "regno", ")", "&", "1", ")", "==", "0", "||", "GET_MODE_SIZE", "(", "mode", ")", "==", "4", ")", "return", "true", ";", "if", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "DATA_REGS", "||", "(", "TARGET_AM33", "&&", "REGNO_REG_CLASS", "(", "regno", ")", "==", "ADDRESS_REGS", ")", "||", "REGNO_REG_CLASS", "(", "regno", ")", "==", "EXTENDED_REGS", ")", "return", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "mn10300", "1", "0", "1", "0", "4", "4" ]

[]

[ "<s>", "bool", "MipsSEDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "false", ";", "return", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MSP430PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMSP430ISelDag", "(", "getMSP430TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "static", "tree", "ix86_veclibabi_svml", "(", "enum", "built_in_function", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "char", "name", "[", "20", "]", ";", "tree", "fntype", ",", "new_fndecl", ",", "args", ";", "unsigned", "arity", ";", "const", "char", "*", "bname", ";", "machine_mode", "el_mode", ",", "in_mode", ";", "int", "n", ",", "in_n", ";", "if", "(", "!", "flag_unsafe_math_optimizations", ")", "return", "NULL_TREE", ";", "el_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "if", "(", "el_mode", "!=", "in_mode", "||", "n", "!=", "in_n", ")", "return", "NULL_TREE", ";", "switch", "(", "fn", ")", "{", "case", "BUILT_IN_EXP", ":", "case", "BUILT_IN_LOG", ":", "case", "BUILT_IN_LOG10", ":", "case", "BUILT_IN_POW", ":", "case", "BUILT_IN_TANH", ":", "case", "BUILT_IN_TAN", ":", "case", "BUILT_IN_ATAN", ":", "case", "BUILT_IN_ATAN2", ":", "case", "BUILT_IN_ATANH", ":", "case", "BUILT_IN_CBRT", ":", "case", "BUILT_IN_SINH", ":", "case", "BUILT_IN_SIN", ":", "case", "BUILT_IN_ASINH", ":", "case", "BUILT_IN_ASIN", ":", "case", "BUILT_IN_COSH", ":", "case", "BUILT_IN_COS", ":", "case", "BUILT_IN_ACOSH", ":", "case", "BUILT_IN_ACOS", ":", "if", "(", "el_mode", "!=", "DFmode", "||", "n", "!=", "2", ")", "return", "NULL_TREE", ";", "break", ";", "case", "BUILT_IN_EXPF", ":", "case", "BUILT_IN_LOGF", ":", "case", "BUILT_IN_LOG10F", ":", "case", "BUILT_IN_POWF", ":", "case", "BUILT_IN_TANHF", ":", "case", "BUILT_IN_TANF", ":", "case", "BUILT_IN_ATANF", ":", "case", "BUILT_IN_ATAN2F", ":", "case", "BUILT_IN_ATANHF", ":", "case", "BUILT_IN_CBRTF", ":", "case", "BUILT_IN_SINHF", ":", "case", "BUILT_IN_SINF", ":", "case", "BUILT_IN_ASINHF", ":", "case", "BUILT_IN_ASINF", ":", "case", "BUILT_IN_COSHF", ":", "case", "BUILT_IN_COSF", ":", "case", "BUILT_IN_ACOSHF", ":", "case", "BUILT_IN_ACOSF", ":", "if", "(", "el_mode", "!=", "SFmode", "||", "n", "!=", "4", ")", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "builtin_decl_implicit", "(", "fn", ")", ")", ")", ";", "if", "(", "fn", "==", "BUILT_IN_LOGF", ")", "strcpy", "(", "name", ",", "\"vmlsLn4\"", ")", ";", "else", "if", "(", "fn", "==", "BUILT_IN_LOG", ")", "strcpy", "(", "name", ",", "\"vmldLn2\"", ")", ";", "else", "if", "(", "n", "==", "4", ")", "{", "sprintf", "(", "name", ",", "\"vmls%s\"", ",", "bname", "+", "10", ")", ";", "name", "[", "strlen", "(", "name", ")", "-", "1", "]", "=", "'4'", ";", "}", "else", "sprintf", "(", "name", ",", "\"vmld%s2\"", ",", "bname", "+", "10", ")", ";", "name", "[", "4", "]", "&=", "~", "0x20", ";", "arity", "=", "0", ";", "for", "(", "args", "=", "DECL_ARGUMENTS", "(", "builtin_decl_implicit", "(", "fn", ")", ")", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "arity", "++", ";", "if", "(", "arity", "==", "1", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "NULL", ")", ";", "else", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "type_in", ",", "NULL", ")", ";", "new_fndecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "fntype", ")", ";", "TREE_PUBLIC", "(", "new_fndecl", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "new_fndecl", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "new_fndecl", ")", "=", "1", ";", "TREE_READONLY", "(", "new_fndecl", ")", "=", "1", ";", "return", "new_fndecl", ";", "}", "</s>" ]

[ "Handler", "for", "an", "SVML-style", "interface", "to", "a", "library", "with", "vectorized", "intrinsics", "." ]

[ "i386", "20", "2", "4", "\"vmlsLn4\"", "\"vmldLn2\"", "4", "\"vmls%s\"", "10", "1", "\"vmld%s2\"", "10", "4", "0x20", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "unsigned", "getSpillSize", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "override", "{", "return", "4", ";", "}", "</s>" ]

[ "Return", "the", "size", "in", "bytes", "of", "the", "stack", "slot", "allocated", "to", "hold", "a", "spilled", "copy", "of", "a", "register", "from", "class", "RC", "." ]

[ "M680x0", "4" ]

[]

[ "<s>", "int", "hppa_can_use_return_insn_p", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "(", "compute_frame_size", "(", "get_frame_size", "(", ")", ",", "0", ")", "?", "0", ":", "1", ")", "&&", "!", "regs_ever_live", "[", "2", "]", "&&", "!", "frame_pointer_needed", ")", ";", "}", "</s>" ]

[ "This", "is", "only", "valid", "once", "reload", "has", "completed", "because", "it", "depends", "on", "knowing", "exactly", "how", "much", "(", "if", "any", ")", "frame", "there", "is", "and", "...", "It", "'s", "only", "valid", "if", "there", "is", "no", "frame", "marker", "to", "de-allocate", "and", "...", "It", "'s", "only", "valid", "if", "%", "r2", "has", "n't", "been", "saved", "into", "the", "caller", "'s", "frame", "(", "we", "'re", "not", "profiling", "and", "%", "r2", "is", "n't", "live", "anywhere", ")", "." ]

[ "pa", "0", "0", "1", "2" ]

[]

[ "<s>", "bool", "RISCVCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_rev_local", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "HOST_WIDE_INT", "diff", ";", "unsigned", "int", "i", ",", "size", ",", "unspec", ";", "machine_mode", "pred_mode", ";", "if", "(", "d", "->", "vec_flags", "==", "VEC_SVE_PRED", "||", "!", "d", "->", "one_vector_p", "||", "!", "d", "->", "perm", "[", "0", "]", ".", "is_constant", "(", "&", "diff", ")", ")", "return", "false", ";", "size", "=", "(", "diff", "+", "1", ")", "*", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ";", "if", "(", "size", "==", "8", ")", "{", "unspec", "=", "UNSPEC_REV64", ";", "pred_mode", "=", "VNx2BImode", ";", "}", "else", "if", "(", "size", "==", "4", ")", "{", "unspec", "=", "UNSPEC_REV32", ";", "pred_mode", "=", "VNx4BImode", ";", "}", "else", "if", "(", "size", "==", "2", ")", "{", "unspec", "=", "UNSPEC_REV16", ";", "pred_mode", "=", "VNx8BImode", ";", "}", "else", "return", "false", ";", "unsigned", "int", "step", "=", "diff", "+", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "step", ";", "++", "i", ")", "if", "(", "!", "d", "->", "perm", ".", "series_p", "(", "i", ",", "step", ",", "diff", "-", "i", ",", "step", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "if", "(", "d", "->", "vec_flags", "==", "VEC_SVE_DATA", ")", "{", "machine_mode", "int_mode", "=", "aarch64_sve_int_mode", "(", "pred_mode", ")", ";", "rtx", "target", "=", "gen_reg_rtx", "(", "int_mode", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_aarch64_sve_reinterpret", "(", "int_mode", ",", "target", ",", "d", "->", "op0", ")", ")", ";", "else", "{", "int", "unspec", "=", "aarch64_sve_rev_unspec", "(", "d", "->", "vmode", ")", ";", "rtx", "pred", "=", "aarch64_ptrue_reg", "(", "pred_mode", ")", ";", "emit_insn", "(", "gen_aarch64_pred", "(", "unspec", ",", "int_mode", ",", "target", ",", "pred", ",", "gen_lowpart", "(", "int_mode", ",", "d", "->", "op0", ")", ")", ")", ";", "}", "emit_move_insn", "(", "d", "->", "target", ",", "gen_lowpart", "(", "d", "->", "vmode", ",", "target", ")", ")", ";", "return", "true", ";", "}", "rtx", "src", "=", "gen_rtx_UNSPEC", "(", "d", "->", "vmode", ",", "gen_rtvec", "(", "1", ",", "d", "->", "op0", ")", ",", "unspec", ")", ";", "emit_set_insn", "(", "d", "->", "target", ",", "src", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "REV", "{", "64,32,16", "}", "insns", ",", "which", "reverse", "elements", "within", "each", "64-bit", ",", "32-bit", "or", "16-bit", "granule", "." ]

[ "aarch64", "0", "1", "8", "4", "2", "1", "0", "1" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "Move32R16", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "S0", ")", ";", "TII", ".", "restoreFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips::Move32R16", "Mips::SP", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "static", "void", "ix86_init_builtins_va_builtins_abi", "(", "void", ")", "{", "tree", "ms_va_ref", ",", "sysv_va_ref", ";", "tree", "fnvoid_va_end_ms", ",", "fnvoid_va_end_sysv", ";", "tree", "fnvoid_va_start_ms", ",", "fnvoid_va_start_sysv", ";", "tree", "fnvoid_va_copy_ms", ",", "fnvoid_va_copy_sysv", ";", "tree", "fnattr_ms", "=", "NULL_TREE", ",", "fnattr_sysv", "=", "NULL_TREE", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", ";", "fnattr_ms", "=", "build_tree_list", "(", "get_identifier", "(", "\"ms_abi\"", ")", ",", "NULL_TREE", ")", ";", "fnattr_sysv", "=", "build_tree_list", "(", "get_identifier", "(", "\"sysv_abi\"", ")", ",", "NULL_TREE", ")", ";", "ms_va_ref", "=", "build_reference_type", "(", "ms_va_list_type_node", ")", ";", "sysv_va_ref", "=", "build_pointer_type", "(", "TREE_TYPE", "(", "sysv_va_list_type_node", ")", ")", ";", "fnvoid_va_end_ms", "=", "build_function_type_list", "(", "void_type_node", ",", "ms_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_start_ms", "=", "build_varargs_function_type_list", "(", "void_type_node", ",", "ms_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_end_sysv", "=", "build_function_type_list", "(", "void_type_node", ",", "sysv_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_start_sysv", "=", "build_varargs_function_type_list", "(", "void_type_node", ",", "sysv_va_ref", ",", "NULL_TREE", ")", ";", "fnvoid_va_copy_ms", "=", "build_function_type_list", "(", "void_type_node", ",", "ms_va_ref", ",", "ms_va_list_type_node", ",", "NULL_TREE", ")", ";", "fnvoid_va_copy_sysv", "=", "build_function_type_list", "(", "void_type_node", ",", "sysv_va_ref", ",", "sysv_va_ref", ",", "NULL_TREE", ")", ";", "add_builtin_function", "(", "\"__builtin_ms_va_start\"", ",", "fnvoid_va_start_ms", ",", "BUILT_IN_VA_START", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_ms", ")", ";", "add_builtin_function", "(", "\"__builtin_ms_va_end\"", ",", "fnvoid_va_end_ms", ",", "BUILT_IN_VA_END", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_ms", ")", ";", "add_builtin_function", "(", "\"__builtin_ms_va_copy\"", ",", "fnvoid_va_copy_ms", ",", "BUILT_IN_VA_COPY", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_ms", ")", ";", "add_builtin_function", "(", "\"__builtin_sysv_va_start\"", ",", "fnvoid_va_start_sysv", ",", "BUILT_IN_VA_START", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_sysv", ")", ";", "add_builtin_function", "(", "\"__builtin_sysv_va_end\"", ",", "fnvoid_va_end_sysv", ",", "BUILT_IN_VA_END", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_sysv", ")", ";", "add_builtin_function", "(", "\"__builtin_sysv_va_copy\"", ",", "fnvoid_va_copy_sysv", ",", "BUILT_IN_VA_COPY", ",", "BUILT_IN_NORMAL", ",", "NULL", ",", "fnattr_sysv", ")", ";", "}", "</s>" ]

[ "Internal", "method", "for", "ix86_init_builtins", "." ]

[ "i386", "\"ms_abi\"", "\"sysv_abi\"", "\"__builtin_ms_va_start\"", "\"__builtin_ms_va_end\"", "\"__builtin_ms_va_copy\"", "\"__builtin_sysv_va_start\"", "\"__builtin_sysv_va_end\"", "\"__builtin_sysv_va_copy\"" ]

[]

[ "<s>", "static", "bool", "alpha_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "return", "GET_CODE", "(", "addr", ")", "==", "AND", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", ".", "On", "the", "Alpha", "this", "is", "true", "only", "for", "the", "unaligned", "modes", ".", "We", "can", "simplify", "the", "test", "since", "we", "know", "that", "the", "address", "must", "be", "valid", "." ]

[ "alpha" ]

[]

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

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

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

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addLegalizeMachineIR", "(", ")", "{", "addPass", "(", "new", "MachineLegalizePass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "ARM64" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "unsigned", "ExtraCondLat", "=", "Cond", ".", "size", "(", ")", "!=", "1", ";", "if", "(", "AArch64", "::", "GPR64allRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "GPR32allRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "1", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "1", ";", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "TrueReg", ")", ")", "TrueCycles", "=", "0", ";", "else", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "FalseReg", ")", ")", "FalseCycles", "=", "0", ";", "return", "true", ";", "}", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "5", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "AArch64", "AArch64", "1", "AArch64::GPR64allRegClass", "AArch64::GPR32allRegClass", "1", "1", "0", "0", "AArch64::FPR64RegClass", "AArch64::FPR32RegClass", "5", "2" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "DagAssign", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "AliasAnalysis", "*", "AA", "=", "&", "getAnalysis", "<", "AliasAnalysis", ">", "(", ")", ";", "TMS320C64XMachineFunctionInfo", "*", "MFI", "=", "Fn", ".", "getInfo", "<", "TMS320C64XMachineFunctionInfo", ">", "(", ")", ";", "std", "::", "queue", "<", "MachineBasicBlock", "*", ">", "ScheduleQ", ";", "std", "::", "vector", "<", "unsigned", ">", "PredsVisited", "(", "Fn", ".", "size", "(", ")", ",", "0", ")", ";", "std", "::", "set", "<", "MachineBasicBlock", "*", ">", "Scheduled", ";", "typedef", "std", "::", "map", "<", "MachineBasicBlock", "*", ",", "MachineSuperBlock", "*", ">", "EntryMSBMap", ";", "EntryMSBMap", "Entries", ";", "unsigned", "sumCycles", "=", "0", ";", "MachineSuperBlockMapTy", "MSBs", "=", "SuperblockFormation", "::", "getSuperblocks", "(", ")", ";", "AssignmentState", "State", ";", "Scheduler", "=", "createClusterDAG", "(", "Algo", ",", "Fn", ",", "MLI", ",", "MDT", ",", "AA", ",", "&", "State", ")", ";", "ResourceAssignment", "*", "RA", "=", "TMS320C64XInstrInfo", "::", "CreateFunctionalUnitScheduler", "(", "&", "TM", ")", ";", "Scheduler", "->", "setFunctionalUnitScheduler", "(", "RA", ")", ";", "for", "(", "MachineSuperBlockMapTy", "::", "iterator", "MSBI", "=", "MSBs", ".", "begin", "(", ")", ",", "MSBE", "=", "MSBs", ".", "end", "(", ")", ";", "MSBI", "!=", "MSBE", ";", "++", "MSBI", ")", "{", "MachineSuperBlock", "*", "MSB", "=", "MSBI", "->", "second", ";", "Entries", ".", "insert", "(", "std", "::", "make_pair", "(", "MSB", "->", "getEntry", "(", ")", ",", "MSB", ")", ")", ";", "}", "ScheduleQ", ".", "push", "(", "&", "Fn", ".", "front", "(", ")", ")", ";", "while", "(", "!", "ScheduleQ", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "ScheduleQ", ".", "front", "(", ")", ";", "ScheduleQ", ".", "pop", "(", ")", ";", "if", "(", "Scheduled", ".", "count", "(", "MBB", ")", ")", "continue", ";", "MachineSuperBlock", "*", "MSB", ";", "std", "::", "auto_ptr", "<", "MachineSuperBlock", ">", "ownedMSB", ";", "EntryMSBMap", "::", "iterator", "it", ";", "if", "(", "(", "it", "=", "Entries", ".", "find", "(", "MBB", ")", ")", "!=", "Entries", ".", "end", "(", ")", ")", "{", "MSB", "=", "it", "->", "second", ";", "}", "else", "{", "if", "(", "!", "MBB", "->", "size", "(", ")", ")", "continue", ";", "ownedMSB", "=", "std", "::", "auto_ptr", "<", "MachineSuperBlock", ">", "(", "new", "MachineSuperBlock", "(", "Fn", ",", "*", "MBB", ")", ")", ";", "MSB", "=", "ownedMSB", ".", "get", "(", ")", ";", "}", "assignPHIs", "(", "&", "State", ",", "MBB", ")", ";", "Scheduler", "->", "Run", "(", "MSB", ")", ";", "Scheduled", ".", "insert", "(", "MSB", "->", "begin", "(", ")", ",", "MSB", "->", "end", "(", ")", ")", ";", "sumCycles", "+=", "Scheduler", "->", "getCycles", "(", ")", ";", "for", "(", "MachineSuperBlock", "::", "iterator", "MBBI", "=", "MSB", "->", "begin", "(", ")", ",", "MBBE", "=", "MSB", "->", "end", "(", ")", ";", "MBBI", "!=", "MBBE", ";", "++", "MBBI", ")", "{", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "SI", "=", "(", "*", "MBBI", ")", "->", "succ_begin", "(", ")", ",", "SE", "=", "(", "*", "MBBI", ")", "->", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "{", "MachineBasicBlock", "*", "Succ", "=", "*", "SI", ";", "ScheduleQ", ".", "push", "(", "Succ", ")", ";", "}", "}", "}", "MFI", "->", "setScheduledCyclesPre", "(", "sumCycles", ")", ";", "delete", "Scheduler", ";", "delete", "RA", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "TMS320C64X", "0", "0", "TMS320C64X" ]

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "override", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "FK_NONE", ":", "return", "true", ";", "case", "PPC", "::", "fixup_ppc_br24", ":", "case", "PPC", "::", "fixup_ppc_br24abs", ":", "if", "(", "const", "MCSymbolRefExpr", "*", "A", "=", "Target", ".", "getSymA", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "S", "=", "dyn_cast", "<", "MCSymbolELF", ">", "(", "&", "A", "->", "getSymbol", "(", ")", ")", ")", "{", "unsigned", "Other", "=", "S", "->", "getOther", "(", ")", "<<", "2", ";", "if", "(", "(", "Other", "&", "ELF", "::", "STO_PPC64_LOCAL_MASK", ")", "!=", "0", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC::fixup_ppc_br24", "PPC::fixup_ppc_br24abs", "2", "PPC", "0" ]

[]

[ "<s>", "bool", "mn10300_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "FIRST_DATA_REGNUM", "||", "regno", "==", "FIRST_ADDRESS_REGNUM", ")", ";", "}", "</s>" ]

[ "Implements", "FUNCTION_VALUE_REGNO_P", "." ]

[ "mn10300" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline assembly memory operand\"", ")", ";", "O", "<<", "'['", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "']'", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"unexpected inline assembly memory operand\"", "AArch64" ]

[]

[ "<s>", "uint64_t", "MipsGOTPLT", "::", "emit", "(", "MemoryRegion", "&", "pRegion", ")", "{", "uint32_t", "*", "buffer", "=", "reinterpret_cast", "<", "uint32_t", "*", ">", "(", "pRegion", ".", "begin", "(", ")", ")", ";", "uint64_t", "result", "=", "0", ";", "for", "(", "iterator", "it", "=", "begin", "(", ")", ",", "ie", "=", "end", "(", ")", ";", "it", "!=", "ie", ";", "++", "it", ",", "++", "buffer", ")", "{", "GOTPLTEntry", "*", "got", "=", "&", "(", "llvm", "::", "cast", "<", "GOTPLTEntry", ">", "(", "(", "*", "it", ")", ")", ")", ";", "*", "buffer", "=", "static_cast", "<", "uint32_t", ">", "(", "got", "->", "getValue", "(", ")", ")", ";", "result", "+=", "got", "->", "size", "(", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "arc_return_address_register", "(", "unsigned", "int", "fn_type", ")", "{", "int", "regno", "=", "0", ";", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "if", "(", "(", "fn_type", "&", "(", "ARC_FUNCTION_ILINK1", "|", "ARC_FUNCTION_FIRQ", ")", ")", "!=", "0", ")", "regno", "=", "ILINK1_REG", ";", "else", "if", "(", "(", "fn_type", "&", "ARC_FUNCTION_ILINK2", ")", "!=", "0", ")", "regno", "=", "ILINK2_REG", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ARC_NORMAL_P", "(", "fn_type", ")", "||", "ARC_NAKED_P", "(", "fn_type", ")", ")", "regno", "=", "RETURN_ADDR_REGNUM", ";", "gcc_assert", "(", "regno", "!=", "0", ")", ";", "return", "regno", ";", "}", "</s>" ]

[ "Return", "the", "register", "number", "of", "the", "register", "holding", "the", "return", "address", "for", "a", "function", "of", "type", "TYPE", "." ]

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "else", "if", "(", "Constraint", "==", "\"wc\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "}", "else", "if", "(", "Constraint", "==", "\"wa\"", "||", "Constraint", "==", "\"wd\"", "||", "Constraint", "==", "\"wf\"", "||", "Constraint", "==", "\"ws\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "first", "&&", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", "&&", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "R", ".", "first", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "std", "::", "make_pair", "(", "TRI", "->", "getMatchingSuperReg", "(", "R", ".", "first", ",", "PPC", "::", "sub_32", ",", "&", "PPC", "::", "G8RCRegClass", ")", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "}", "return", "R", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RC_NOX0RegClass", "0U", "PPC::GPRC_NOR0RegClass", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass", "\"wc\"", "0U", "PPC::CRBITRCRegClass", "\"wa\"", "\"wd\"", "\"wf\"", "\"ws\"", "0U", "PPC::VSRCRegClass", "MVT::i64", "PPC", "PPC", "PPC::GPRCRegClass", "PPC::sub_32", "PPC::G8RCRegClass", "PPC::G8RCRegClass" ]

[]

[ "<s>", "static", "rtx", "loongarch_force_binary", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "reg", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "loongarch_emit_binary", "(", "code", ",", "reg", ",", "op0", ",", "op1", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Compute", "(", "CODE", "OP0", "OP1", ")", "and", "store", "the", "result", "in", "a", "new", "register", "of", "mode", "MODE", ".", "Return", "that", "new", "register", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "bool", "aapcs_vfp_is_call_or_return_candidate", "(", "enum", "arm_pcs", "pcs_variant", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "machine_mode", "*", "base_mode", ",", "int", "*", "count", ")", "{", "machine_mode", "new_mode", "=", "VOIDmode", ";", "if", "(", "type", ")", "{", "int", "ag_count", "=", "aapcs_vfp_sub_candidate", "(", "type", ",", "&", "new_mode", ")", ";", "if", "(", "ag_count", ">", "0", "&&", "ag_count", "<=", "4", ")", "*", "count", "=", "ag_count", ";", "else", "return", "false", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "*", "count", "=", "1", ";", "new_mode", "=", "mode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "{", "*", "count", "=", "2", ";", "new_mode", "=", "(", "mode", "==", "DCmode", "?", "DFmode", ":", "SFmode", ")", ";", "}", "else", "return", "false", ";", "if", "(", "!", "use_vfp_abi", "(", "pcs_variant", ",", "ARM_NUM_REGS", "(", "new_mode", ")", ">", "1", ")", ")", "return", "false", ";", "*", "base_mode", "=", "new_mode", ";", "if", "(", "TARGET_GENERAL_REGS_ONLY", ")", "error", "(", "\"argument of type %qT not permitted with -mgeneral-regs-only\"", ",", "type", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "argument", "whose", "type", "is", "TYPE", ",", "or", "mode", "is", "MODE", ",", "is", "suitable", "for", "passing", "or", "returning", "in", "VFP", "registers", "for", "the", "PCS", "variant", "selected", ".", "If", "it", "is", ",", "then", "*", "BASE_MODE", "is", "updated", "to", "contain", "a", "machine", "mode", "describing", "each", "element", "of", "the", "argument", "'s", "type", "and", "*", "COUNT", "to", "hold", "the", "number", "of", "such", "elements", "." ]

[ "arm", "0", "4", "1", "2", "1", "\"argument of type %qT not permitted with -mgeneral-regs-only\"" ]

[]

[ "<s>", "static", "void", "nds32_asm_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"\\t! END PROLOGUE\\n\"", ")", ";", "}", "</s>" ]

[ "After", "rtl", "prologue", "has", "been", "expanded", ",", "this", "function", "is", "used", "." ]

[ "nds32", "\"\\t! END PROLOGUE\\n\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SIRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "CSR_AMDGPU_HighRegs_SaveList", ";", "default", ":", "{", "static", "const", "MCPhysReg", "NoCalleeSavedReg", "=", "AMDGPU", "::", "NoRegister", ";", "return", "&", "NoCalleeSavedReg", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU::NoRegister" ]

[]

[ "<s>", "machreg_t", "inet_netof", "(", "machreg_t", "in", ")", "{", "return", "_inet_netof", "(", "in", "<<", "SHIFT_BITS", ")", ";", "}", "</s>" ]

[ "<", "arpa/inet.h", ">", "has", "unsigned", "long", "inet_netof", "(", "struct", "in_addr", ")", ";", "(", "IRIX", "6.2", ")", "in_addr_t", "inet_netof", "(", "struct", "in_addr", ")", ";", "(", "IRIX", "6.5", ")" ]

[ "mips" ]

[]

[ "<s>", "uint16_t", "getAttrs", "(", ")", "const", "{", "return", "Attrs", ";", "}", "</s>" ]

[ "Return", "the", "attributes", "of", "any", "kind", "in", "AKs", "existing", "in", "the", "IR", "at", "a", "position", "that", "will", "affect", "this", "one", "." ]

[ "Hexagon" ]

[]

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

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

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

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "EXTSW", ":", "case", "PPC", "::", "EXTSW_32", ":", "case", "PPC", "::", "EXTSW_32_64", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SubIdx", "=", "PPC", "::", "sub_32", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "PowerPC", "PPC", "PPC::EXTSW", "PPC::EXTSW_32", "PPC::EXTSW_32_64", "1", "0", "PPC::sub_32" ]

[]

[ "<s>", "void", "ia64_split_tmode_move", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "in", "[", "2", "]", ",", "out", "[", "2", "]", ",", "insn", ";", "rtx", "fixup", "[", "2", "]", ";", "bool", "dead", "=", "false", ";", "bool", "reversed", "=", "false", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "MEM", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "rtx", "base", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "while", "(", "GET_CODE", "(", "base", ")", "!=", "REG", ")", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "if", "(", "REGNO", "(", "base", ")", "==", "REGNO", "(", "operands", "[", "0", "]", ")", ")", "reversed", "=", "true", ";", "if", "(", "refers_to_regno_p", "(", "REGNO", "(", "operands", "[", "0", "]", ")", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "2", ",", "base", ",", "0", ")", ")", "dead", "=", "true", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "REG", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", "reversed", "=", "true", ";", "fixup", "[", "0", "]", "=", "ia64_split_tmode", "(", "in", ",", "operands", "[", "1", "]", ",", "reversed", ",", "dead", ")", ";", "fixup", "[", "1", "]", "=", "ia64_split_tmode", "(", "out", ",", "operands", "[", "0", "]", ",", "reversed", ",", "dead", ")", ";", "if", "(", "GET_CODE", "(", "EXP", ")", "==", "MEM", "\\", "&&", "(", "GET_CODE", "(", "XEXP", "(", "EXP", ",", "0", ")", ")", "==", "POST_MODIFY", "\\", "||", "GET_CODE", "(", "XEXP", "(", "EXP", ",", "0", ")", ")", "==", "POST_INC", "\\", "||", "GET_CODE", "(", "XEXP", "(", "EXP", ",", "0", ")", ")", "==", "POST_DEC", ")", ")", "\\", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "XEXP", "(", "XEXP", "(", "EXP", ",", "0", ")", ",", "0", ")", ")", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "out", "[", "0", "]", ",", "in", "[", "0", "]", ")", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "in", "[", "0", "]", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "out", "[", "0", "]", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "out", "[", "1", "]", ",", "in", "[", "1", "]", ")", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "in", "[", "1", "]", ")", ";", "MAYBE_ADD_REG_INC_NOTE", "(", "insn", ",", "out", "[", "1", "]", ")", ";", "if", "(", "fixup", "[", "0", "]", ")", "emit_insn", "(", "fixup", "[", "0", "]", ")", ";", "if", "(", "fixup", "[", "1", "]", ")", "emit_insn", "(", "fixup", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Split", "a", "TImode", "or", "TFmode", "move", "instruction", "after", "reload", ".", "This", "is", "used", "by", "*", "movtf_internal", "and", "*", "movti_internal", "." ]

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

[]

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

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

[ "TOY" ]

[]

[ "<s>", "static", "bool", "frv_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "TARGET_FDPIC", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "force", "certain", "constants", "to", "memory", ".", "If", "we", "decide", "we", "ca", "n't", ",", "the", "caller", "should", "be", "able", "to", "cope", "with", "it", "in", "another", "way", ".", "We", "never", "allow", "constants", "to", "be", "forced", "into", "memory", "for", "TARGET_FDPIC", ".", "This", "is", "necessary", "for", "several", "reasons", ":", "1", ".", "Since", "LEGITIMATE_CONSTANT_P", "rejects", "constant", "pool", "addresses", ",", "the", "target-independent", "code", "will", "try", "to", "force", "them", "into", "the", "constant", "pool", ",", "thus", "leading", "to", "infinite", "recursion", ".", "2", ".", "We", "can", "never", "introduce", "new", "constant", "pool", "references", "during", "reload", ".", "Any", "such", "reference", "would", "require", "use", "of", "the", "pseudo", "FDPIC", "register", ".", "3", ".", "We", "ca", "n't", "represent", "a", "constant", "added", "to", "a", "function", "pointer", "(", "which", "is", "not", "the", "same", "as", "a", "pointer", "to", "a", "function+constant", ")", ".", "4", ".", "In", "many", "cases", ",", "it", "'s", "more", "efficient", "to", "calculate", "the", "constant", "in-line", "." ]

[ "frv" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tBX_RET", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "VARegSaveSize", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "const", "unsigned", "*", "CSRegs", "=", "getCalleeSavedRegs", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasStackFrame", "(", ")", ")", "{", "if", "(", "NumBytes", "!=", "0", ")", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "NumBytes", ")", ";", "}", "else", "{", "if", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "do", "--", "MBBI", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "isCSRestore", "(", "MBBI", ",", "CSRegs", ")", ")", ";", "if", "(", "!", "isCSRestore", "(", "MBBI", ",", "CSRegs", ")", ")", "++", "MBBI", ";", "}", "NumBytes", "-=", "(", "AFI", "->", "getGPRCalleeSavedArea1Size", "(", ")", "+", "AFI", "->", "getGPRCalleeSavedArea2Size", "(", ")", "+", "AFI", "->", "getDPRCalleeSavedAreaSize", "(", ")", ")", ";", "if", "(", "AFI", "->", "shouldRestoreSPFromFP", "(", ")", ")", "{", "NumBytes", "=", "AFI", "->", "getFramePtrSpillOffset", "(", ")", "-", "NumBytes", ";", "if", "(", "NumBytes", ")", "emitThumbRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "ARM", "::", "SP", ",", "FramePtr", ",", "-", "NumBytes", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "else", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tBX_RET", "&&", "&", "MBB", ".", "front", "(", ")", "!=", "MBBI", "&&", "prior", "(", "MBBI", ")", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP", ")", "{", "MachineBasicBlock", "::", "iterator", "PMBBI", "=", "prior", "(", "MBBI", ")", ";", "emitSPUpdate", "(", "MBB", ",", "PMBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "NumBytes", ")", ";", "}", "else", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "NumBytes", ")", ";", "}", "}", "if", "(", "VARegSaveSize", ")", "{", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "isCSRestore", "(", "MBBI", ",", "CSRegs", ")", ")", "++", "MBBI", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ")", ".", "addReg", "(", "ARM", "::", "R3", ",", "RegState", "::", "Define", ")", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "VARegSaveSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tBX_RET_vararg", ")", ")", ".", "addReg", "(", "ARM", "::", "R3", ",", "RegState", "::", "Kill", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM::tBX_RET", "ARM::tPOP_RET", "\"Can only insert epilog into returning blocks\"", "ARM", "ARM", "0", "ARM::SP", "ARM::tMOVtgpr2gpr", "ARM::SP", "ARM::tBX_RET", "ARM::tPOP", "ARM::tPOP", "ARM::R3", "ARM::tBX_RET_vararg", "ARM::R3" ]

[]

[ "<s>", "static", "void", "cris_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "putc", "(", "'['", ",", "file", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "cris_output_addr_const", "(", "file", ",", "x", ")", ";", "else", "if", "(", "cris_base_or_autoincr_p", "(", "x", ",", "true", ")", ")", "cris_print_base", "(", "x", ",", "file", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "x1", ",", "x2", ";", "x1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "x2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "cris_base_p", "(", "x1", ",", "true", ")", ")", "{", "cris_print_base", "(", "x1", ",", "file", ")", ";", "cris_print_index", "(", "x2", ",", "file", ")", ";", "}", "else", "if", "(", "cris_base_p", "(", "x2", ",", "true", ")", ")", "{", "cris_print_base", "(", "x2", ",", "file", ")", ";", "cris_print_index", "(", "x1", ",", "file", ")", ";", "}", "else", "LOSE_AND_RETURN", "(", "\"unrecognized address\"", ",", "x", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "putc", "(", "'['", ",", "file", ")", ";", "cris_print_base", "(", "XEXP", "(", "x", ",", "0", ")", ",", "file", ")", ";", "putc", "(", "']'", ",", "file", ")", ";", "}", "else", "LOSE_AND_RETURN", "(", "\"unrecognized address\"", ",", "x", ")", ";", "putc", "(", "']'", ",", "file", ")", ";", "}", "</s>" ]

[ "The", "PRINT_OPERAND_ADDRESS", "worker", "." ]

[ "cris", "0", "1", "\"unrecognized address\"", "0", "\"unrecognized address\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isImmMskBitp", "(", "Value", ")", ")", "{", "int", "N", "=", "Log2_32", "(", "Value", ")", "+", "1", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "MKMSK_rus", ")", ",", "Reg", ")", ".", "addImm", "(", "N", ")", ".", "getInstr", "(", ")", ";", "}", "if", "(", "isImmU16", "(", "Value", ")", ")", "{", "int", "Opcode", "=", "isImmU6", "(", "Value", ")", "?", "XCore", "::", "LDC_ru6", ":", "XCore", "::", "LDC_lru6", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ".", "getInstr", "(", ")", ";", "}", "MachineConstantPool", "*", "ConstantPool", "=", "MBB", ".", "getParent", "(", ")", "->", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ")", ",", "Value", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "Align", "(", "4", ")", ")", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "LDWCP_lru6", ")", ",", "Reg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "getInstr", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "1", "XCore::MKMSK_rus", "XCore::LDC_ru6", "XCore::LDC_lru6", "4", "XCore::LDWCP_lru6" ]

[]

[ "<s>", "void", "emitAssignment", "(", "MCSymbol", "*", "Symbol", ",", "const", "MCExpr", "*", "Value", ")", "override", "{", "if", "(", "Value", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "SymbolRef", ")", "return", ";", "const", "MCSymbol", "&", "RhsSym", "=", "static_cast", "<", "const", "MCSymbolRefExpr", "*", ">", "(", "Value", ")", "->", "getSymbol", "(", ")", ";", "MCSymbolData", "&", "Data", "=", "getStreamer", "(", ")", ".", "getOrCreateSymbolData", "(", "&", "RhsSym", ")", ";", "MCSymbolData", "&", "SymbolData", "=", "getStreamer", "(", ")", ".", "getOrCreateSymbolData", "(", "Symbol", ")", ";", "unsigned", "Other", "=", "MCELF", "::", "getOther", "(", "SymbolData", ")", "<<", "2", ";", "Other", "&=", "~", "ELF", "::", "STO_PPC64_LOCAL_MASK", ";", "Other", "|=", "(", "MCELF", "::", "getOther", "(", "Data", ")", "<<", "2", ")", "&", "ELF", "::", "STO_PPC64_LOCAL_MASK", ";", "MCELF", "::", "setOther", "(", "SymbolData", ",", "Other", ">>", "2", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assignment", "of", "Value", "to", "Symbol", "." ]

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

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "prefers32BitThumb", "(", ")", ")", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "&", "UnpackMachineBundlesID", ")", ";", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "useConstIslands", "(", ")", ")", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "if", "(", "getARMSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "addPass", "(", "createARMNaClRewritePass", "(", ")", ")", ";", "}", "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", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "void", "m68k_output_pic_call", "(", "rtx", "dest", ")", "{", "const", "char", "*", "out", ";", "if", "(", "!", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ")", "out", "=", "\"jsr %0\"", ";", "else", "if", "(", "TARGET_PCREL", ")", "out", "=", "\"bsr.l %o0\"", ";", "else", "if", "(", "TARGET_68020", ")", "out", "=", "\"bsr.l %0@PLTPC\"", ";", "out", "=", "\"bsr %0@PLTPC\"", ";", "else", "if", "(", "optimize_size", "||", "TARGET_ID_SHARED_LIBRARY", ")", "out", "=", "\"move.l %0@GOT(%%a5), %%a1\\n\\tjsr (%%a1)\"", ";", "else", "out", "=", "\"lea %0-.-8,%%a1\\n\\tjsr 0(%%pc,%%a1)\"", ";", "output_asm_insn", "(", "out", ",", "&", "dest", ")", ";", "}", "</s>" ]

[ "Output", "a", "BSR", "instruction", "suitable", "for", "PIC", "code", "." ]

[ "m68k", "0", "\"jsr %0\"", "\"bsr.l %o0\"", "\"bsr.l %0@PLTPC\"", "\"bsr %0@PLTPC\"", "\"move.l %0@GOT(%%a5), %%a1\\n\\tjsr (%%a1)\"", "\"lea %0-.-8,%%a1\\n\\tjsr 0(%%pc,%%a1)\"" ]

[]

[ "<s>", "static", "int", "distance_agu_use_in_bb", "(", "unsigned", "int", "regno", ",", "rtx_insn", "*", "insn", ",", "int", "distance", ",", "rtx_insn", "*", "start", ",", "bool", "*", "found", ",", "bool", "*", "redefined", ")", "{", "basic_block", "bb", "=", "NULL", ";", "rtx_insn", "*", "next", "=", "start", ";", "rtx_insn", "*", "prev", "=", "NULL", ";", "*", "found", "=", "false", ";", "*", "redefined", "=", "false", ";", "if", "(", "start", "!=", "NULL_RTX", ")", "{", "bb", "=", "BLOCK_FOR_INSN", "(", "start", ")", ";", "if", "(", "start", "!=", "BB_HEAD", "(", "bb", ")", ")", "prev", "=", "insn", ";", "}", "while", "(", "next", "&&", "next", "!=", "insn", "&&", "distance", "<", "LEA_SEARCH_THRESHOLD", ")", "{", "if", "(", "NONDEBUG_INSN_P", "(", "next", ")", "&&", "NONJUMP_INSN_P", "(", "next", ")", ")", "{", "distance", "=", "increase_distance", "(", "prev", ",", "next", ",", "distance", ")", ";", "if", "(", "insn_uses_reg_mem", "(", "regno", ",", "next", ")", ")", "{", "*", "found", "=", "true", ";", "return", "distance", ";", "}", "if", "(", "insn_defines_reg", "(", "regno", ",", "INVALID_REGNUM", ",", "next", ")", ")", "{", "*", "redefined", "=", "true", ";", "return", "-", "1", ";", "}", "prev", "=", "next", ";", "}", "if", "(", "next", "==", "BB_END", "(", "bb", ")", ")", "break", ";", "next", "=", "NEXT_INSN", "(", "next", ")", ";", "}", "return", "distance", ";", "}", "</s>" ]

[ "Return", "the", "distance", "in", "half-cycles", "between", "INSN", "and", "the", "next", "insn", "that", "uses", "register", "number", "REGNO", "in", "memory", "address", "added", "to", "DISTANCE", ".", "Return", "-1", "if", "REGNO0", "is", "set", ".", "Put", "true", "value", "into", "*", "FOUND", "if", "register", "usage", "was", "found", "and", "false", "otherwise", ".", "Put", "true", "value", "into", "*", "REDEFINED", "if", "register", "redefinition", "was", "found", "and", "false", "otherwise", "." ]

[ "i386", "1" ]

[]

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ",", "Last", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Last", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "emitIf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "emitElse", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "emitBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "emitIfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "emitElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "emitLoop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "emitEndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_AND_B64", ":", "case", "AMDGPU", "::", "S_OR_B64", ":", "combineMasks", "(", "MI", ")", ";", "Last", "=", "I", ";", "continue", ";", "default", ":", "Last", "=", "I", ";", "continue", ";", "}", "Next", "=", "(", "Last", "==", "MBB", ".", "end", "(", ")", ")", "?", "MBB", ".", "begin", "(", ")", ":", "Last", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_BREAK", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_ELSE_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64" ]

[]

[ "<s>", "bool", "VLIWResourceModel", "::", "isResourceAvailable", "(", "SUnit", "*", "SU", ",", "bool", "IsTop", ")", "{", "if", "(", "!", "SU", "||", "!", "SU", "->", "getInstr", "(", ")", ")", "return", "false", ";", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "!", "ResourcesModel", "->", "canReserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ")", "return", "false", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "MachineBasicBlock", "*", "MBB", "=", "SU", "->", "getInstr", "(", ")", "->", "getParent", "(", ")", ";", "auto", "&", "QST", "=", "MBB", "->", "getParent", "(", ")", "->", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "const", "auto", "&", "QII", "=", "*", "QST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "IsTop", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "hasDependence", "(", "Packet", "[", "i", "]", ",", "SU", ",", "QII", ")", ")", "return", "false", ";", "}", "else", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "hasDependence", "(", "SU", ",", "Packet", "[", "i", "]", ",", "QII", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "scheduling", "of", "this", "SU", "is", "possible", "in", "the", "current", "packet", "." ]

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

[]

[ "<s>", "bool", "SparcInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "LOAD_STACK_GUARD", ":", "{", "assert", "(", "Subtarget", ".", "isTargetLinux", "(", ")", "&&", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", ")", ";", "const", "int64_t", "Offset", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "0x28", ":", "0x14", ";", "MI", "->", "setDesc", "(", "get", "(", "Subtarget", ".", "is64Bit", "(", ")", "?", "SP", "::", "LDXri", ":", "SP", "::", "LDri", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addReg", "(", "SP", "::", "G7", ")", ".", "addImm", "(", "Offset", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Sparc", "Sparc", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", "0x28", "0x14", "SP::LDXri", "SP::LDri", "SP::G7" ]

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "const", "uint16_t", "Thumb1_16bitNopEncoding", "=", "0x46c0", ";", "const", "uint16_t", "Thumb2_16bitNopEncoding", "=", "0xbf00", ";", "const", "uint32_t", "ARMv4_NopEncoding", "=", "0xe1a00000", ";", "const", "uint32_t", "ARMv6T2_NopEncoding", "=", "0xe320f000", ";", "if", "(", "isThumb", "(", ")", ")", "{", "const", "uint16_t", "nopEncoding", "=", "hasNOP", "(", "STI", ")", "?", "Thumb2_16bitNopEncoding", ":", "Thumb1_16bitNopEncoding", ";", "uint64_t", "NumNops", "=", "Count", "/", "2", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "(", "OS", ",", "nopEncoding", ",", "Endian", ")", ";", "if", "(", "Count", "&", "1", ")", "OS", "<<", "'\\0'", ";", "return", "true", ";", "}", "const", "uint32_t", "nopEncoding", "=", "hasNOP", "(", "STI", ")", "?", "ARMv6T2_NopEncoding", ":", "ARMv4_NopEncoding", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "(", "OS", ",", "nopEncoding", ",", "Endian", ")", ";", "switch", "(", "Count", "%", "4", ")", "{", "default", ":", "break", ";", "case", "1", ":", "OS", "<<", "'\\0'", ";", "break", ";", "case", "2", ":", "OS", ".", "write", "(", "\"\\0\\0\"", ",", "2", ")", ";", "break", ";", "case", "3", ":", "OS", ".", "write", "(", "\"\\0\\0\\xa0\"", ",", "3", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0x46c0", "0xbf00", "ARM", "0xe1a00000", "ARM", "0xe320f000", "2", "0", "support::endian", "1", "ARM", "ARM", "4", "0", "support::endian", "4", "1", "2", "\"\\0\\0\"", "2", "3", "\"\\0\\0\\xa0\"", "3" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "Subtarget", ".", "hasStdExtF", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "Subtarget", ".", "hasStdExtD", "(", ")", ")", "return", "false", ";", "if", "(", "Imm", ".", "isNegZero", "(", ")", ")", "return", "false", ";", "return", "Imm", ".", "isZero", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "RISCV", "RISCV", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "const", "char", "*", "MSP430TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "MSP430ISD", "::", "RET_FLAG", ":", "return", "\"MSP430ISD::RET_FLAG\"", ";", "case", "MSP430ISD", "::", "RETI_FLAG", ":", "return", "\"MSP430ISD::RETI_FLAG\"", ";", "case", "MSP430ISD", "::", "RRA", ":", "return", "\"MSP430ISD::RRA\"", ";", "case", "MSP430ISD", "::", "RLA", ":", "return", "\"MSP430ISD::RLA\"", ";", "case", "MSP430ISD", "::", "RRC", ":", "return", "\"MSP430ISD::RRC\"", ";", "case", "MSP430ISD", "::", "CALL", ":", "return", "\"MSP430ISD::CALL\"", ";", "case", "MSP430ISD", "::", "Wrapper", ":", "return", "\"MSP430ISD::Wrapper\"", ";", "case", "MSP430ISD", "::", "BR_CC", ":", "return", "\"MSP430ISD::BR_CC\"", ";", "case", "MSP430ISD", "::", "CMP", ":", "return", "\"MSP430ISD::CMP\"", ";", "case", "MSP430ISD", "::", "SELECT_CC", ":", "return", "\"MSP430ISD::SELECT_CC\"", ";", "case", "MSP430ISD", "::", "SHL", ":", "return", "\"MSP430ISD::SHL\"", ";", "case", "MSP430ISD", "::", "SRA", ":", "return", "\"MSP430ISD::SRA\"", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430ISD::RET_FLAG", "\"MSP430ISD::RET_FLAG\"", "MSP430ISD::RETI_FLAG", "\"MSP430ISD::RETI_FLAG\"", "MSP430ISD::RRA", "\"MSP430ISD::RRA\"", "MSP430ISD::RLA", "\"MSP430ISD::RLA\"", "MSP430ISD::RRC", "\"MSP430ISD::RRC\"", "MSP430ISD::CALL", "\"MSP430ISD::CALL\"", "MSP430ISD::Wrapper", "\"MSP430ISD::Wrapper\"", "MSP430ISD::BR_CC", "\"MSP430ISD::BR_CC\"", "MSP430ISD::CMP", "\"MSP430ISD::CMP\"", "MSP430ISD::SELECT_CC", "\"MSP430ISD::SELECT_CC\"", "MSP430ISD::SHL", "\"MSP430ISD::SHL\"", "MSP430ISD::SRA", "\"MSP430ISD::SRA\"" ]

[]

[ "<s>", "int", "h8300_shift_needs_scratch_p", "(", "int", "count", ",", "machine_mode", "mode", ")", "{", "enum", "h8_cpu", "cpu", ";", "int", "a", ",", "lr", ",", "ar", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "count", ")", "return", "1", ";", "if", "(", "TARGET_H8300", ")", "cpu", "=", "H8_300", ";", "else", "if", "(", "TARGET_H8300S", ")", "cpu", "=", "H8_S", ";", "else", "cpu", "=", "H8_300H", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "a", "=", "shift_alg_qi", "[", "cpu", "]", "[", "SHIFT_ASHIFT", "]", "[", "count", "]", ";", "lr", "=", "shift_alg_qi", "[", "cpu", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "count", "]", ";", "ar", "=", "shift_alg_qi", "[", "cpu", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "count", "]", ";", "break", ";", "case", "HImode", ":", "a", "=", "shift_alg_hi", "[", "cpu", "]", "[", "SHIFT_ASHIFT", "]", "[", "count", "]", ";", "lr", "=", "shift_alg_hi", "[", "cpu", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "count", "]", ";", "ar", "=", "shift_alg_hi", "[", "cpu", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "count", "]", ";", "break", ";", "case", "SImode", ":", "a", "=", "shift_alg_si", "[", "cpu", "]", "[", "SHIFT_ASHIFT", "]", "[", "count", "]", ";", "lr", "=", "shift_alg_si", "[", "cpu", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "count", "]", ";", "ar", "=", "shift_alg_si", "[", "cpu", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "count", "]", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "a", "==", "SHIFT_LOOP", "||", "lr", "==", "SHIFT_LOOP", "||", "ar", "==", "SHIFT_LOOP", "||", "(", "TARGET_H8300H", "&&", "mode", "==", "SImode", "&&", "count", "==", "8", ")", ")", ";", "}", "</s>" ]

[ "Given", "COUNT", "and", "MODE", "of", "a", "shift", ",", "return", "1", "if", "a", "scratch", "reg", "may", "be", "needed", "for", "some", "shift", "with", "COUNT", "and", "MODE", ".", "Return", "0", "otherwise", "." ]

[ "h8300", "1", "8" ]

[]

[ "<s>", "const", "char", "*", "nvptx_output_set_softstack", "(", "unsigned", "src_regno", ")", "{", "if", "(", "cfun", "->", "machine", "->", "has_softstack", "&&", "!", "crtl", "->", "is_leaf", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tst.shared.u%d\\t[%s], \"", ",", "POINTER_SIZE", ",", "reg_names", "[", "SOFTSTACK_SLOT_REGNUM", "]", ")", ";", "output_reg", "(", "asm_out_file", ",", "src_regno", ",", "VOIDmode", ")", ";", "fprintf", "(", "asm_out_file", ",", "\";\\n\"", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "instruction", "that", "sets", "soft", "stack", "pointer", "in", "shared", "memory", "to", "the", "value", "in", "register", "given", "by", "SRC_REGNO", "." ]

[ "nvptx", "\"\\tst.shared.u%d\\t[%s], \"", "\";\\n\"", "\"\"" ]

[]