Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "BoolRC", "=", "TRI", "->", "getBoolRC", "(", ")", ";", "if", "(", "ST", ".", "isWave32", "(", ")", ")", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B32", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B32", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B32", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B32_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B32_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B32_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ";", "Exec", "=", "AMDGPU", "::", "EXEC_LO", ";", "}", "else", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B64", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B64", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B64", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B64_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B64_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B64_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "Exec", "=", "AMDGPU", "::", "EXEC", ";", "}", "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_IF_BREAK", ":", "emitIfBreak", "(", "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", ":", "case", "AMDGPU", "::", "S_AND_B32", ":", "case", "AMDGPU", "::", "S_OR_B32", ":", "combineMasks", "(", "MI", ")", ";", "Last", "=", "I", ";", "continue", ";", "default", ":", "Last", "=", "I", ";", "continue", ";", "}", "Next", "=", "(", "Last", "==", "MBB", ".", "end", "(", ")", ")", "?", "MBB", ".", "begin", "(", ")", ":", "Last", ";", "}", "}", "LoweredEndCf", ".", "clear", "(", ")", ";", "LoweredIf", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32", "AMDGPU::S_XOR_B32", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_ANDN2_B32_term", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_SAVEEXEC_B32", "AMDGPU::EXEC_LO", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_XOR_B64", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_OR_SAVEEXEC_B64", "AMDGPU::EXEC", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32" ]

[]

[ "<s>", "rtx", "extract_branch_condition_rtx", "(", "rtx_insn", "*", "insn", ")", "{", "gcc_assert", "(", "CALL_P", "(", "insn", ")", "||", "JUMP_P", "(", "insn", ")", ")", ";", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "rtx", "if_then_else_rtx", "=", "SET_SRC", "(", "body", ")", ";", "if", "(", "GET_CODE", "(", "if_then_else_rtx", ")", "==", "IF_THEN_ELSE", ")", "return", "XEXP", "(", "if_then_else_rtx", ",", "0", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "==", "COND_EXEC", ")", "return", "XEXP", "(", "body", ",", "0", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Extract", "the", "rtx", "representing", "the", "branch", "condition", "to", "help", "recognize", "data", "hazards", "." ]

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

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "assert", "(", "CCMask", ">", "0", "&&", "CCMask", "<", "15", "&&", "\"Invalid predicate\"", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "STI", ".", "hasLoadStoreOnCond", "(", ")", ")", "{", "if", "(", "unsigned", "CondOpcode", "=", "getConditionalMove", "(", "Opcode", ")", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "CondOpcode", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "Trap", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CondTrap", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "Return", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CondReturn", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallJG", ")", "{", "const", "GlobalValue", "*", "Global", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getGlobal", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "RemoveOperand", "(", "1", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBRCL", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addGlobalAddress", "(", "Global", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallBR", ")", "{", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBCR", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "0", "15", "\"Invalid predicate\"", "SystemZ::CC", "SystemZ::Trap", "SystemZ::CondTrap", "SystemZ::CC", "SystemZ::Return", "SystemZ::CondReturn", "SystemZ::CC", "SystemZ::CallJG", "0", "1", "1", "0", "SystemZ::CallBRCL", "SystemZ::CC", "SystemZ::CallBR", "0", "0", "SystemZ::CallBCR", "SystemZ::CC" ]

[]

[ "<s>", "static", "NodeRef", "getEntryNode", "(", "const", "MCallSubGraph", "&", "G", ")", "{", "return", "G", ".", "getEntryNode", "(", ")", "?", "G", ".", "getEntryNode", "(", ")", ":", "G", ".", "Nodes", ".", "front", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "token", "chain", "corresponding", "to", "the", "entry", "of", "the", "function", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "IsTailCallReturn", "=", "false", ";", "if", "(", "MBB", ".", "end", "(", ")", "!=", "MBBI", ")", "{", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "IsTailCallReturn", "=", "RetOpcode", "==", "AArch64", "::", "TCRETURNdi", "||", "RetOpcode", "==", "AArch64", "::", "TCRETURNri", ";", "}", "int", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "uint64_t", "ArgumentPopSize", "=", "0", ";", "if", "(", "IsTailCallReturn", ")", "{", "MachineOperand", "&", "StackAdjust", "=", "MBBI", "->", "getOperand", "(", "1", ")", ";", "ArgumentPopSize", "=", "StackAdjust", ".", "getImm", "(", ")", ";", "}", "else", "{", "ArgumentPopSize", "=", "AFI", "->", "getArgumentStackToRestore", "(", ")", ";", "}", "NumBytes", "+=", "ArgumentPopSize", ";", "unsigned", "NumRestores", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "LastPopI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "MachineBasicBlock", "::", "iterator", "Begin", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "LastPopI", "!=", "Begin", ")", "{", "--", "LastPopI", ";", "unsigned", "Restores", "=", "getNumCSRestores", "(", "*", "LastPopI", ",", "CSRegs", ")", ";", "NumRestores", "+=", "Restores", ";", "if", "(", "Restores", "==", "0", ")", "{", "++", "LastPopI", ";", "break", ";", "}", "}", "NumBytes", "-=", "NumRestores", "*", "8", ";", "assert", "(", "NumBytes", ">=", "0", "&&", "\"Negative stack allocation size!?\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "!", "canUseRedZone", "(", "MF", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "NumBytes", ",", "TII", ")", ";", "return", ";", "}", "if", "(", "NumBytes", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "FP", ",", "-", "(", "NumRestores", "-", "2", ")", "*", "8", ",", "TII", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::TCRETURNdi", "AArch64::TCRETURNri", "AArch64", "AArch64", "0", "1", "0", "0", "8", "0", "\"Negative stack allocation size!?\"", "AArch64::SP", "AArch64::SP", "AArch64::SP", "AArch64::FP", "2", "8" ]

[]

[ "<s>", "static", "bool", "mem_ok_for_ldrd_strd", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ",", "HOST_WIDE_INT", "*", "align", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "base", "!=", "NULL", "&&", "offset", "!=", "NULL", ")", ";", "if", "(", "side_effects_p", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "SUBREG_P", "(", "mem", ")", ")", "return", "false", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "*", "offset", "=", "const0_rtx", ";", "*", "align", "=", "MEM_ALIGN", "(", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "arm_legitimate_address_p", "(", "DImode", ",", "addr", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "(", "REG_P", "(", "*", "base", ")", "&&", "CONST_INT_P", "(", "*", "offset", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "for", "gen_operands_ldrd_strd", ".", "Returns", "true", "iff", "the", "memory", "operand", "MEM", "'s", "address", "contains", "an", "immediate", "offset", "from", "the", "base", "register", "and", "has", "no", "side", "effects", ",", "in", "which", "case", "it", "sets", "BASE", "and", "OFFSET", "accordingly", "." ]

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

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "MipsTargetMachine", "&", "TM", "=", "getMipsTargetMachine", "(", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", "TM", ")", ")", ";", "addPass", "(", "createMipsLongBranchPass", "(", "TM", ")", ")", ";", "addPass", "(", "createMipsExpandPseudoPass", "(", "TM", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI insert s_cbranch_execz instructions\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI insert s_cbranch_execz instructions\"" ]

[]

[ "<s>", "static", "bool", "spu_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_SFmode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "case", "E_DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "True", "if", "MODE", "is", "valid", "for", "the", "target", ".", "By", "``", "valid", "''", ",", "we", "mean", "able", "to", "be", "manipulated", "in", "non-trivial", "ways", ".", "In", "particular", ",", "this", "means", "all", "the", "arithmetic", "is", "supported", "." ]

[ "spu" ]

[]

[ "<s>", "bool", "swiftAsyncContextIsDynamicallySet", "(", ")", "const", "{", "const", "Triple", "&", "TT", "=", "getTargetTriple", "(", ")", ";", "unsigned", "Major", "=", "TT", ".", "getOSVersion", "(", ")", ".", "getMajor", "(", ")", ";", "switch", "(", "TT", ".", "getOS", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Triple", "::", "IOS", ":", "case", "Triple", "::", "TvOS", ":", "return", "Major", "<", "15", ";", "case", "Triple", "::", "WatchOS", ":", "return", "Major", "<", "8", ";", "case", "Triple", "::", "MacOSX", ":", "case", "Triple", "::", "Darwin", ":", "return", "Major", "<", "12", ";", "}", "}", "</s>" ]

[ "Return", "whether", "FrameLowering", "should", "always", "set", "the", "``", "extended", "frame", "present", "''", "bit", "in", "FP", ",", "or", "set", "it", "based", "on", "a", "symbol", "in", "the", "runtime", "." ]

[ "X86", "15", "8", "12" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "split", "(", "MachineInstr", "&", "MI", ",", "std", "::", "set", "<", "unsigned", ">", "&", "UpdRegs", ")", "{", "if", "(", "TfrLimitActive", ")", "{", "if", "(", "TfrCounter", ">=", "TfrLimit", ")", "return", "false", ";", "TfrCounter", "++", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nsplitting BB#\"", "<<", "MI", ".", "getParent", "(", ")", "->", "getNumber", "(", ")", "<<", "\": \"", "<<", "MI", ")", ";", "MachineOperand", "&", "MD", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MP", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "MachineOperand", "&", "MS1", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "MachineOperand", "&", "MS2", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "assert", "(", "MD", ".", "isDef", "(", ")", ")", ";", "unsigned", "DR", "=", "MD", ".", "getReg", "(", ")", ",", "DSR", "=", "MD", ".", "getSubReg", "(", ")", ";", "bool", "ReadUndef", "=", "MD", ".", "isUndef", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "At", "=", "MI", ";", "if", "(", "ReadUndef", "&&", "DSR", "!=", "0", "&&", "MRI", "->", "shouldTrackSubRegLiveness", "(", "DR", ")", ")", "{", "unsigned", "NewSR", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "DefAt", "=", "At", ";", "bool", "SameReg", "=", "(", "MS1", ".", "isReg", "(", ")", "&&", "DR", "==", "MS1", ".", "getReg", "(", ")", ")", "||", "(", "MS2", ".", "isReg", "(", ")", "&&", "DR", "==", "MS2", ".", "getReg", "(", ")", ")", ";", "if", "(", "SameReg", ")", "{", "NewSR", "=", "(", "DSR", "==", "Hexagon", "::", "subreg_loreg", ")", "?", "Hexagon", "::", "subreg_hireg", ":", "Hexagon", "::", "subreg_loreg", ";", "if", "(", "(", "MS1", ".", "isReg", "(", ")", "&&", "NewSR", "==", "MS1", ".", "getSubReg", "(", ")", ")", "||", "(", "MS2", ".", "isReg", "(", ")", "&&", "NewSR", "==", "MS2", ".", "getSubReg", "(", ")", ")", ")", "++", "DefAt", ";", "}", "MachineBasicBlock", "&", "B", "=", "*", "At", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "At", "->", "getDebugLoc", "(", ")", ";", "auto", "ImpD", "=", "BuildMI", "(", "B", ",", "DefAt", ",", "DL", ",", "HII", "->", "get", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ")", ")", ".", "addReg", "(", "DR", ",", "RegState", "::", "Define", ",", "NewSR", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "ImpD", ")", ";", "LocalImpDefs", ".", "insert", "(", "&", "*", "ImpD", ")", ";", "}", "MachineInstr", "*", "TfrT", "=", "genCondTfrFor", "(", "MI", ".", "getOperand", "(", "2", ")", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "true", ",", "ReadUndef", ",", "false", ")", ";", "MachineInstr", "*", "TfrF", "=", "genCondTfrFor", "(", "MI", ".", "getOperand", "(", "3", ")", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "false", ",", "ReadUndef", ",", "true", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrT", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrF", ")", ";", "for", "(", "auto", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "Op", ".", "isReg", "(", ")", ")", "UpdRegs", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "removeInstr", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Split", "into", "substrings", "around", "the", "occurrences", "of", "a", "separator", "character", "." ]

[ "Hexagon", "Hexagon", "\"\\nsplitting BB#\"", "\": \"", "0", "1", "2", "3", "0", "0", "Hexagon::subreg_loreg", "Hexagon::subreg_hireg", "Hexagon::subreg_loreg", "2", "3" ]

[]

[ "<s>", "unsigned", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "unsigned", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "0", ",", "DL", ".", "getPointerSizeInBits", "(", "0", ")", ")", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "AddrReg", ",", "FI", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

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

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]

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

[ "SNES" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no-realign-stack\"", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "cond_type", "is_cond_candidate", "(", "rtx", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "src", ",", "dst", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "COND_NO", ";", "dst", "=", "XEXP", "(", "pat", ",", "0", ")", ";", "if", "(", "(", "GET_CODE", "(", "dst", ")", "!=", "REG", "&&", "GET_CODE", "(", "dst", ")", "!=", "SUBREG", ")", "||", "GET_MODE", "(", "dst", ")", "!=", "SImode", ")", "return", "COND_NO", ";", "src", "=", "XEXP", "(", "pat", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "src", ")", "==", "REG", "||", "(", "GET_CODE", "(", "src", ")", "==", "SUBREG", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "src", ")", ")", "==", "REG", ")", ")", "&&", "GET_MODE", "(", "src", ")", "==", "SImode", ")", "return", "COND_MOV_INSN", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src", ")", "==", "0", ")", "return", "COND_CLR_INSN", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "REG", "||", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "SUBREG", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "==", "REG", ")", ")", "&&", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "SImode", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", "==", "1", ")", "return", "COND_INC_INSN", ";", "else", "if", "(", "(", "(", "GET_CODE", "(", "src", ")", "==", "MINUS", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", "==", "1", ")", "||", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", "==", "-", "1", ")", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "REG", "||", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "SUBREG", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "==", "REG", ")", ")", "&&", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "SImode", ")", "return", "COND_DEC_INSN", ";", "}", "else", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ")", "==", "LABEL_REF", ")", "return", "COND_BRANCH_INSN", ";", "return", "COND_NO", ";", "}", "</s>" ]

[ "Check", "whether", "insn", "is", "a", "candidate", "for", "a", "conditional", "." ]

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

[]

[ "<s>", "static", "void", "s390_register_info", "(", ")", "{", "int", "i", ";", "char", "clobbered_regs", "[", "32", "]", ";", "gcc_assert", "(", "!", "epilogue_completed", ")", ";", "if", "(", "reload_completed", ")", "s390_regs_ever_clobbered", "(", "clobbered_regs", ")", ";", "else", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "df_regs_ever_live_p", "(", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "clobbered_regs", "[", "i", "]", "&&", "!", "global_regs", "[", "i", "]", ";", "cfun_frame_layout", ".", "fpr_bitmap", "=", "0", ";", "cfun_frame_layout", ".", "high_fprs", "=", "0", ";", "for", "(", "i", "=", "FPR0_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "{", "cfun_set_fpr_save", "(", "i", ")", ";", "if", "(", "i", ">=", "FPR8_REGNUM", ")", "cfun_frame_layout", ".", "high_fprs", "++", ";", "}", "clobbered_regs", "[", "12", "]", "|=", "(", "(", "flag_pic", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "||", "(", "flag_split_stack", "&&", "cfun", "->", "stdarg", "&&", "(", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "has_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_REGNUM", ")", ")", ")", ")", ";", "clobbered_regs", "[", "BASE_REGNUM", "]", "|=", "(", "cfun", "->", "machine", "->", "base_reg", "&&", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "BASE_REGNUM", ")", ";", "clobbered_regs", "[", "HARD_FRAME_POINTER_REGNUM", "]", "|=", "!", "!", "frame_pointer_needed", ";", "clobbered_regs", "[", "RETURN_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun_frame_layout", ".", "save_return_addr_p", "||", "crtl", "->", "calls_eh_return", ")", ";", "clobbered_regs", "[", "STACK_POINTER_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun_save_high_fprs_p", "||", "get_frame_size", "(", ")", ">", "0", "||", "(", "reload_completed", "&&", "cfun_frame_layout", ".", "frame_size", ">", "0", ")", "||", "cfun", "->", "calls_alloca", ")", ";", "memset", "(", "cfun_frame_layout", ".", "gpr_save_slots", ",", "SAVE_SLOT_NONE", ",", "16", ")", ";", "for", "(", "i", "=", "6", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", ")", "cfun_gpr_save_slot", "(", "i", ")", "=", "SAVE_SLOT_STACK", ";", "s390_register_info_stdarg_fpr", "(", ")", ";", "s390_register_info_gprtofpr", "(", ")", ";", "s390_register_info_set_ranges", "(", ")", ";", "s390_register_info_stdarg_gpr", "(", ")", ";", "}", "</s>" ]

[ "Fill", "cfun-", ">", "machine", "with", "info", "about", "register", "usage", "of", "current", "function", ".", "Return", "in", "CLOBBERED_REGS", "which", "GPRs", "are", "currently", "considered", "set", "." ]

[ "s390", "32", "0", "32", "0", "32", "0", "0", "12", "0", "0", "16", "6", "16" ]

[]

[ "<s>", "static", "rtx", "mark_constant_pool_use", "(", "rtx", "x", ")", "{", "rtx_insn", "*", "insn", ",", "*", "lab", ";", "rtx", "pattern", ";", "if", "(", "x", "==", "NULL_RTX", ")", "return", "x", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "case", "CODE_LABEL", ":", "break", ";", "default", ":", "return", "x", ";", "}", "lab", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "x", ")", ";", "for", "(", "insn", "=", "PREV_INSN", "(", "lab", ")", ";", "insn", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "LABEL_P", "(", "insn", ")", "||", "LABEL_REFS", "(", "insn", ")", "!=", "NEXT_INSN", "(", "insn", ")", ")", "break", ";", "lab", "=", "insn", ";", "}", "for", "(", "rtx", "insn", "=", "LABEL_REFS", "(", "lab", ")", ";", "insn", ";", "insn", "=", "LABEL_REFS", "(", "insn", ")", ")", "as_a", "<", "rtx_insn", "*", ">", "(", "insn", ")", "->", "set_deleted", "(", ")", ";", "for", "(", "insn", "=", "NEXT_INSN", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "x", ")", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "continue", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "UNSPEC_VOLATILE", ")", "continue", ";", "switch", "(", "XINT", "(", "pattern", ",", "1", ")", ")", "{", "case", "UNSPECV_CONST2", ":", "case", "UNSPECV_CONST4", ":", "case", "UNSPECV_CONST8", ":", "XVECEXP", "(", "pattern", ",", "0", ",", "1", ")", "=", "const1_rtx", ";", "break", ";", "case", "UNSPECV_WINDOW_END", ":", "if", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", "==", "x", ")", "return", "lab", ";", "break", ";", "case", "UNSPECV_CONST_END", ":", "return", "lab", ";", "default", ":", "break", ";", "}", "}", "return", "lab", ";", "}", "</s>" ]

[ "Mark", "the", "use", "of", "a", "constant", "in", "the", "literal", "table", ".", "If", "the", "constant", "has", "multiple", "labels", ",", "make", "it", "unique", "." ]

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

[]

[ "<s>", "SNES", "::", "Fixups", "SNESMCExpr", "::", "getFixupKind", "(", ")", "const", "{", "SNES", "::", "Fixups", "Kind", "=", "SNES", "::", "Fixups", "::", "LastTargetFixupKind", ";", "switch", "(", "getKind", "(", ")", ")", "{", "case", "VK_SNES_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "SNES", "::", "fixup_lo8_ldi_neg", ":", "SNES", "::", "fixup_lo8_ldi", ";", "break", ";", "case", "VK_SNES_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "SNES", "::", "fixup_hi8_ldi_neg", ":", "SNES", "::", "fixup_hi8_ldi", ";", "break", ";", "case", "VK_SNES_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "SNES", "::", "fixup_hh8_ldi_neg", ":", "SNES", "::", "fixup_hh8_ldi", ";", "break", ";", "case", "VK_SNES_HHI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "SNES", "::", "fixup_ms8_ldi_neg", ":", "SNES", "::", "fixup_ms8_ldi", ";", "break", ";", "case", "VK_SNES_PM_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "SNES", "::", "fixup_lo8_ldi_pm_neg", ":", "SNES", "::", "fixup_lo8_ldi_pm", ";", "break", ";", "case", "VK_SNES_PM_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "SNES", "::", "fixup_hi8_ldi_pm_neg", ":", "SNES", "::", "fixup_hi8_ldi_pm", ";", "break", ";", "case", "VK_SNES_PM_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "SNES", "::", "fixup_hh8_ldi_pm_neg", ":", "SNES", "::", "fixup_hh8_ldi_pm", ";", "break", ";", "case", "VK_SNES_None", ":", "llvm_unreachable", "(", "\"Uninitialized expression\"", ")", ";", "}", "return", "Kind", ";", "}", "</s>" ]

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

[ "SNES", "SNES::Fixups", "SNES", "SNES::Fixups", "SNES::Fixups", "SNES", "SNES::fixup_lo8_ldi_neg", "SNES::fixup_lo8_ldi", "SNES", "SNES::fixup_hi8_ldi_neg", "SNES::fixup_hi8_ldi", "SNES", "SNES::fixup_hh8_ldi_neg", "SNES::fixup_hh8_ldi", "SNES", "SNES::fixup_ms8_ldi_neg", "SNES::fixup_ms8_ldi", "SNES", "SNES::fixup_lo8_ldi_pm_neg", "SNES::fixup_lo8_ldi_pm", "SNES", "SNES::fixup_hi8_ldi_pm_neg", "SNES::fixup_hi8_ldi_pm", "SNES", "SNES::fixup_hh8_ldi_pm_neg", "SNES::fixup_hh8_ldi_pm", "SNES", "\"Uninitialized expression\"" ]

[]

[ "<s>", "bool", "NPEnginePassConfig", "::", "addPreISel", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "NPEngine" ]

[]

[ "<s>", "unsigned", "int", "arm_debugger_regno", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "<", "16", ")", "return", "regno", ";", "if", "(", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ")", "return", "64", "+", "regno", "-", "FIRST_VFP_REGNUM", ";", "else", "return", "256", "+", "(", "regno", "-", "FIRST_VFP_REGNUM", ")", "/", "2", ";", "}", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "104", "+", "regno", "-", "FIRST_IWMMXT_GR_REGNUM", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "112", "+", "regno", "-", "FIRST_IWMMXT_REGNUM", ";", "if", "(", "IS_PAC_REGNUM", "(", "regno", ")", ")", "return", "DWARF_PAC_REGNUM", ";", "return", "DWARF_FRAME_REGISTERS", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "DWARF2", "register", "numbers", "." ]

[ "arm", "16", "64", "256", "2", "104", "112" ]

[]

[ "<s>", "bool", "PatmosPostRASchedStrategy", "::", "pickNode", "(", "SUnit", "*", "&", "SU", ",", "bool", "&", "IsTopNode", ",", "bool", "&", "IsBundled", ")", "{", "IsTopNode", "=", "false", ";", "if", "(", "CurrBundle", ".", "empty", "(", ")", ")", "{", "IsBundled", "=", "false", ";", "if", "(", "ReadyQ", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "CurrIsPseudo", ")", "{", "ReadyQ", ".", "recedeCycle", "(", "++", "CurrCycle", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nPicking node in cycle \"", "<<", "CurrCycle", "<<", "\"\\n\"", ";", "ReadyQ", ".", "dump", "(", ")", ")", ";", "if", "(", "!", "ReadyQ", ".", "selectBundle", "(", "CurrBundle", ")", ")", "{", "SU", "=", "NULL", ";", "CurrIsPseudo", "=", "false", ";", "return", "true", ";", "}", "else", "{", "CurrIsPseudo", "=", "true", ";", "}", "}", "else", "{", "IsBundled", "=", "true", ";", "}", "SU", "=", "CurrBundle", ".", "front", "(", ")", ";", "CurrBundle", ".", "erase", "(", "CurrBundle", ".", "begin", "(", ")", ")", ";", "CurrIsPseudo", "=", "CurrIsPseudo", "&&", "SU", "&&", "(", "SU", "->", "getInstr", "(", ")", "->", "isPseudo", "(", ")", "&&", "!", "SU", "->", "getInstr", "(", ")", "->", "isInlineAsm", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "Patmos", "Patmos", "\"\\nPicking node in cycle \"", "\"\\n\"" ]

[]

[ "<s>", "int", "arm_mac_accumulator_is_result", "(", "rtx", "producer", ",", "rtx", "consumer", ")", "{", "rtx", "result", ";", "rtx", "op0", ",", "op1", ",", "acc", ";", "producer", "=", "PATTERN", "(", "producer", ")", ";", "consumer", "=", "PATTERN", "(", "consumer", ")", ";", "if", "(", "GET_CODE", "(", "producer", ")", "==", "COND_EXEC", ")", "producer", "=", "COND_EXEC_CODE", "(", "producer", ")", ";", "if", "(", "GET_CODE", "(", "consumer", ")", "==", "COND_EXEC", ")", "consumer", "=", "COND_EXEC_CODE", "(", "consumer", ")", ";", "if", "(", "GET_CODE", "(", "producer", ")", "!=", "SET", ")", "return", "0", ";", "result", "=", "XEXP", "(", "producer", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "consumer", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "consumer", ",", "1", ")", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "0", ")", ")", "!=", "MULT", ")", "return", "0", ";", "op0", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "0", ")", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "0", ")", ",", "1", ")", ";", "acc", "=", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "consumer", ",", "1", ")", ")", "==", "MINUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "1", ")", ")", "!=", "MULT", ")", "return", "0", ";", "op0", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "1", ")", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "1", ")", ",", "1", ")", ";", "acc", "=", "XEXP", "(", "XEXP", "(", "consumer", ",", "1", ")", ",", "0", ")", ";", "}", "else", "return", "0", ";", "return", "(", "reg_overlap_mentioned_p", "(", "result", ",", "acc", ")", "&&", "!", "reg_overlap_mentioned_p", "(", "result", ",", "op0", ")", "&&", "!", "reg_overlap_mentioned_p", "(", "result", ",", "op1", ")", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "iff", "the", "consumer", "(", "a", "multiply-accumulate", "or", "a", "multiple-subtract", "instruction", ")", "has", "an", "accumulator", "dependency", "on", "the", "result", "of", "the", "producer", "and", "no", "other", "dependency", "on", "that", "result", ".", "It", "does", "not", "check", "if", "the", "producer", "is", "multiply-accumulate", "instruction", "." ]

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

[]

[ "<s>", "unsigned", "ARM64AsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "*", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARM64Operand", "*", "Op", "=", "static_cast", "<", "ARM64Operand", "*", ">", "(", "AsmOp", ")", ";", "int64_t", "ExpectedVal", ";", "switch", "(", "Kind", ")", "{", "default", ":", "return", "Match_InvalidOperand", ";", "case", "MCK__35_0", ":", "ExpectedVal", "=", "0", ";", "break", ";", "case", "MCK__35_1", ":", "ExpectedVal", "=", "1", ";", "break", ";", "case", "MCK__35_12", ":", "ExpectedVal", "=", "12", ";", "break", ";", "case", "MCK__35_16", ":", "ExpectedVal", "=", "16", ";", "break", ";", "case", "MCK__35_2", ":", "ExpectedVal", "=", "2", ";", "break", ";", "case", "MCK__35_24", ":", "ExpectedVal", "=", "24", ";", "break", ";", "case", "MCK__35_3", ":", "ExpectedVal", "=", "3", ";", "break", ";", "case", "MCK__35_32", ":", "ExpectedVal", "=", "32", ";", "break", ";", "case", "MCK__35_4", ":", "ExpectedVal", "=", "4", ";", "break", ";", "case", "MCK__35_48", ":", "ExpectedVal", "=", "48", ";", "break", ";", "case", "MCK__35_6", ":", "ExpectedVal", "=", "6", ";", "break", ";", "case", "MCK__35_64", ":", "ExpectedVal", "=", "64", ";", "break", ";", "case", "MCK__35_8", ":", "ExpectedVal", "=", "8", ";", "break", ";", "}", "if", "(", "!", "Op", "->", "isImm", "(", ")", ")", "return", "Match_InvalidOperand", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", "->", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return", "Match_InvalidOperand", ";", "if", "(", "CE", "->", "getValue", "(", ")", "==", "ExpectedVal", ")", "return", "Match_Success", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "ARM64", "0", "1", "12", "16", "2", "24", "3", "32", "4", "48", "6", "64", "8" ]

[]

[ "<s>", "static", "bool", "mips_mode_ok_for_mov_fmt_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_CCFmode", ":", "case", "E_SFmode", ":", "return", "TARGET_HARD_FLOAT", ";", "case", "E_DFmode", ":", "return", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ";", "case", "E_V2SFmode", ":", "return", "TARGET_HARD_FLOAT", "&&", "TARGET_PAIRED_SINGLE_FLOAT", ";", "default", ":", "return", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "moves", "in", "mode", "MODE", "can", "use", "the", "FPU", "'s", "mov.fmt", "instruction", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseReg", ",", "int64_t", "&", "Offset", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "LdSt", ".", "mayLoadOrStore", "(", ")", ")", "return", "false", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "!=", "3", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "||", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "Width", "=", "(", "*", "LdSt", ".", "memoperands_begin", "(", ")", ")", "->", "getSize", "(", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "BaseReg", "=", "&", "LdSt", ".", "getOperand", "(", "2", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "get", "the", "base", "operand", ",", "byte", "offset", "of", "an", "instruction", "and", "the", "memory", "width", "." ]

[ "PowerPC", "PPC", "3", "1", "2", "1", "2" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isAsmClobberable", "(", "const", "MachineFunction", "&", "MF", ",", "MCRegister", "PhysReg", ")", "const", "{", "return", "!", "isReservedReg", "(", "MF", ",", "PhysReg", ")", ";", "}", "</s>" ]

[ "Returns", "false", "if", "we", "ca", "n't", "guarantee", "that", "Physreg", ",", "specified", "as", "an", "IR", "asm", "clobber", "constraint", ",", "will", "be", "preserved", "across", "the", "statement", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "prefers32BitThumb", "(", ")", ")", "PM", ".", "add", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createUnpackMachineBundlesPass", "(", ")", ")", ";", "}", "PM", ".", "add", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "initial_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "{", "if", "(", "regs_ever_live", "[", "2", "]", "||", "regs_ever_live", "[", "3", "]", "||", "regs_ever_live", "[", "6", "]", "||", "regs_ever_live", "[", "7", "]", "||", "regs_ever_live", "[", "14", "]", "||", "regs_ever_live", "[", "15", "]", "||", "regs_ever_live", "[", "16", "]", "||", "regs_ever_live", "[", "17", "]", "||", "fp_regs_to_save", "(", ")", "||", "frame_pointer_needed", ")", "return", "REG_SAVE_BYTES", "+", "4", "*", "fp_regs_to_save", "(", ")", ";", "else", "return", "0", ";", "}", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "if", "(", "regs_ever_live", "[", "2", "]", "||", "regs_ever_live", "[", "3", "]", "||", "regs_ever_live", "[", "6", "]", "||", "regs_ever_live", "[", "7", "]", "||", "regs_ever_live", "[", "14", "]", "||", "regs_ever_live", "[", "15", "]", "||", "regs_ever_live", "[", "16", "]", "||", "regs_ever_live", "[", "17", "]", "||", "fp_regs_to_save", "(", ")", "||", "frame_pointer_needed", ")", "return", "(", "get_frame_size", "(", ")", "+", "REG_SAVE_BYTES", "+", "4", "*", "fp_regs_to_save", "(", ")", "+", "(", "current_function_outgoing_args_size", "?", "current_function_outgoing_args_size", "+", "4", ":", "0", ")", ")", ";", "else", "return", "(", "get_frame_size", "(", ")", "+", "(", "current_function_outgoing_args_size", "?", "current_function_outgoing_args_size", "+", "4", ":", "0", ")", ")", ";", "}", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "(", "get_frame_size", "(", ")", "+", "(", "current_function_outgoing_args_size", "?", "current_function_outgoing_args_size", "+", "4", ":", "0", ")", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Function", "for", "INITIAL_ELIMINATION_OFFSET", "(", "FROM", ",", "TO", ",", "OFFSET", ")", ".", "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "mn10300", "2", "3", "6", "7", "14", "15", "16", "17", "4", "0", "2", "3", "6", "7", "14", "15", "16", "17", "4", "4", "0", "4", "0", "4", "0" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "Subtarget", "->", "hasAddr64", "(", ")", "?", "&", "WebAssembly", "::", "I64RegClass", ":", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "unsigned", "Opc", "=", "Subtarget", "->", "hasAddr64", "(", ")", "?", "WebAssembly", "::", "COPY_I64", ":", "WebAssembly", "::", "COPY_I32", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass", "WebAssembly::COPY_I64", "WebAssembly::COPY_I32", "0" ]

[]

[ "<s>", "bool", "MipsSEDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Base", ",", "Offset", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "if", "(", "selectAddrRegImm16", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_R", ":", "if", "(", "selectAddrRegImm9", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_ZC", ":", "if", "(", "Subtarget", "->", "inMicroMipsMode", "(", ")", ")", "{", "if", "(", "selectAddrRegImm12", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "}", "else", "if", "(", "Subtarget", "->", "hasMips32r6", "(", ")", ")", "{", "if", "(", "selectAddrRegImm9", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "}", "else", "if", "(", "selectAddrRegImm16", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Unexpected asm memory constraint\"", "0", "MVT::i32", "0", "MVT::i32", "0", "MVT::i32", "Mips", "Mips", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "useMachineCombiner", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "when", "a", "target", "supports", "MachineCombiner", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "union_uses", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ",", "df_ref", "def", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "if", "(", "!", "link", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_out", "=", "1", ";", "while", "(", "link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_out", "=", "1", ";", "if", "(", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "{", "rtx", "use_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "NONDEBUG_INSN_P", "(", "use_insn", ")", ")", "unionfind_union", "(", "insn_entry", "+", "INSN_UID", "(", "insn", ")", ",", "insn_entry", "+", "INSN_UID", "(", "use_insn", ")", ")", ";", "}", "link", "=", "link", "->", "next", ";", "}", "}", "</s>" ]

[ "Union", "INSN", "with", "all", "insns", "containing", "uses", "reached", "from", "DEF", ".", "Detect", "whether", "DEF", "is", "live-out", "from", "the", "current", "function", "." ]

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

[]

[ "<s>", "static", "void", "vr4130_reorder", "(", "rtx", "*", "ready", ",", "int", "nready", ")", "{", "if", "(", "vr4130_swap_insns_p", "(", "ready", "[", "nready", "-", "1", "]", ",", "ready", "[", "nready", "-", "2", "]", ")", ")", "mips_promote_ready", "(", "ready", ",", "nready", "-", "2", ",", "nready", "-", "1", ")", ";", "}", "</s>" ]

[ "A", "TUNE_MIPS4130", "helper", "function", ".", "(", "READY", ",", "NREADY", ")", "describes", "a", "ready", "queue", "with", "at", "least", "two", "instructions", ".", "Swap", "the", "first", "two", "if", "vr4130_swap_insns_p", "says", "that", "it", "could", "be", "worthwhile", "." ]

[ "mips", "1", "2", "2", "1" ]

[]

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

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

[ "AVR" ]

[]

[ "<s>", "bool", "MBlazeTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "return", "VT", "!=", "MVT", "::", "f32", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MVT::f32" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyBlockAddressReference", "(", ")", "const", "{", "return", "classifyLocalReference", "(", "nullptr", ")", ";", "}", "</s>" ]

[ "Classify", "a", "blockaddress", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "SHADER_TYPE", ":", "BB", "->", "getParent", "(", ")", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "ShaderType", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INTERP", ":", "LowerSI_INTERP", "(", "MI", ",", "*", "BB", ",", "I", ",", "MRI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_WQM", ":", "LowerSI_WQM", "(", "MI", ",", "*", "BB", ",", "I", ",", "MRI", ")", ";", "break", ";", "}", "return", "BB", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "0", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectWrite", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ",", "unsigned", "AddrChan", ")", "const", "{", "unsigned", "AddrReg", ";", "switch", "(", "AddrChan", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid Channel\"", ")", ";", "case", "0", ":", "AddrReg", "=", "R600", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "1", ":", "AddrReg", "=", "R600", "::", "R600_Addr_YRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "2", ":", "AddrReg", "=", "R600", "::", "R600_Addr_ZRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "3", ":", "AddrReg", "=", "R600", "::", "R600_Addr_WRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "}", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "R600", "::", "MOVA_INT_eg", ",", "R600", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "*", "MOVA", ",", "R600", "::", "OpName", "::", "write", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "R600", "::", "MOV", ",", "AddrReg", ",", "ValueReg", ")", ".", "addReg", "(", "R600", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "*", "Mov", ",", "R600", "::", "OpName", "::", "dst_rel", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "write", "." ]

[ "AMDGPU", "R600", "\"Invalid Channel\"", "0", "R600::R600_AddrRegClass", "1", "R600::R600_Addr_YRegClass", "2", "R600::R600_Addr_ZRegClass", "3", "R600::R600_Addr_WRegClass", "R600::MOVA_INT_eg", "R600::AR_X", "R600::OpName", "0", "R600::MOV", "R600::AR_X", "R600::OpName", "1" ]

[]

[ "<s>", "static", "rtx_insn", "*", "add_parameter_dependencies", "(", "rtx_insn", "*", "call", ",", "rtx_insn", "*", "head", ")", "{", "rtx_insn", "*", "insn", ";", "rtx_insn", "*", "last", "=", "call", ";", "rtx_insn", "*", "first_arg", "=", "NULL", ";", "bool", "is_spilled", "=", "false", ";", "head", "=", "PREV_INSN", "(", "head", ")", ";", "while", "(", "true", ")", "{", "last", "=", "PREV_INSN", "(", "last", ")", ";", "if", "(", "last", "==", "head", ")", "return", "NULL", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "last", ")", ")", "continue", ";", "if", "(", "insn_is_function_arg", "(", "last", ",", "&", "is_spilled", ")", ")", "break", ";", "return", "NULL", ";", "}", "first_arg", "=", "last", ";", "while", "(", "true", ")", "{", "insn", "=", "PREV_INSN", "(", "last", ")", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "break", ";", "if", "(", "insn", "==", "head", ")", "break", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "{", "last", "=", "insn", ";", "continue", ";", "}", "if", "(", "insn_is_function_arg", "(", "insn", ",", "&", "is_spilled", ")", ")", "{", "if", "(", "is_spilled", ")", "add_dependence", "(", "first_arg", ",", "insn", ",", "REG_DEP_OUTPUT", ")", ";", "first_arg", "=", "last", "=", "insn", ";", "}", "else", "break", ";", "}", "if", "(", "!", "is_spilled", ")", "return", "NULL", ";", "return", "first_arg", ";", "}", "</s>" ]

[ "Add", "output", "dependencies", "for", "chain", "of", "function", "adjacent", "arguments", "if", "only", "there", "is", "a", "move", "to", "likely", "spilled", "HW", "register", ".", "Return", "first", "argument", "if", "at", "least", "one", "dependence", "was", "added", "or", "NULL", "otherwise", "." ]

[ "i386" ]

[]

[ "<s>", "int", "iq2000_adjust_insn_length", "(", "rtx", "insn", ",", "int", "length", ")", "{", "if", "(", "simplejump_p", "(", "insn", ")", "||", "(", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "||", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", ")", ")", "length", "+=", "4", ";", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "INSN", ".", "LENGTH", "is", "the", "initial", "length", "computed", "by", "attributes", "in", "the", "machine-description", "file", "." ]

[ "iq2000", "4" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "RISCVFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "size_t", "Reg", "=", "0", ";", "Reg", "<", "getNumRegs", "(", ")", ";", "Reg", "++", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCVABI", "::", "getBPReg", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VL", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VTYPE", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VXSAT", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VXRM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VLENB", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FRM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "FFLAGS", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "0", "RISCV", "RISCV::X0", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8", "RISCVABI::getBPReg", "RISCV::VL", "RISCV::VTYPE", "RISCV::VXSAT", "RISCV::VXRM", "RISCV::VLENB", "RISCV::FRM", "RISCV::FFLAGS" ]

[]

[ "<s>", "void", "TGSIFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "mf", ",", "MachineBasicBlock", "&", "mbb", ")", "const", "{", "MachineFrameInfo", "&", "mfi", "=", "mf", ".", "getFrameInfo", "(", ")", ";", "const", "TGSIInstrInfo", "&", "tii", "=", "*", "static_cast", "<", "const", "TGSIInstrInfo", "*", ">", "(", "mf", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "mbbi", "=", "mbb", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "int", "frame_sz", "=", "mfi", ".", "getStackSize", "(", ")", ";", "if", "(", "frame_sz", "==", "0", ")", "return", ";", "BuildMI", "(", "mbb", ",", "mbbi", ",", "dl", ",", "tii", ".", "get", "(", "TGSI", "::", "UADDs", ")", ",", "TGSI", "::", "TEMP0x", ")", ".", "addReg", "(", "TGSI", "::", "TEMP0x", ")", ".", "addImm", "(", "frame_sz", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI", "TGSI", "0", "TGSI::UADDs", "TGSI::TEMP0x", "TGSI::TEMP0x" ]

[]

[ "<s>", "void", "GBZ80InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "GB", "::", "ST8_FI", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "assert", "(", "false", "&&", "\"not implemented\"", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB", "0", "MVT::i8", "GB::ST8_FI", "MVT::i16", "\"not implemented\"", "\"Cannot store this register into a stack slot!\"" ]

[]

[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "PredicateFtor", "&&", "!", "PredicateFtor", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "STI", "->", "isThumb1Only", "(", ")", "||", "STI", "->", "prefers32BitThumb", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "OptimizeSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "MinimizeSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "::", "rpo_iterator", "I", "=", "RPOT", ".", "begin", "(", ")", ",", "E", "=", "RPOT", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "bpf_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "BPF_R0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "is", "the", "number", "of", "a", "hard", "register", "in", "which", "the", "values", "of", "called", "function", "may", "come", "back", "." ]

[ "bpf" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_JT", ":", "return", "lowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "lowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "lowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "lowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "lowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "lowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "lowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "lowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "lowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "lowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "lowerADD", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BR_JT", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::ADD" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Mips", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "Mips", "::", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "Mips", "::", "RA", ",", "MVT", "::", "i32", ")", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "Mips", "::", "RA", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "0", "0", "\"Can only return in registers!\"", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0", "1", "MipsISD::Ret", "MVT::Other", "Mips::RA", "MVT::i32", "MipsISD::Ret", "MVT::Other", "Mips::RA", "MVT::i32" ]

[]

[ "<s>", "void", "bpf_expand_prologue", "(", "void", ")", "{", "rtx", "insn", ";", "HOST_WIDE_INT", "size", ";", "size", "=", "(", "cfun", "->", "machine", "->", "local_vars_size", "+", "cfun", "->", "machine", "->", "callee_saved_reg_size", ")", ";", "if", "(", "TARGET_XBPF", ")", "{", "int", "regno", ";", "int", "fp_offset", "=", "-", "cfun", "->", "machine", "->", "local_vars_size", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "{", "if", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "(", "cfun", "->", "calls_alloca", "&&", "regno", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "rtx", "mem", ";", "if", "(", "!", "IN_RANGE", "(", "fp_offset", ",", "-", "1", "-", "0x7fff", ",", "0x7fff", ")", ")", "break", ";", "else", "{", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "hard_frame_pointer_rtx", ",", "fp_offset", "-", "8", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ")", ";", "fp_offset", "-=", "8", ";", "}", "}", "}", "}", "if", "(", "cfun", "->", "calls_alloca", ")", "{", "insn", "=", "emit_move_insn", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "if", "(", "size", ">", "0", ")", "{", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "to", "the", "instructions", "in", "a", "function", "prologue", ".", "This", "function", "is", "called", "when", "expanding", "the", "'prologue", "'", "pattern", "in", "bpf.md", "." ]

[ "bpf", "0", "1", "0x7fff", "0x7fff", "8", "8", "0" ]

[]

[ "<s>", "static", "void", "s390_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "s390_function_arg_vector", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "{", "if", "(", "!", "arg", ".", "named", ")", "return", ";", "cum", "->", "vrs", "+=", "1", ";", "}", "else", "if", "(", "s390_function_arg_float", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "{", "cum", "->", "fprs", "+=", "1", ";", "}", "else", "if", "(", "s390_function_arg_integer", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "cum", "->", "gprs", "+=", "(", "(", "size", "+", "UNITS_PER_LONG", "-", "1", ")", "/", "UNITS_PER_LONG", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available.", ")", ".", "The", "boolean", "NAMED", "specifies", "whether", "the", "argument", "is", "a", "named", "argument", "(", "as", "opposed", "to", "an", "unnamed", "argument", "matching", "an", "ellipsis", ")", "." ]

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

[]

[ "<s>", "int", "ix86_return_in_memory", "(", "tree", "type", ")", "{", "int", "needed_intregs", ",", "needed_sseregs", ",", "size", ";", "enum", "machine_mode", "mode", "=", "type_natural_mode", "(", "type", ")", ";", "if", "(", "TARGET_64BIT", ")", "return", "!", "examine_argument", "(", "mode", ",", "type", ",", "1", ",", "&", "needed_intregs", ",", "&", "needed_sseregs", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "1", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "MS_AGGREGATE_RETURN", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "size", "<=", "8", ")", "return", "0", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "||", "mode", "==", "TImode", ")", "{", "if", "(", "size", "<", "8", ")", "return", "0", ";", "if", "(", "size", "==", "8", ")", "return", "(", "TARGET_MMX", "?", "0", ":", "1", ")", ";", "if", "(", "size", "==", "16", ")", "return", "(", "TARGET_SSE", "?", "0", ":", "1", ")", ";", "}", "if", "(", "mode", "==", "XFmode", ")", "return", "0", ";", "if", "(", "size", ">", "12", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "false", "iff", "type", "is", "returned", "in", "memory", "." ]

[ "i386", "1", "1", "8", "0", "8", "0", "8", "0", "1", "16", "0", "1", "0", "12", "1", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isCandidateToMergeOrPair", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "assert", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "\"Expected a reg operand.\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "unsigned", "BaseReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "BaseReg", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "isLdStPairSuppressed", "(", "MI", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "isPaired128Slow", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "STRQui", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "\"Expected a reg operand.\"", "2", "1", "AArch64::LDURQi", "AArch64::STURQi", "AArch64::LDRQui", "AArch64::STRQui" ]

[]

[ "<s>", "bool", "BitSimplification", "::", "processBlock", "(", "MachineBasicBlock", "&", "B", ",", "const", "RegisterSet", "&", "AVs", ")", "{", "if", "(", "!", "BT", ".", "reached", "(", "&", "B", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "RegisterSet", "AVB", "=", "AVs", ";", "RegisterSet", "Defs", ";", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "AVB", ".", "insert", "(", "Defs", ")", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "I", ";", "Defs", ".", "clear", "(", ")", ";", "HBS", "::", "getInstrDefs", "(", "*", "MI", ",", "Defs", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "COPY", "||", "Opc", "==", "TargetOpcode", "::", "REG_SEQUENCE", ")", "continue", ";", "if", "(", "MI", "->", "mayStore", "(", ")", ")", "{", "bool", "T", "=", "genStoreUpperHalf", "(", "MI", ")", ";", "T", "=", "T", "||", "genStoreImmediate", "(", "MI", ")", ";", "Changed", "|=", "T", ";", "continue", ";", "}", "if", "(", "Defs", ".", "count", "(", ")", "!=", "1", ")", "continue", ";", "const", "MachineOperand", "&", "Op0", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "!", "Op0", ".", "isReg", "(", ")", "||", "!", "Op0", ".", "isDef", "(", ")", ")", "continue", ";", "BitTracker", "::", "RegisterRef", "RD", "=", "Op0", ";", "if", "(", "!", "BT", ".", "has", "(", "RD", ".", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "FRC", "=", "HBS", "::", "getFinalVRegClass", "(", "RD", ",", "MRI", ")", ";", "const", "BitTracker", "::", "RegisterCell", "&", "RC", "=", "BT", ".", "lookup", "(", "RD", ".", "Reg", ")", ";", "if", "(", "FRC", "->", "getID", "(", ")", "==", "Hexagon", "::", "DoubleRegsRegClassID", ")", "{", "bool", "T", "=", "genPackhl", "(", "MI", ",", "RD", ",", "RC", ")", ";", "T", "=", "T", "||", "simplifyExtractLow", "(", "MI", ",", "RD", ",", "RC", ",", "AVB", ")", ";", "Changed", "|=", "T", ";", "continue", ";", "}", "if", "(", "FRC", "->", "getID", "(", ")", "==", "Hexagon", "::", "IntRegsRegClassID", ")", "{", "bool", "T", "=", "genBitSplit", "(", "MI", ",", "RD", ",", "RC", ",", "AVB", ")", ";", "T", "=", "T", "||", "simplifyExtractLow", "(", "MI", ",", "RD", ",", "RC", ",", "AVB", ")", ";", "T", "=", "T", "||", "genExtractHalf", "(", "MI", ",", "RD", ",", "RC", ")", ";", "T", "=", "T", "||", "genCombineHalf", "(", "MI", ",", "RD", ",", "RC", ")", ";", "T", "=", "T", "||", "genExtractLow", "(", "MI", ",", "RD", ",", "RC", ")", ";", "T", "=", "T", "||", "simplifyRCmp0", "(", "MI", ",", "RD", ")", ";", "Changed", "|=", "T", ";", "continue", ";", "}", "if", "(", "FRC", "->", "getID", "(", ")", "==", "Hexagon", "::", "PredRegsRegClassID", ")", "{", "bool", "T", "=", "simplifyTstbit", "(", "MI", ",", "RD", ",", "RC", ")", ";", "Changed", "|=", "T", ";", "continue", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "Hexagon", "1", "0", "Hexagon::DoubleRegsRegClassID", "Hexagon::IntRegsRegClassID", "Hexagon::PredRegsRegClassID" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "isAsmClobberable", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "PhysReg", ")", "const", "{", "return", "!", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "PhysReg", ")", ";", "}", "</s>" ]

[ "Returns", "false", "if", "we", "ca", "n't", "guarantee", "that", "Physreg", ",", "specified", "as", "an", "IR", "asm", "clobber", "constraint", ",", "will", "be", "preserved", "across", "the", "statement", "." ]

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

[]

[ "<s>", "static", "bool", "cr16_frame_pointer_required", "(", "void", ")", "{", "return", "(", "cfun", "->", "calls_alloca", "||", "crtl", "->", "calls_eh_return", "||", "cfun", "->", "has_nonlocal_label", "||", "crtl", "->", "calls_eh_return", ")", ";", "}", "</s>" ]

[ "Implements", "FRAME_POINTER_REQUIRED", "." ]

[ "cr16" ]

[]

[ "<s>", "void", "M68kMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "Opcode", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EncodeInstruction: \"", "<<", "MCII", ".", "getName", "(", "Opcode", ")", "<<", "\"(\"", "<<", "Opcode", "<<", "\")\\n\"", ")", ";", "const", "uint8_t", "*", "Beads", "=", "getGenInstrBeads", "(", "MI", ")", ";", "if", "(", "!", "Beads", "||", "!", "*", "Beads", ")", "{", "llvm_unreachable", "(", "\"*** Instruction does not have Beads defined\"", ")", ";", "}", "uint64_t", "Buffer", "=", "0", ";", "unsigned", "Offset", "=", "0", ";", "unsigned", "ThisByte", "=", "0", ";", "for", "(", "uint8_t", "Bead", "=", "*", "Beads", ";", "Bead", ";", "Bead", "=", "*", "++", "Beads", ")", "{", "if", "(", "!", "(", "Bead", "&", "0xF", ")", ")", "{", "switch", "(", "Bead", ">>", "4", ")", "{", "case", "M68kBeads", "::", "Ignore", ":", "continue", ";", "}", "}", "switch", "(", "Bead", "&", "0xF", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown Bead code\"", ")", ";", "break", ";", "case", "M68kBeads", "::", "Bits1", ":", "case", "M68kBeads", "::", "Bits2", ":", "case", "M68kBeads", "::", "Bits3", ":", "case", "M68kBeads", "::", "Bits4", ":", "Offset", "+=", "encodeBits", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "case", "M68kBeads", "::", "DAReg", ":", "case", "M68kBeads", "::", "DA", ":", "case", "M68kBeads", "::", "DReg", ":", "case", "M68kBeads", "::", "Reg", ":", "Offset", "+=", "encodeReg", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "case", "M68kBeads", "::", "Disp8", ":", "case", "M68kBeads", "::", "Imm8", ":", "case", "M68kBeads", "::", "Imm16", ":", "case", "M68kBeads", "::", "Imm32", ":", "case", "M68kBeads", "::", "Imm3", ":", "Offset", "+=", "encodeImm", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "}", "while", "(", "Offset", "/", "16", ")", "{", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "Buffer", ",", "support", "::", "big", ")", ";", "Buffer", ">>=", "16", ";", "Offset", "-=", "16", ";", "ThisByte", "+=", "2", ";", "}", "}", "assert", "(", "Offset", "==", "0", "&&", "\"M68k Instructions are % 2 bytes\"", ")", ";", "assert", "(", "(", "ThisByte", "&&", "!", "(", "ThisByte", "%", "2", ")", ")", "&&", "\"M68k Instructions are % 2 bytes\"", ")", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "\"EncodeInstruction: \"", "\"(\"", "\")\\n\"", "\"*** Instruction does not have Beads defined\"", "0", "0", "0", "0xF", "4", "M68kBeads::Ignore", "0xF", "\"Unknown Bead code\"", "M68kBeads::Bits1", "M68kBeads::Bits2", "M68kBeads::Bits3", "M68kBeads::Bits4", "M68kBeads::DAReg", "M68kBeads::DA", "M68kBeads::DReg", "M68kBeads::Reg", "M68kBeads::Disp8", "M68kBeads::Imm8", "M68kBeads::Imm16", "M68kBeads::Imm32", "M68kBeads::Imm3", "16", "support::endian", "support::big", "16", "16", "2", "0", "\"M68k Instructions are % 2 bytes\"", "2", "\"M68k Instructions are % 2 bytes\"" ]

[]

[ "<s>", "void", "rx_emit_stack_pushm", "(", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "last_reg", ";", "rtx", "first_push", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "0", "]", ")", ")", ";", "last_reg", "=", "(", "INTVAL", "(", "operands", "[", "0", "]", ")", "/", "UNITS_PER_WORD", ")", "-", "1", ";", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "PARALLEL", ")", ";", "first_push", "=", "XVECEXP", "(", "operands", "[", "1", "]", ",", "0", ",", "1", ")", ";", "gcc_assert", "(", "SET_P", "(", "first_push", ")", ")", ";", "first_push", "=", "SET_SRC", "(", "first_push", ")", ";", "gcc_assert", "(", "REG_P", "(", "first_push", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tpushm\\t%s-%s\\n\"", ",", "reg_names", "[", "REGNO", "(", "first_push", ")", "-", "last_reg", "]", ",", "reg_names", "[", "REGNO", "(", "first_push", ")", "]", ")", ";", "}", "</s>" ]

[ "Generate", "a", "PUSHM", "instruction", "that", "matches", "the", "given", "operands", "." ]

[ "rx", "0", "0", "1", "1", "1", "0", "1", "\"\\tpushm\\t%s-%s\\n\"" ]

[]

[ "<s>", "bool", "SILowerI1Copies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "TheMF", ")", "{", "MF", "=", "&", "TheMF", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "ST", "=", "&", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "lowerCopiesFromI1", "(", ")", ";", "lowerPhis", "(", ")", ";", "lowerCopiesToI1", "(", ")", ";", "for", "(", "unsigned", "Reg", ":", "ConstrainRegs", ")", "MRI", "->", "constrainRegClass", "(", "Reg", ",", "&", "AMDGPU", "::", "SReg_64_XEXECRegClass", ")", ";", "ConstrainRegs", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SReg_64_XEXECRegClass" ]

[]

[ "<s>", "void", "TL45FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "bool", "hasFramePointer", "=", "hasFP", "(", "MF", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "TL45RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "TL45InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "Register", "FPReg", "=", "TL45", "::", "bp", ";", "Register", "SPReg", "=", "TL45", "::", "sp", ";", "auto", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFramePointer", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "BuildMI", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "TII", "->", "get", "(", "TL45", "::", "ADDI", ")", ")", ".", "addReg", "(", "SPReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addImm", "(", "-", "(", "StackSize", "-", "4", ")", ")", ";", "}", "if", "(", "hasFramePointer", ")", "{", "BuildMI", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "TII", "->", "get", "(", "TL45", "::", "LW", ")", ")", ".", "addReg", "(", "FPReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "Register", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRestore", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "0", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45", "TL45", "TL45::bp", "TL45::sp", "\"frame pointer should not have been eliminated\"", "TL45::ADDI", "4", "TL45::LW", "0", "0" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Register", "&&", "Reg", ".", "Kind", "==", "RegKind", "::", "Scalar", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "SDValue", "LanaiTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "combineSelectAndUseCommutative", "(", "N", ",", "DCI", ",", "false", ")", ";", "case", "ISD", "::", "AND", ":", "return", "combineSelectAndUseCommutative", "(", "N", ",", "DCI", ",", "true", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "ISD::ADD", "ISD::OR", "ISD::XOR", "ISD::AND", "ISD::SUB" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownOne", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "APInt", "KnownZero2", ";", "APInt", "KnownOne2", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "{", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "32", ",", "31", ")", ";", "break", ";", "}", "case", "AMDGPUISD", "::", "BFE_I32", ":", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "CWidth", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "CWidth", ")", "return", ";", "unsigned", "BitWidth", "=", "32", ";", "uint32_t", "Width", "=", "CWidth", "->", "getZExtValue", "(", ")", "&", "0x1f", ";", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BFE_U32", ")", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "Width", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "AMDGPU", "AMDGPU", "0", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "32", "31", "AMDGPUISD::BFE_I32", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "AMDGPUISD::BFE_U32" ]

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "I", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "LDWFI", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::LDWFI", "0" ]

[]

[ "<s>", "static", "unsigned", "getFramePointerSaveOffset", "(", "bool", "LP64", ",", "bool", "isMacho", ")", "{", "if", "(", "isMacho", ")", "return", "LP64", "?", "40", ":", "20", ";", "return", "-", "4U", ";", "}", "</s>" ]

[ "getFramePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "frame", "pointer", "." ]

[ "PowerPC", "40", "20", "4U" ]

[]

[ "<s>", "static", "void", "mips16_emit_constants", "(", "struct", "mips16_constant", "*", "constants", ",", "rtx_insn", "*", "insn", ")", "{", "struct", "mips16_constant", "*", "c", ",", "*", "next", ";", "int", "align", ";", "align", "=", "0", ";", "for", "(", "c", "=", "constants", ";", "c", "!=", "NULL", ";", "c", "=", "next", ")", "{", "if", "(", "align", "<", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ")", "{", "int", "align_log", "=", "floor_log2", "(", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ")", ";", "insn", "=", "emit_insn_after", "(", "gen_align", "(", "GEN_INT", "(", "align_log", ")", ")", ",", "insn", ")", ";", "}", "align", "=", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ";", "insn", "=", "emit_label_after", "(", "c", "->", "label", ",", "insn", ")", ";", "insn", "=", "mips16_emit_constants_1", "(", "c", "->", "mode", ",", "c", "->", "value", ",", "insn", ")", ";", "next", "=", "c", "->", "next", ";", "free", "(", "c", ")", ";", "}", "emit_barrier_after", "(", "insn", ")", ";", "}", "</s>" ]

[ "Dump", "out", "the", "constants", "in", "CONSTANTS", "after", "INSN", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "bool", "msp430_is_mem_indirect", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", ";", "rtx", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "||", "GET_CODE", "(", "op0", ")", "==", "POST_INC", ")", ";", "}", "</s>" ]

[ "For", "X", ",", "which", "must", "be", "a", "MEM", "RTX", ",", "return", "TRUE", "if", "it", "is", "an", "indirect", "memory", "reference", ",", "@", "Rn", "or", "@", "Rn+", "." ]

[ "msp430", "0" ]

[]

[ "<s>", "static", "void", "thumb_pop", "(", "FILE", "*", "f", ",", "unsigned", "long", "mask", ")", "{", "int", "regno", ";", "int", "lo_mask", "=", "mask", "&", "0xFF", ";", "int", "pushed_words", "=", "0", ";", "gcc_assert", "(", "mask", ")", ";", "if", "(", "lo_mask", "==", "0", "&&", "(", "mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ")", ")", "{", "thumb_exit", "(", "f", ",", "-", "1", ")", ";", "return", ";", "}", "fprintf", "(", "f", ",", "\"\\tpop\\t{\"", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_LO_REGNUM", ";", "regno", "++", ",", "lo_mask", ">>=", "1", ")", "{", "if", "(", "lo_mask", "&", "1", ")", "{", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "regno", ")", ";", "if", "(", "(", "lo_mask", "&", "~", "1", ")", "!=", "0", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "pushed_words", "++", ";", "}", "}", "if", "(", "mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ")", "{", "if", "(", "TARGET_INTERWORK", "||", "TARGET_BACKTRACE", "||", "crtl", "->", "calls_eh_return", ")", "{", "fprintf", "(", "f", ",", "\"}\\n\"", ")", ";", "thumb_exit", "(", "f", ",", "-", "1", ")", ";", "return", ";", "}", "else", "{", "if", "(", "mask", "&", "0xFF", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "PC_REGNUM", ")", ";", "}", "}", "fprintf", "(", "f", ",", "\"}\\n\"", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "push", "or", "pop", "registers", "to", "or", "from", "the", "stack", ".", "F", "is", "the", "assembly", "file", ".", "MASK", "is", "the", "registers", "to", "pop", "." ]

[ "arm", "0xFF", "0", "0", "1", "1", "\"\\tpop\\t{\"", "0", "1", "1", "\"%r\"", "1", "0", "\", \"", "1", "\"}\\n\"", "1", "0xFF", "\", \"", "\"%r\"", "\"}\\n\"" ]

[]

[ "<s>", "static", "void", "pru_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.set no_warn_regname_label\\n\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", "." ]

[ "pru", "\"\\t.set no_warn_regname_label\\n\"" ]

[]

[ "<s>", "static", "bool", "nios2_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "0", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "0", ")", ";", "return", "true", ";", "}", "else", "if", "(", "nios2_simple_const_p", "(", "x", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "return", "true", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "return", "true", ";", "}", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "CONST_DOUBLE", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "return", "true", ";", "}", "case", "AND", ":", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "NOT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "NOT", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "case", "MULT", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "}", "case", "SIGN_EXTEND", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "false", ";", "}", "case", "ZERO_EXTEND", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

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

[]

[ "<s>", "bool", "OptimizeReturned", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "visit", "(", "F", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "AliasAnalysis", "&", "AA", "=", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "AssumptionCache", "&", "AC", "=", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "DominatorTree", "&", "DT", "=", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "TargetLibraryInfo", "&", "TLI", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "F", ")", ";", "auto", "&", "TM", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ".", "getTM", "<", "HexagonTargetMachine", ">", "(", ")", ";", "HexagonVectorCombine", "HVC", "(", "F", ",", "AA", ",", "AC", ",", "DT", ",", "TLI", ",", "TM", ")", ";", "return", "HVC", ".", "run", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "check_required_extensions", "(", "const", "function_instance", "&", "instance", ")", "{", "rvv_type_info", "type_info", "=", "instance", ".", "type", ";", "uint64_t", "required_extensions", "=", "type_info", ".", "required_extensions", ";", "const", "rvv_op_info", "*", "op_info", "=", "instance", ".", "op_info", ";", "if", "(", "required_extensions_p", "(", "op_info", "->", "ret", ".", "base_type", ")", ")", "{", "enum", "vector_type_index", "ret_type_idx", "=", "op_info", "->", "ret", ".", "get_function_type_index", "(", "type_info", ".", "index", ")", ";", "if", "(", "ret_type_idx", "==", "NUM_VECTOR_TYPES", ")", "return", "false", ";", "required_extensions", "|=", "get_required_extensions", "(", "ret_type_idx", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "op_info", "->", "args", "[", "i", "]", ".", "base_type", "!=", "NUM_BASE_TYPES", ";", "++", "i", ")", "{", "if", "(", "!", "required_extensions_p", "(", "op_info", "->", "args", "[", "i", "]", ".", "base_type", ")", ")", "continue", ";", "enum", "vector_type_index", "vector_type", "=", "op_info", "->", "args", "[", "i", "]", ".", "get_function_type_index", "(", "type_info", ".", "index", ")", ";", "if", "(", "vector_type", "==", "NUM_VECTOR_TYPES", ")", "return", "false", ";", "required_extensions", "|=", "get_required_extensions", "(", "vector_type", ")", ";", "if", "(", "op_info", "->", "args", "[", "i", "]", ".", "base_type", "==", "RVV_BASE_eew64_index", ")", "required_extensions", "|=", "RVV_REQUIRE_RV64BIT", ";", "}", "uint64_t", "riscv_isa_flags", "=", "0", ";", "if", "(", "TARGET_VECTOR_ELEN_FP_32", ")", "riscv_isa_flags", "|=", "RVV_REQUIRE_ELEN_FP_32", ";", "if", "(", "TARGET_VECTOR_ELEN_FP_64", ")", "riscv_isa_flags", "|=", "RVV_REQUIRE_ELEN_FP_64", ";", "if", "(", "TARGET_VECTOR_ELEN_64", ")", "riscv_isa_flags", "|=", "RVV_REQUIRE_ELEN_64", ";", "if", "(", "TARGET_64BIT", ")", "riscv_isa_flags", "|=", "RVV_REQUIRE_RV64BIT", ";", "if", "(", "TARGET_FULL_V", ")", "riscv_isa_flags", "|=", "RVV_REQUIRE_FULL_V", ";", "if", "(", "TARGET_MIN_VLEN", ">", "32", ")", "riscv_isa_flags", "|=", "RVV_REQUIRE_MIN_VLEN_64", ";", "uint64_t", "missing_extensions", "=", "required_extensions", "&", "~", "riscv_isa_flags", ";", "if", "(", "missing_extensions", "!=", "0", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "all", "the", "RVV_REQUIRE_", "*", "values", "in", "REQUIRED_EXTENSIONS", "are", "enabled", "." ]

[ "riscv", "0", "0", "32", "0" ]

[]

[ "<s>", "bool", "arc_branch_size_unknown_p", "(", "void", ")", "{", "return", "!", "optimize_size", "&&", "arc_reorg_in_progress", ";", "}", "</s>" ]

[ "When", "estimating", "sizes", "during", "arc_reorg", ",", "when", "optimizing", "for", "speed", ",", "there", "are", "three", "reasons", "why", "we", "need", "to", "consider", "branches", "to", "be", "length", "6", ":", "-", "annull-false", "delay", "slot", "insns", "are", "implemented", "using", "conditional", "execution", ",", "thus", "preventing", "short", "insn", "formation", "where", "used", ".", "-", "for", "ARC600", ":", "annul-true", "delay", "slot", "insns", "are", "implemented", "where", "possible", "using", "conditional", "execution", ",", "preventing", "short", "insn", "formation", "where", "used", ".", "-", "for", "ARC700", ":", "likely", "or", "somewhat", "likely", "taken", "branches", "are", "made", "long", "and", "unaligned", "if", "possible", "to", "avoid", "branch", "penalty", "." ]

[ "arc" ]

[]

[ "<s>", "MCContext", "&", "getContext", "(", ")", "{", "return", "getStreamer", "(", ")", ".", "getContext", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "LLVMContext", "used", "by", "the", "analysis", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "aarch64_init_builtins", "(", ")", "{", "aarch64_general_init_builtins", "(", ")", ";", "aarch64_sve", "::", "init_builtins", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_INIT_BUILTINS", "." ]

[ "aarch64", "aarch64_sve::init_builtins" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STRBui", ":", "case", "AArch64", "::", "STRHui", ":", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STRQui", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::STRWui", "AArch64::STRXui", "AArch64::STRBui", "AArch64::STRHui", "AArch64::STRSui", "AArch64::STRDui", "AArch64::STRQui", "0", "0", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "Threshold", "=", "300", ";", "UP", ".", "MaxCount", "=", "UINT_MAX", ";", "UP", ".", "Partial", "=", "true", ";", "const", "unsigned", "MaxAlloca", "=", "(", "256", "-", "16", ")", "*", "4", ";", "unsigned", "ThresholdPrivate", "=", "UnrollThresholdPrivate", ";", "unsigned", "ThresholdLocal", "=", "UnrollThresholdLocal", ";", "unsigned", "MaxBoost", "=", "std", "::", "max", "(", "ThresholdPrivate", ",", "ThresholdLocal", ")", ";", "AMDGPUAS", "ASST", "=", "ST", "->", "getAMDGPUAS", "(", ")", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "const", "DataLayout", "&", "DL", "=", "BB", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "LocalGEPsSeen", "=", "0", ";", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", ")", "continue", ";", "unsigned", "AS", "=", "GEP", "->", "getAddressSpace", "(", ")", ";", "unsigned", "Threshold", "=", "0", ";", "if", "(", "AS", "==", "ASST", ".", "PRIVATE_ADDRESS", ")", "Threshold", "=", "ThresholdPrivate", ";", "else", "if", "(", "AS", "==", "ASST", ".", "LOCAL_ADDRESS", ")", "Threshold", "=", "ThresholdLocal", ";", "else", "continue", ";", "if", "(", "UP", ".", "Threshold", ">=", "Threshold", ")", "continue", ";", "if", "(", "AS", "==", "ASST", ".", "PRIVATE_ADDRESS", ")", "{", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ",", "DL", ")", ")", ";", "if", "(", "!", "Alloca", "||", "!", "Alloca", "->", "isStaticAlloca", "(", ")", ")", "continue", ";", "Type", "*", "Ty", "=", "Alloca", "->", "getAllocatedType", "(", ")", ";", "unsigned", "AllocaSize", "=", "Ty", "->", "isSized", "(", ")", "?", "DL", ".", "getTypeAllocSize", "(", "Ty", ")", ":", "0", ";", "if", "(", "AllocaSize", ">", "MaxAlloca", ")", "continue", ";", "}", "else", "if", "(", "AS", "==", "ASST", ".", "LOCAL_ADDRESS", ")", "{", "LocalGEPsSeen", "++", ";", "if", "(", "LocalGEPsSeen", ">", "1", "||", "L", "->", "getLoopDepth", "(", ")", ">", "2", "||", "(", "!", "isa", "<", "GlobalVariable", ">", "(", "GEP", "->", "getPointerOperand", "(", ")", ")", "&&", "!", "isa", "<", "Argument", ">", "(", "GEP", "->", "getPointerOperand", "(", ")", ")", ")", ")", "continue", ";", "}", "bool", "HasLoopDef", "=", "false", ";", "for", "(", "const", "Value", "*", "Op", ":", "GEP", "->", "operands", "(", ")", ")", "{", "const", "Instruction", "*", "Inst", "=", "dyn_cast", "<", "Instruction", ">", "(", "Op", ")", ";", "if", "(", "!", "Inst", "||", "L", "->", "isLoopInvariant", "(", "Op", ")", ")", "continue", ";", "if", "(", "any_of", "(", "L", "->", "getSubLoops", "(", ")", ",", "[", "Inst", "]", "(", "const", "Loop", "*", "SubLoop", ")", "{", "return", "SubLoop", "->", "contains", "(", "Inst", ")", ";", "}", ")", ")", "continue", ";", "HasLoopDef", "=", "true", ";", "break", ";", "}", "if", "(", "!", "HasLoopDef", ")", "continue", ";", "UP", ".", "Threshold", "=", "Threshold", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Set unroll threshold \"", "<<", "Threshold", "<<", "\" for loop:\\n\"", "<<", "*", "L", "<<", "\" due to \"", "<<", "*", "GEP", "<<", "'\\n'", ")", ";", "if", "(", "UP", ".", "Threshold", "==", "MaxBoost", ")", "return", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "300", "256", "16", "4", "AMDGPU", "AMDGPU", "0", "0", "0", "1", "2", "\"Set unroll threshold \"", "\" for loop:\\n\"", "\" due to \"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "CSKYTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "CSKY", "::", "ISEL32", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT32", ")", ";", "case", "CSKY", "::", "ISEL16", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT16", ")", ";", "}", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"Unexpected instr type to insert\"", "CSKY::ISEL32", "CSKY::BT32", "CSKY::ISEL16", "CSKY::BT16" ]

[]

[ "<s>", "FunctionPass", "*", "createTargetRegisterAllocator", "(", "bool", "Optimized", ")", "override", "{", "return", "createGreedyRegisterAllocator", "(", ")", ";", "}", "</s>" ]

[ "createTargetRegisterAllocator", "-", "Create", "the", "register", "allocator", "pass", "for", "this", "target", "at", "the", "current", "optimization", "level", "." ]

[ "TPC" ]

[]

[ "<s>", "static", "bool", "avr_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "PSImode", "==", "mode", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

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

[ "avr" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "ReplaceTailWithBranchTo", "(", "MachineBasicBlock", "::", "iterator", "Tail", ",", "MachineBasicBlock", "*", "NewDest", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "Tail", "->", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasITBlocks", "(", ")", ")", "{", "TargetInstrInfo", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "return", ";", "}", "unsigned", "PredReg", "=", "0", ";", "ARMCC", "::", "CondCodes", "CC", "=", "getInstrPredicate", "(", "Tail", ",", "PredReg", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Tail", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "--", "MBBI", ";", "TargetInstrInfo", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "{", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", "->", "begin", "(", ")", ";", "unsigned", "Count", "=", "4", ";", "while", "(", "Count", "&&", "MBBI", "!=", "E", ")", "{", "if", "(", "MBBI", "->", "isDebugValue", "(", ")", ")", "{", "--", "MBBI", ";", "continue", ";", "}", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Count", "==", "4", ")", "MBBI", "->", "eraseFromParent", "(", ")", ";", "else", "{", "unsigned", "MaskOn", "=", "1", "<<", "Count", ";", "unsigned", "MaskOff", "=", "~", "(", "MaskOn", "-", "1", ")", ";", "MBBI", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "(", "Mask", "&", "MaskOff", ")", "|", "MaskOn", ")", ";", "}", "return", ";", "}", "--", "MBBI", ";", "--", "Count", ";", "}", "}", "}", "</s>" ]

[ "Delete", "the", "instruction", "OldInst", "and", "everything", "after", "it", ",", "replacing", "it", "with", "an", "unconditional", "branch", "to", "NewDest", "." ]

[ "ARM", "ARM", "ARM", "0", "ARMCC::CondCodes", "ARMCC::AL", "ARMCC::AL", "4", "ARM::t2IT", "1", "4", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "ix86_avx256_split_vector_move_misalign", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "m", ";", "rtx", "(", "*", "extract", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "if", "(", "(", "MEM_P", "(", "op1", ")", "&&", "!", "TARGET_AVX256_SPLIT_UNALIGNED_LOAD", ")", "||", "(", "MEM_P", "(", "op0", ")", "&&", "!", "TARGET_AVX256_SPLIT_UNALIGNED_STORE", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "rtx", "orig_op0", "=", "NULL_RTX", ";", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_VECTOR_INT", ":", "case", "MODE_INT", ":", "if", "(", "mode", "!=", "V32QImode", ")", "{", "if", "(", "!", "MEM_P", "(", "op0", ")", ")", "{", "orig_op0", "=", "op0", ";", "op0", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "}", "else", "op0", "=", "gen_lowpart", "(", "V32QImode", ",", "op0", ")", ";", "op1", "=", "gen_lowpart", "(", "V32QImode", ",", "op1", ")", ";", "mode", "=", "V32QImode", ";", "}", "break", ";", "case", "MODE_VECTOR_FLOAT", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "mode", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "E_V32QImode", ":", "extract", "=", "gen_avx_vextractf128v32qi", ";", "mode", "=", "V16QImode", ";", "break", ";", "case", "E_V16BFmode", ":", "extract", "=", "gen_avx_vextractf128v16bf", ";", "mode", "=", "V8BFmode", ";", "break", ";", "case", "E_V16HFmode", ":", "extract", "=", "gen_avx_vextractf128v16hf", ";", "mode", "=", "V8HFmode", ";", "break", ";", "case", "E_V8SFmode", ":", "extract", "=", "gen_avx_vextractf128v8sf", ";", "mode", "=", "V4SFmode", ";", "break", ";", "case", "E_V4DFmode", ":", "extract", "=", "gen_avx_vextractf128v4df", ";", "mode", "=", "V2DFmode", ";", "break", ";", "}", "if", "(", "MEM_P", "(", "op1", ")", ")", "{", "rtx", "r", "=", "gen_reg_rtx", "(", "mode", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "0", ")", ";", "emit_move_insn", "(", "r", ",", "m", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "16", ")", ";", "r", "=", "gen_rtx_VEC_CONCAT", "(", "GET_MODE", "(", "op0", ")", ",", "r", ",", "m", ")", ";", "emit_move_insn", "(", "op0", ",", "r", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "op0", ")", ")", "{", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "0", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "op1", ",", "const0_rtx", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "16", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "copy_rtx", "(", "op1", ")", ",", "const1_rtx", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "orig_op0", ")", "emit_move_insn", "(", "orig_op0", ",", "gen_lowpart", "(", "GET_MODE", "(", "orig_op0", ")", ",", "op0", ")", ")", ";", "}", "</s>" ]

[ "Split", "32-byte", "AVX", "unaligned", "load", "and", "store", "if", "needed", "." ]

[ "i386", "0", "16", "0", "16" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "cerr", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6_RRegs", ":", "XCore", "::", "LDAWSP_lru6_RRegs", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "0", "0", "1", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "0", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6_RRegs", "XCore::LDAWSP_lru6_RRegs", "XCore::SP" ]

[]

[ "<s>", "HOST_WIDE_INT", "sparc_compute_frame_size", "(", "HOST_WIDE_INT", "size", ",", "int", "leaf_function_p", ")", "{", "int", "outgoing_args_size", "=", "(", "current_function_outgoing_args_size", "+", "REG_PARM_STACK_SPACE", "(", "current_function_decl", ")", ")", ";", "int", "n_regs", "=", "0", ";", "int", "i", ";", "if", "(", "TARGET_ARCH64", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "n_regs", "+=", "2", ";", "}", "else", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "+=", "2", ")", "if", "(", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "||", "(", "regs_ever_live", "[", "i", "+", "1", "]", "&&", "!", "call_used_regs", "[", "i", "+", "1", "]", ")", ")", "n_regs", "+=", "2", ";", "}", "for", "(", "i", "=", "32", ";", "i", "<", "(", "TARGET_V9", "?", "96", ":", "64", ")", ";", "i", "+=", "2", ")", "if", "(", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "||", "(", "regs_ever_live", "[", "i", "+", "1", "]", "&&", "!", "call_used_regs", "[", "i", "+", "1", "]", ")", ")", "n_regs", "+=", "2", ";", "num_gfregs", "=", "n_regs", ";", "if", "(", "leaf_function_p", "&&", "n_regs", "==", "0", "&&", "size", "==", "0", "&&", "current_function_outgoing_args_size", "==", "0", ")", "actual_fsize", "=", "apparent_fsize", "=", "0", ";", "else", "{", "apparent_fsize", "=", "(", "size", "-", "STARTING_FRAME_OFFSET", "+", "7", ")", "&", "-", "8", ";", "apparent_fsize", "+=", "n_regs", "*", "4", ";", "actual_fsize", "=", "apparent_fsize", "+", "(", "(", "outgoing_args_size", "+", "7", ")", "&", "-", "8", ")", ";", "}", "if", "(", "!", "leaf_function_p", "||", "size", ">", "0", ")", "actual_fsize", "+=", "FIRST_PARM_OFFSET", "(", "current_function_decl", ")", ";", "return", "SPARC_STACK_ALIGN", "(", "actual_fsize", ")", ";", "}", "</s>" ]

[ "Compute", "the", "frame", "size", "required", "by", "the", "function", ".", "This", "function", "is", "called", "during", "the", "reload", "pass", "and", "also", "by", "sparc_expand_prologue", "." ]

[ "sparc", "0", "0", "8", "2", "0", "8", "2", "1", "1", "2", "32", "96", "64", "2", "1", "1", "2", "0", "0", "0", "0", "7", "8", "4", "7", "8", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "RISCVRegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "loadStackInputValue", "(", "SelectionDAG", "&", "DAG", ",", "EVT", "VT", ",", "const", "SDLoc", "&", "SL", ",", "int64_t", "Offset", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "VT", ".", "getStoreSize", "(", ")", ",", "Offset", ",", "true", ")", ";", "auto", "SrcPtrInfo", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "SDValue", "Ptr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getLoad", "(", "VT", ",", "SL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Ptr", ",", "SrcPtrInfo", ",", "4", ",", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "}", "</s>" ]

[ "Similar", "to", "CreateLiveInRegister", ",", "except", "value", "maybe", "loaded", "from", "a", "stack", "slot", "rather", "than", "passed", "in", "a", "register", "." ]

[ "AMDGPU", "AMDGPU", "MVT::i32", "4" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Chain", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDValue", "TCChain", "=", "Chain", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "VMOVRRD", ")", "{", "SDNode", "*", "VMov", "=", "Copy", ";", "SmallPtrSet", "<", "SDNode", "*", ",", "2", ">", "Copies", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "VMov", "->", "use_begin", "(", ")", ",", "UE", "=", "VMov", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", ")", "return", "false", ";", "Copies", ".", "insert", "(", "*", "UI", ")", ";", "}", "if", "(", "Copies", ".", "size", "(", ")", ">", "2", ")", "return", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "VMov", "->", "use_begin", "(", ")", ",", "UE", "=", "VMov", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "SDValue", "UseChain", "=", "UI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Copies", ".", "count", "(", "UseChain", ".", "getNode", "(", ")", ")", ")", "Copy", "=", "*", "UI", ";", "else", "TCChain", "=", "UseChain", ";", "}", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "{", "if", "(", "!", "Copy", "->", "hasOneUse", "(", ")", ")", "return", "false", ";", "Copy", "=", "*", "Copy", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", "||", "!", "Copy", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "{", "return", "false", ";", "}", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ARMISD", "::", "RET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "if", "(", "!", "HasRet", ")", "return", "false", ";", "Chain", "=", "TCChain", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "ARM", "ARM", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "0", "ARMISD::VMOVRRD", "2", "ISD::CopyToReg", "2", "0", "ISD::BITCAST", "ISD::CopyToReg", "1", "0", "0", "ARMISD::RET_FLAG" ]

[]

[ "<s>", "int", "sh_loop_align", "(", "rtx_insn", "*", "label", ")", "{", "rtx_insn", "*", "next", "=", "label", ";", "if", "(", "!", "optimize", "||", "optimize_size", ")", "return", "0", ";", "do", "next", "=", "next_nonnote_insn", "(", "next", ")", ";", "while", "(", "next", "&&", "LABEL_P", "(", "next", ")", ")", ";", "if", "(", "!", "next", "||", "!", "INSN_P", "(", "next", ")", "||", "recog_memoized", "(", "next", ")", "==", "CODE_FOR_consttable_2", ")", "return", "0", ";", "return", "align_loops", ".", "levels", "[", "0", "]", ".", "log", ";", "}", "</s>" ]

[ "If", "we", "are", "inside", "a", "phony", "loop", ",", "almost", "any", "kind", "of", "label", "can", "turn", "up", "as", "the", "first", "one", "in", "the", "loop", ".", "Aligning", "a", "braf", "label", "causes", "incorrect", "switch", "destination", "addresses", ";", "we", "can", "detect", "braf", "labels", "because", "they", "are", "followed", "by", "a", "BARRIER", ".", "Applying", "loop", "alignment", "to", "small", "constant", "or", "switch", "tables", "is", "a", "waste", "of", "space", ",", "so", "we", "suppress", "this", "too", "." ]

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

[]

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

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "unsigned", "parse_env_var", "(", "const", "char", "*", "str", ",", "char", "*", "*", "*", "pvalues", ")", "{", "const", "char", "*", "curval", ",", "*", "nextval", ";", "char", "*", "*", "values", ";", "unsigned", "num", "=", "1", ",", "i", ";", "curval", "=", "strchr", "(", "str", ",", "':'", ")", ";", "while", "(", "curval", ")", "{", "num", "++", ";", "curval", "=", "strchr", "(", "curval", "+", "1", ",", "':'", ")", ";", "}", "values", "=", "(", "char", "*", "*", ")", "xmalloc", "(", "num", "*", "sizeof", "(", "char", "*", ")", ")", ";", "curval", "=", "str", ";", "nextval", "=", "strchr", "(", "curval", ",", "':'", ")", ";", "if", "(", "nextval", "==", "NULL", ")", "nextval", "=", "strchr", "(", "curval", ",", "'\\0'", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num", ";", "i", "++", ")", "{", "int", "l", "=", "nextval", "-", "curval", ";", "values", "[", "i", "]", "=", "(", "char", "*", ")", "xmalloc", "(", "l", "+", "1", ")", ";", "memcpy", "(", "values", "[", "i", "]", ",", "curval", ",", "l", ")", ";", "values", "[", "i", "]", "[", "l", "]", "=", "0", ";", "curval", "=", "nextval", "+", "1", ";", "nextval", "=", "strchr", "(", "curval", ",", "':'", ")", ";", "if", "(", "nextval", "==", "NULL", ")", "nextval", "=", "strchr", "(", "curval", ",", "'\\0'", ")", ";", "}", "*", "pvalues", "=", "values", ";", "return", "num", ";", "}", "</s>" ]

[ "Parse", "STR", ",", "saving", "found", "tokens", "into", "PVALUES", "and", "return", "their", "number", ".", "Tokens", "are", "assumed", "to", "be", "delimited", "by", "'", ":", "'", "." ]

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

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "MCFixup", "const", "&", "Fixup", ",", "uint64_t", "Value", ",", "MCRelaxableFragment", "const", "*", "DF", ",", "MCAsmLayout", "const", "&", "Layout", ")", "const", "override", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "AAP", "::", "fixup_AAP_BR16", ":", "case", "AAP", "::", "fixup_AAP_BRCC16", ":", "case", "AAP", "::", "fixup_AAP_BAL16", ":", "llvm_unreachable", "(", "\"Cannot relax short instruction fixups!\"", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "AAP", "AAP::fixup_AAP_BR16", "AAP::fixup_AAP_BRCC16", "AAP::fixup_AAP_BAL16", "\"Cannot relax short instruction fixups!\"" ]

[]

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

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

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

[]

[ "<s>", "void", "init_builtins", "(", ")", "{", "sve_switcher", "sve", ";", "register_builtin_types", "(", ")", ";", "if", "(", "in_lto_p", ")", "handle_arm_sve_h", "(", ")", ";", "}", "</s>" ]

[ "Initialize", "all", "compiler", "built-ins", "related", "to", "RVV", "that", "should", "be", "defined", "at", "start-up", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "if", "(", "!", "CurrCycleInstr", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "return", ";", "}", "if", "(", "CurrCycleInstr", "->", "isImplicitDef", "(", ")", "||", "CurrCycleInstr", "->", "isDebugInstr", "(", ")", "||", "CurrCycleInstr", "->", "isKill", "(", ")", ")", "{", "CurrCycleInstr", "=", "nullptr", ";", "return", ";", "}", "if", "(", "CurrCycleInstr", "->", "isBundle", "(", ")", ")", "{", "processBundle", "(", ")", ";", "return", ";", "}", "unsigned", "NumWaitStates", "=", "TII", ".", "getNumWaitStates", "(", "*", "CurrCycleInstr", ")", ";", "EmittedInstrs", ".", "push_front", "(", "CurrCycleInstr", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "std", "::", "min", "(", "NumWaitStates", ",", "getMaxLookAhead", "(", ")", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "}", "EmittedInstrs", ".", "resize", "(", "getMaxLookAhead", "(", ")", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "}", "</s>" ]

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

[ "AMDGPU", "1" ]

[]

[ "<s>", "void", "ix86_print_patchable_function_entry", "(", "FILE", "*", "file", ",", "unsigned", "HOST_WIDE_INT", "patch_area_size", ",", "bool", "record_p", ")", "{", "if", "(", "cfun", "->", "machine", "->", "function_label_emitted", ")", "{", "return", ";", "}", "default_print_patchable_function_entry", "(", "file", ",", "patch_area_size", ",", "record_p", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_PRINT_PATCHABLE_FUNCTION_ENTRY", "." ]

[ "i386" ]

[]

[ "<s>", "static", "char", "*", "mips16e_add_register_range", "(", "char", "*", "s", ",", "unsigned", "int", "min_reg", ",", "unsigned", "int", "max_reg", ")", "{", "if", "(", "min_reg", "!=", "max_reg", ")", "s", "+=", "sprintf", "(", "s", ",", "\",%s-%s\"", ",", "reg_names", "[", "min_reg", "]", ",", "reg_names", "[", "max_reg", "]", ")", ";", "else", "s", "+=", "sprintf", "(", "s", ",", "\",%s\"", ",", "reg_names", "[", "min_reg", "]", ")", ";", "return", "s", ";", "}", "</s>" ]

[ "Add", "a", "MIPS16e", "SAVE", "or", "RESTORE", "register-range", "argument", "to", "string", "S", "for", "the", "register", "range", "[", "MIN_REG", ",", "MAX_REG", "]", ".", "Return", "a", "pointer", "to", "the", "null", "terminator", "." ]

[ "mips", "\",%s-%s\"", "\",%s\"" ]

[]

[ "<s>", "static", "rtx", "sched_get_reg_operand", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "rtx", "op", "=", "NULL", ";", "if", "(", "opx_p", ")", "{", "if", "(", "get_attr_opx_type", "(", "insn", ")", "==", "OPX_TYPE_RN", ")", "{", "op", "=", "sched_get_operand", "(", "insn", ",", "true", ")", ";", "gcc_assert", "(", "op", "!=", "NULL", ")", ";", "if", "(", "!", "reload_completed", "&&", "!", "REG_P", "(", "op", ")", ")", "return", "NULL", ";", "}", "}", "else", "{", "if", "(", "get_attr_opy_type", "(", "insn", ")", "==", "OPY_TYPE_RN", ")", "{", "op", "=", "sched_get_operand", "(", "insn", ",", "false", ")", ";", "gcc_assert", "(", "op", "!=", "NULL", ")", ";", "if", "(", "!", "reload_completed", "&&", "!", "REG_P", "(", "op", ")", ")", "return", "NULL", ";", "}", "}", "return", "op", ";", "}", "</s>" ]

[ "Return", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", ",", "if", "it", "is", "an", "integer", "register", ",", "or", "NULL", "overwise", "." ]

[ "m68k" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "CodeEmitter", ".", "reset", "(", "TM", ".", "getTarget", "(", ")", ".", "createMCCodeEmitter", "(", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ",", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "MF", ".", "getContext", "(", ")", ")", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Intrn", "=", "MF", ".", "getFunction", "(", ")", "->", "hasInternalLinkage", "(", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Intrn", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "EmitXRayTable", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "emit_csky_regs_push", "(", "unsigned", "long", "mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", ";", "rtx", "tmp", ";", "int", "dwarf_par_index", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CSKY_NGPR_REGS", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "}", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "12", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", "+", "1", ")", ")", ";", "dwarf_par_index", "=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CSKY_NGPR_REGS", ";", "i", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "num_regs", ")", ";", "tmp", "=", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSHPOP_MULT", ")", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "SImode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "++", ")", "=", "tmp", ";", "break", ";", "}", "for", "(", "j", "=", "1", ",", "i", "++", ";", "j", "<", "num_regs", ";", "i", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "j", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "SImode", ",", "addr", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "++", ")", "=", "tmp", ";", "j", "++", ";", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "num_regs", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "add_reg_note", "(", "par", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "par", ")", "=", "1", ";", "return", "par", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "that", "we", "will", "recognize", "as", "a", "push_multi", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", ".", "DWARF_REGS_MASK", "is", "a", "subset", "of", "MASK", "for", "registers", "that", "should", "be", "annotated", "for", "DWARF2", "frame", "unwind", "information", "." ]

[ "csky", "0", "0", "1", "12", "1", "1", "0", "1", "4", "0", "0", "1", "1", "0", "1", "1", "4", "1", "0", "0", "4", "1", "0", "0", "1" ]

[]

[ "<s>", "SDValue", "Cpu0TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Cpu0CC", "Cpu0CCInfo", "(", "CallConv", ",", "ABI", ".", "IsO32", "(", ")", ",", "CCInfo", ")", ";", "Cpu0CCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ".", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "Cpu0MachineFunctionInfo", "*", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "Cpu0FI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "unsigned", "V0", "=", "Cpu0", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Cpu0ISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "return", "DAG", ".", "getNode", "(", "Cpu0ISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "Cpu0", "::", "LR", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Cpu0", "Cpu0", "ISD::OutputArg", "16", "Cpu0", "Cpu0", "Cpu0", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "\"sret virtual register not created in the entry block\"", "Cpu0::V0", "1", "0", "Cpu0ISD::Ret", "MVT::Other", "Cpu0ISD::Ret", "MVT::Other", "Cpu0::LR", "MVT::i32" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreISel", "(", "PassManagerBase", "&", "PM", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", ")", "PM", ".", "add", "(", "createGlobalMergePass", "(", "getTargetLowering", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "ARM", "ARM" ]

[]