Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "gen_shifty_op", "(", "int", "code", ",", "rtx", "*", "operands", ")", "{", "int", "value", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "int", "max", ",", "i", ";", "value", "=", "value", "&", "31", ";", "if", "(", "value", "==", "31", ")", "{", "if", "(", "code", "==", "LSHIFTRT", ")", "{", "emit_insn", "(", "gen_rotlsi3_1", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "emit_insn", "(", "gen_movt", "(", "operands", "[", "0", "]", ",", "get_t_reg_rtx", "(", ")", ")", ")", ";", "return", ";", "}", "else", "if", "(", "code", "==", "ASHIFT", ")", "{", "if", "(", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "0", ")", "{", "emit_insn", "(", "gen_andsi3", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_rotlsi3_31", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "return", ";", "}", "}", "}", "else", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "return", ";", "}", "max", "=", "ashl_lshr_seq", "[", "value", "]", ".", "insn_count", ";", "for", "(", "i", "=", "0", ";", "i", "<", "max", ";", "i", "++", ")", "gen_ashift", "(", "code", ",", "ashl_lshr_seq", "[", "value", "]", ".", "amount", "[", "i", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "split", "a", "constant", "shift", "into", "its", "component", "SH", "constant", "shift", "instructions", "." ]

[ "sh", "2", "31", "31", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "uint64_t", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ")", "||", "!", "needsSPWriteback", "(", "MF", ")", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "InsertPt", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SPReg", "=", "0", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "{", "auto", "FI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "SPReg", "=", "FI", "->", "getBasePointerVreg", "(", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "SPReg", ")", ".", "addReg", "(", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "else", "{", "SPReg", "=", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ";", "}", "writeSPToGlobal", "(", "SPReg", ",", "MF", ",", "MBB", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "0", "WebAssembly", "WebAssembly::CONST_I32", "WebAssembly::ADD_I32", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::FP32", "WebAssembly::SP32" ]

[]

[ "<s>", "unsigned", "TVMInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "return", "8", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "TVM", "TVM", "0", "0", "8" ]

[]

[ "<s>", "bool", "Z80InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ",", "UnCondBrIter", "=", "I", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "!", "I", "->", "getOperand", "(", "0", ")", ".", "isMBB", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getNumOperands", "(", ")", "==", "1", ")", "{", "UnCondBrIter", "=", "I", ";", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "UnCondBrIter", "=", "I", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "assert", "(", "I", "->", "getNumExplicitOperands", "(", ")", "==", "2", "&&", "\"Invalid conditional branch\"", ")", ";", "Z80", "::", "CondCode", "BranchCode", "=", "Z80", "::", "CondCode", "(", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "TargetBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "if", "(", "AllowModify", "&&", "UnCondBrIter", "!=", "MBB", ".", "end", "(", ")", "&&", "MBB", ".", "isLayoutSuccessor", "(", "TargetBB", ")", ")", "{", "BranchCode", "=", "GetOppositeBranchCondition", "(", "BranchCode", ")", ";", "MachineBasicBlock", "::", "iterator", "OldInst", "=", "I", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Z80", "::", "JQCC", ")", ")", ".", "addMBB", "(", "UnCondBrIter", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ".", "addImm", "(", "BranchCode", ")", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Z80", "::", "JQ", ")", ")", ".", "addMBB", "(", "TargetBB", ")", ";", "OldInst", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "=", "MBB", ".", "end", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "continue", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "Z80", "Z80", "0", "1", "0", "0", "0", "2", "\"Invalid conditional branch\"", "Z80::CondCode", "Z80::CondCode", "1", "0", "Z80::JQCC", "0", "Z80::JQ", "0" ]

[]

[ "<s>", "bool", "AArch64A57FPLoadBalancing", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "*", "F", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "balanceFPOps", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A57FPLoadBalancing *****\\n\"", ")", ";", "MRI", "=", "&", "F", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "F", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "RCI", ".", "runOnMachineFunction", "(", "F", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SystemZShortenInst", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "F", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "Changed", "|=", "processBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "finishLayout", "(", "MCAssembler", "const", "&", "Asm", ",", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "for", "(", "auto", "I", ":", "Layout", ".", "getSectionOrder", "(", ")", ")", "{", "auto", "&", "Fragments", "=", "I", "->", "getFragmentList", "(", ")", ";", "for", "(", "auto", "&", "J", ":", "Fragments", ")", "{", "switch", "(", "J", ".", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "auto", "Size", "=", "Asm", ".", "computeFragmentSize", "(", "Layout", ",", "J", ")", ";", "for", "(", "auto", "K", "=", "J", ".", "getIterator", "(", ")", ";", "K", "!=", "Fragments", ".", "begin", "(", ")", "&&", "Size", ">=", "HEXAGON_PACKET_SIZE", ";", ")", "{", "--", "K", ";", "switch", "(", "K", "->", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "Size", "=", "0", ";", "break", ";", "}", "case", "MCFragment", "::", "FT_Relaxable", ":", "{", "auto", "&", "RF", "=", "cast", "<", "MCRelaxableFragment", ">", "(", "*", "K", ")", ";", "auto", "&", "Inst", "=", "const_cast", "<", "MCInst", "&", ">", "(", "RF", ".", "getInst", "(", ")", ")", ";", "while", "(", "Size", ">", "0", "&&", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Inst", ")", "<", "4", ")", "{", "MCInst", "*", "Nop", "=", "new", "(", "Asm", ".", "getContext", "(", ")", ")", "MCInst", ";", "Nop", "->", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Nop", ")", ")", ";", "Size", "-=", "4", ";", "if", "(", "!", "HexagonMCChecker", "(", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ",", "Inst", ",", "*", "Asm", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ".", "check", "(", ")", ")", "{", "Inst", ".", "erase", "(", "Inst", ".", "end", "(", ")", "-", "1", ")", ";", "Size", "=", "0", ";", "}", "}", "bool", "Error", "=", "HexagonMCShuffle", "(", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ")", ";", "(", "void", ")", "Error", ";", "ReplaceInstruction", "(", "Asm", ".", "getEmitter", "(", ")", ",", "RF", ",", "Inst", ")", ";", "Layout", ".", "invalidateFragmentsFrom", "(", "&", "RF", ")", ";", "Size", "=", "0", ";", "break", ";", "}", "}", "}", "}", "}", "}", "}", "}", "</s>" ]

[ "Give", "backend", "an", "opportunity", "to", "finish", "layout", "after", "relaxation", "." ]

[ "Hexagon", "0", "0", "Hexagon", "4", "Hexagon::A2_nop", "4", "Hexagon", "1", "0", "Hexagon", "0" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "hasTOCLoReloc", "(", "MI", ")", ")", "continue", ";", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "PPC", "::", "X2", ",", "false", ",", "true", ")", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC::X2" ]

[]

[ "<s>", "int", "xtensa_expand_block_move", "(", "rtx", "*", "operands", ")", "{", "static", "const", "machine_mode", "mode_from_align", "[", "]", "=", "{", "VOIDmode", ",", "QImode", ",", "HImode", ",", "VOIDmode", ",", "SImode", ",", "}", ";", "rtx", "dst_mem", "=", "operands", "[", "0", "]", ";", "rtx", "src_mem", "=", "operands", "[", "1", "]", ";", "HOST_WIDE_INT", "bytes", ",", "align", ";", "int", "num_pieces", ",", "move_ratio", ";", "rtx", "temp", "[", "2", "]", ";", "machine_mode", "mode", "[", "2", "]", ";", "int", "amount", "[", "2", "]", ";", "bool", "active", "[", "2", "]", ";", "int", "phase", "=", "0", ";", "int", "next", ";", "int", "offset_ld", "=", "0", ";", "int", "offset_st", "=", "0", ";", "rtx", "x", ";", "if", "(", "!", "optimize", "||", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", ")", "return", "0", ";", "bytes", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "if", "(", "bytes", "<=", "0", ")", "return", "0", ";", "if", "(", "align", ">", "MOVE_MAX", ")", "align", "=", "MOVE_MAX", ";", "move_ratio", "=", "4", ";", "if", "(", "optimize", ">", "2", ")", "move_ratio", "=", "LARGEST_MOVE_RATIO", ";", "num_pieces", "=", "(", "bytes", "/", "align", ")", "+", "(", "bytes", "%", "align", ")", ";", "if", "(", "num_pieces", ">", "move_ratio", ")", "return", "0", ";", "x", "=", "XEXP", "(", "dst_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "dst_mem", "=", "replace_equiv_address", "(", "dst_mem", ",", "x", ")", ";", "}", "x", "=", "XEXP", "(", "src_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "src_mem", "=", "replace_equiv_address", "(", "src_mem", ",", "x", ")", ";", "}", "active", "[", "0", "]", "=", "active", "[", "1", "]", "=", "false", ";", "do", "{", "next", "=", "phase", ";", "phase", "^=", "1", ";", "if", "(", "bytes", ">", "0", ")", "{", "int", "next_amount", ";", "next_amount", "=", "(", "bytes", ">=", "4", "?", "4", ":", "(", "bytes", ">=", "2", "?", "2", ":", "1", ")", ")", ";", "next_amount", "=", "MIN", "(", "next_amount", ",", "align", ")", ";", "amount", "[", "next", "]", "=", "next_amount", ";", "mode", "[", "next", "]", "=", "mode_from_align", "[", "next_amount", "]", ";", "temp", "[", "next", "]", "=", "gen_reg_rtx", "(", "mode", "[", "next", "]", ")", ";", "x", "=", "adjust_address", "(", "src_mem", ",", "mode", "[", "next", "]", ",", "offset_ld", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", "[", "next", "]", ",", "x", ")", ")", ";", "offset_ld", "+=", "next_amount", ";", "bytes", "-=", "next_amount", ";", "active", "[", "next", "]", "=", "true", ";", "}", "if", "(", "active", "[", "phase", "]", ")", "{", "active", "[", "phase", "]", "=", "false", ";", "x", "=", "adjust_address", "(", "dst_mem", ",", "mode", "[", "phase", "]", ",", "offset_st", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "x", ",", "temp", "[", "phase", "]", ")", ")", ";", "offset_st", "+=", "amount", "[", "phase", "]", ";", "}", "}", "while", "(", "active", "[", "next", "]", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Try", "to", "expand", "a", "block", "move", "operation", "to", "an", "RTL", "block", "move", "instruction", ".", "If", "not", "optimizing", "or", "if", "the", "block", "size", "is", "not", "a", "constant", "or", "if", "the", "block", "is", "small", ",", "the", "expansion", "fails", "and", "GCC", "falls", "back", "to", "calling", "memcpy", "(", ")", ".", "operands", "[", "0", "]", "is", "the", "destination", "operands", "[", "1", "]", "is", "the", "source", "operands", "[", "2", "]", "is", "the", "length", "operands", "[", "3", "]", "is", "the", "alignment" ]

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

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "1", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ";", "break", ";", "}", "}", "else", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_SAVE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_SAVE", ";", "break", ";", "case", "96", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_SAVE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "1", ")", "{", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", "->", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", "->", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "1", "8", "32", "AMDGPU::SI_SPILL_S32_SAVE", "64", "AMDGPU::SI_SPILL_S64_SAVE", "128", "AMDGPU::SI_SPILL_S128_SAVE", "256", "AMDGPU::SI_SPILL_S256_SAVE", "512", "AMDGPU::SI_SPILL_S512_SAVE", "8", "32", "AMDGPU::SI_SPILL_V32_SAVE", "64", "AMDGPU::SI_SPILL_V64_SAVE", "96", "AMDGPU::SI_SPILL_V96_SAVE", "128", "AMDGPU::SI_SPILL_V128_SAVE", "256", "AMDGPU::SI_SPILL_V256_SAVE", "512", "AMDGPU::SI_SPILL_V512_SAVE", "1", "4", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3", "AMDGPU::SGPR0", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", "AMDGPU::KILL" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "RISCVFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "Register", "SPReg", "=", "RISCV", "::", "X2", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "adjustReg", "(", "MBB", ",", "MI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</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", ")", "." ]

[ "RI5CY", "RISCV", "RISCV::X2", "0", "0", "RISCV::ADJCALLSTACKDOWN" ]

[]

[ "<s>", "bool", "WebAssemblyRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no-realign-stack\"", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "WebAssemblyAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0" ]

[]

[ "<s>", "static", "rtx", "alphaev5_next_group", "(", "rtx", "insn", ",", "int", "*", "pin_use", ",", "int", "*", "plen", ")", "{", "int", "len", ",", "in_use", ";", "len", "=", "in_use", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "goto", "next_and_done", ";", "while", "(", "1", ")", "{", "enum", "alphaev5_pipe", "pipe", ";", "pipe", "=", "alphaev5_insn_pipe", "(", "insn", ")", ";", "switch", "(", "pipe", ")", "{", "case", "EV5_STOP", ":", "if", "(", "in_use", ")", "goto", "done", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "len", "=", "-", "1", ";", "else", "len", "=", "get_attr_length", "(", "insn", ")", ";", "goto", "next_and_done", ";", "case", "EV5_E01", ":", "if", "(", "in_use", "&", "EV5_E0", ")", "{", "if", "(", "in_use", "&", "EV5_E1", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "}", "else", "in_use", "|=", "EV5_E0", "|", "EV5_E01", ";", "break", ";", "case", "EV5_E0", ":", "if", "(", "in_use", "&", "EV5_E0", ")", "{", "if", "(", "!", "(", "in_use", "&", "EV5_E01", ")", "||", "(", "in_use", "&", "EV5_E1", ")", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "}", "in_use", "|=", "EV5_E0", ";", "break", ";", "case", "EV5_E1", ":", "if", "(", "in_use", "&", "EV5_E1", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "break", ";", "case", "EV5_FAM", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "{", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "}", "else", "in_use", "|=", "EV5_FA", "|", "EV5_FAM", ";", "break", ";", "case", "EV5_FA", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "goto", "done", ";", "in_use", "|=", "EV5_FA", ";", "break", ";", "case", "EV5_FM", ":", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "break", ";", "case", "EV5_NONE", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "4", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "goto", "next_and_done", ";", "next", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "goto", "done", ";", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "goto", "done", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "insn", ")", "==", "USE", ")", "goto", "next", ";", "}", "next_and_done", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "done", ":", "*", "plen", "=", "len", ";", "*", "pin_use", "=", "in_use", ";", "return", "insn", ";", "}", "</s>" ]

[ "IN_USE", "is", "a", "mask", "of", "the", "slots", "currently", "filled", "within", "the", "insn", "group", ".", "The", "mask", "bits", "come", "from", "alphaev5_pipe", "above", ".", "If", "EV5_E01", "is", "set", ",", "then", "the", "insn", "in", "EV5_E0", "can", "be", "swapped", "by", "the", "hardware", "into", "EV5_E1", ".", "LEN", "is", ",", "of", "course", ",", "the", "length", "of", "the", "group", "in", "bytes", "." ]

[ "alpha", "0", "1", "0", "1", "4" ]

[]

[ "<s>", "static", "bool", "v850_handle_memory_option", "(", "enum", "small_memory_type", "type", ",", "const", "char", "*", "value", ")", "{", "int", "i", ",", "size", ";", "if", "(", "*", "value", "!=", "'-'", "&&", "*", "value", "!=", "'='", ")", "return", "false", ";", "value", "++", ";", "for", "(", "i", "=", "0", ";", "value", "[", "i", "]", ";", "i", "++", ")", "if", "(", "!", "ISDIGIT", "(", "value", "[", "i", "]", ")", ")", "return", "false", ";", "size", "=", "atoi", "(", "value", ")", ";", "if", "(", "size", ">", "small_memory", "[", "type", "]", ".", "physical_max", ")", "error", "(", "\"value passed to %<-m%s%> is too large\"", ",", "small_memory", "[", "type", "]", ".", "name", ")", ";", "else", "small_memory", "[", "type", "]", ".", "max", "=", "size", ";", "return", "true", ";", "}", "</s>" ]

[ "Set", "the", "maximum", "size", "of", "small", "memory", "area", "TYPE", "to", "the", "value", "given", "by", "VALUE", ".", "Return", "true", "if", "VALUE", "was", "syntactically", "correct", ".", "VALUE", "starts", "with", "the", "argument", "separator", ":", "either", "``", "-", "''", "or", "``", "=", "''", "." ]

[ "v850", "0", "\"value passed to %<-m%s%> is too large\"" ]

[]

[ "<s>", "BitVector", "SparcRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G1", ")", ";", "if", "(", "ReserveAppRegisters", ")", "{", "Reserved", ".", "set", "(", "SP", "::", "G2", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G3", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G4", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "Reserved", ".", "set", "(", "SP", "::", "G5", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "O6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G0", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G7", ")", ";", "if", "(", "!", "Subtarget", ".", "isV9", "(", ")", ")", "{", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "16", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "SP", "::", "D16", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "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", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "SP::G1", "SP::G2", "SP::G3", "SP::G4", "SP::G5", "SP::O6", "SP::I6", "SP::I7", "SP::G0", "SP::G6", "SP::G7", "0", "16", "SP::D16" ]

[]

[ "<s>", "void", "setMustSaveLR", "(", "bool", "U", ")", "{", "MustSaveLR", "=", "U", ";", "}", "</s>" ]

[ "MustSaveLR", "-", "This", "is", "set", "when", "the", "prolog/epilog", "inserter", "does", "its", "initial", "scan", "of", "the", "function", "." ]

[ "PowerPC" ]

[]

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

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

[ "GBZ80", "GB", "ISD::InputArg", "16", "GB", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "AMDGPUCFGStructurizer", "::", "removeSuccessor", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "while", "(", "MBB", "->", "succ_size", "(", ")", ")", "MBB", "->", "removeSuccessor", "(", "*", "MBB", "->", "succ_begin", "(", ")", ")", ";", "}", "</s>" ]

[ "Remove", "specified", "successor", "from", "the", "successors", "list", "of", "this", "MachineBasicBlock", "." ]

[ "R600" ]

[]

[ "<s>", "static", "bool", "xtensa_split_imm_two_addends", "(", "HOST_WIDE_INT", "imm", ",", "HOST_WIDE_INT", "v", "[", "2", "]", ")", "{", "HOST_WIDE_INT", "v0", ",", "v1", ";", "if", "(", "imm", "<", "-", "32768", ")", "v0", "=", "-", "32768", ",", "v1", "=", "imm", "+", "32768", ";", "else", "if", "(", "imm", ">", "32512", ")", "v0", "=", "32512", ",", "v1", "=", "imm", "-", "32512", ";", "else", "if", "(", "TARGET_DENSITY", "&&", "xtensa_simm12b", "(", "imm", ")", ")", "return", "false", ";", "else", "v0", "=", "(", "imm", "+", "128", ")", "&", "~", "255L", ",", "v1", "=", "imm", "-", "v0", ";", "if", "(", "xtensa_simm8", "(", "v1", ")", "||", "xtensa_simm8x256", "(", "v1", ")", ")", "{", "v", "[", "0", "]", "=", "v0", ",", "v", "[", "1", "]", "=", "v1", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Try", "to", "split", "an", "integer", "value", "into", "what", "are", "suitable", "for", "two", "consecutive", "immediate", "addition", "instructions", ",", "ADDI", "or", "ADDMI", "." ]

[ "xtensa", "2", "32768", "32768", "32768", "32512", "32512", "32512", "128", "255L", "0", "1" ]

[]

[ "<s>", "inline", "tree", "tuple_type_field", "(", "tree", "type", ")", "{", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "return", "field", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "single", "field", "in", "tuple", "type", "TYPE", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "emitValueImpl", "(", "const", "MCExpr", "*", "Value", ",", "unsigned", "Size", ",", "SMLoc", "Loc", ")", "override", "{", "const", "MCExpr", "*", "A", ",", "*", "B", ";", "if", "(", "!", "requiresFixups", "(", "getContext", "(", ")", ",", "Value", ",", "A", ",", "B", ")", ")", "return", "MCELFStreamer", "::", "emitValueImpl", "(", "Value", ",", "Size", ",", "Loc", ")", ";", "MCStreamer", "::", "emitValueImpl", "(", "Value", ",", "Size", ",", "Loc", ")", ";", "MCDataFragment", "*", "DF", "=", "getOrCreateDataFragment", "(", ")", ";", "flushPendingLabels", "(", "DF", ",", "DF", "->", "getContents", "(", ")", ".", "size", "(", ")", ")", ";", "MCDwarfLineEntry", "::", "make", "(", "this", ",", "getCurrentSectionOnly", "(", ")", ")", ";", "unsigned", "Add", ",", "Sub", ";", "std", "::", "tie", "(", "Add", ",", "Sub", ")", "=", "getRelocPairForSize", "(", "Size", ")", ";", "DF", "->", "getFixups", "(", ")", ".", "push_back", "(", "MCFixup", "::", "create", "(", "DF", "->", "getContents", "(", ")", ".", "size", "(", ")", ",", "A", ",", "static_cast", "<", "MCFixupKind", ">", "(", "Add", ")", ",", "Loc", ")", ")", ";", "DF", "->", "getFixups", "(", ")", ".", "push_back", "(", "MCFixup", "::", "create", "(", "DF", "->", "getContents", "(", ")", ".", "size", "(", ")", ",", "B", ",", "static_cast", "<", "MCFixupKind", ">", "(", "Sub", ")", ",", "Loc", ")", ")", ";", "DF", "->", "getContents", "(", ")", ".", "resize", "(", "DF", "->", "getContents", "(", ")", ".", "size", "(", ")", "+", "Size", ",", "0", ")", ";", "}", "</s>" ]

[ "Overriding", "these", "functions", "allows", "us", "to", "dismiss", "all", "labels", "that", "are", "candidates", "for", "marking", "as", "microMIPS", "when", ".word/.long/.4byte", "etc", "directives", "are", "emitted", "." ]

[ "RISCV", "0" ]

[]

[ "<s>", "static", "bool", "note_csky_invalid_constants", "(", "rtx_insn", "*", "insn", ",", "HOST_WIDE_INT", "address", ",", "int", "do_pushes", ")", "{", "bool", "result", "=", "false", ";", "int", "opno", ";", "extract_constrain_insn", "(", "insn", ")", ";", "if", "(", "recog_data", ".", "n_alternatives", "==", "0", ")", "return", "false", ";", "preprocess_constraints", "(", "insn", ")", ";", "const", "operand_alternative", "*", "op_alt", "=", "which_op_alt", "(", ")", ";", "for", "(", "opno", "=", "0", ";", "opno", "<", "recog_data", ".", "n_operands", ";", "opno", "++", ")", "{", "if", "(", "recog_data", ".", "operand_type", "[", "opno", "]", "!=", "OP_IN", ")", "continue", ";", "if", "(", "op_alt", "[", "opno", "]", ".", "memory_ok", ")", "{", "rtx", "op", "=", "recog_data", ".", "operand", "[", "opno", "]", ";", "if", "(", "CONSTANT_P", "(", "op", ")", ")", "{", "if", "(", "do_pushes", ")", "push_csky_minipool_fix", "(", "insn", ",", "address", ",", "recog_data", ".", "operand_loc", "[", "opno", "]", ",", "recog_data", ".", "operand_mode", "[", "opno", "]", ",", "op", ")", ";", "result", "=", "true", ";", "}", "}", "}", "return", "result", ";", "}", "</s>" ]

[ "Scan", "INSN", "and", "note", "any", "of", "its", "operands", "that", "need", "fixing", ".", "If", "DO_PUSHES", "is", "false", "we", "do", "not", "actually", "push", "any", "of", "the", "fixups", "needed", ".", "The", "function", "returns", "TRUE", "if", "any", "fixups", "were", "needed/pushed", "." ]

[ "csky", "0", "0" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "mips_split_call", "(", "rtx", "insn", ",", "rtx", "call_pattern", ")", "{", "emit_call_insn", "(", "call_pattern", ")", ";", "if", "(", "!", "find_reg_note", "(", "insn", ",", "REG_NORETURN", ",", "0", ")", ")", "mips_restore_gp_from_cprestore_slot", "(", "gen_rtx_REG", "(", "Pmode", ",", "POST_CALL_TMP_REG", ")", ")", ";", "}", "</s>" ]

[ "Split", "call", "instruction", "INSN", "into", "a", "$", "gp-clobbering", "call", "and", "(", "where", "necessary", ")", "an", "instruction", "to", "restore", "$", "gp", "from", "its", "save", "slot", ".", "CALL_PATTERN", "is", "the", "pattern", "of", "the", "new", "call", "." ]

[ "mips", "0" ]

[]

[ "<s>", "void", "add_all_one_mask_operand", "(", "machine_mode", "mode", ")", "{", "add_input_operand", "(", "CONSTM1_RTX", "(", "mode", ")", ",", "mode", ")", ";", "}", "</s>" ]

[ "Since", "we", "may", "normalize", "vop/vop_tu/vop_m/vop_tumu", "..", "into", "a", "single", "patter", ".", "We", "add", "a", "fake", "all", "true", "mask", "for", "the", "intrinsics", "that", "do", "n't", "need", "a", "real", "mask", "." ]

[ "riscv" ]

[]

[ "<s>", "const", "char", "*", "mprocTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "}", "</s>" ]

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

[ "mproc", "mproc" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Branch Expansion Pass\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Branch Expansion Pass\"" ]

[]

[ "<s>", "rtx", "avr_libcall_value", "(", "enum", "machine_mode", "mode", ")", "{", "int", "offs", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "offs", "<", "2", ")", "offs", "=", "2", ";", "return", "gen_rtx_REG", "(", "mode", ",", "RET_REGISTER", "+", "2", "-", "offs", ")", ";", "}", "</s>" ]

[ "Ceate", "an", "RTX", "representing", "the", "place", "where", "a", "library", "function", "returns", "a", "value", "of", "mode", "MODE", "." ]

[ "avr", "2", "2", "2" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "AMDGPURegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "Dst", ",", "const", "RegisterBank", "&", "Src", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VGPRRegBankID", ")", "{", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "}", "if", "(", "Size", "==", "1", "&&", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SCCRegBankID", "&&", "(", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VGPRRegBankID", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "return", "RegisterBankInfo", "::", "copyCost", "(", "Dst", ",", "Src", ",", "Size", ")", ";", "}", "</s>" ]

[ "Get", "the", "cost", "of", "a", "copy", "from", "B", "to", "A", ",", "or", "put", "differently", ",", "get", "the", "cost", "of", "A", "=", "COPY", "B", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::SGPRRegBankID", "AMDGPU::VGPRRegBankID", "1", "AMDGPU::SCCRegBankID", "AMDGPU::SGPRRegBankID", "AMDGPU::VGPRRegBankID", "AMDGPU::VCCRegBankID" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "HexagonTargetLowering", "::", "findRepresentativeClass", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "nullptr", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "TRI", ",", "VT", ")", ";", "case", "MVT", "::", "v64i8", ":", "case", "MVT", "::", "v32i16", ":", "case", "MVT", "::", "v16i32", ":", "case", "MVT", "::", "v8i64", ":", "RRC", "=", "&", "Hexagon", "::", "HvxVRRegClass", ";", "break", ";", "case", "MVT", "::", "v128i8", ":", "case", "MVT", "::", "v64i16", ":", "case", "MVT", "::", "v32i32", ":", "case", "MVT", "::", "v16i64", ":", "if", "(", "Subtarget", ".", "hasV60TOps", "(", ")", "&&", "Subtarget", ".", "useHVXOps", "(", ")", "&&", "Subtarget", ".", "useHVXDblOps", "(", ")", ")", "RRC", "=", "&", "Hexagon", "::", "HvxVRRegClass", ";", "else", "RRC", "=", "&", "Hexagon", "::", "HvxWRRegClass", ";", "break", ";", "case", "MVT", "::", "v256i8", ":", "case", "MVT", "::", "v128i16", ":", "case", "MVT", "::", "v64i32", ":", "case", "MVT", "::", "v32i64", ":", "RRC", "=", "&", "Hexagon", "::", "HvxWRRegClass", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "Hexagon", "Hexagon", "1", "MVT::v64i8", "MVT::v32i16", "MVT::v16i32", "MVT::v8i64", "Hexagon::HvxVRRegClass", "MVT::v128i8", "MVT::v64i16", "MVT::v32i32", "MVT::v16i64", "Hexagon::HvxVRRegClass", "Hexagon::HvxWRRegClass", "MVT::v256i8", "MVT::v128i16", "MVT::v64i32", "MVT::v32i64", "Hexagon::HvxWRRegClass" ]

[]

[ "<s>", "void", "scalar_chain", "::", "add_insn", "(", "bitmap", "candidates", ",", "unsigned", "int", "insn_uid", ")", "{", "if", "(", "bitmap_bit_p", "(", "insns", ",", "insn_uid", ")", ")", "return", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Adding insn %d to chain #%d\\n\"", ",", "insn_uid", ",", "chain_id", ")", ";", "bitmap_set_bit", "(", "insns", ",", "insn_uid", ")", ";", "rtx_insn", "*", "insn", "=", "DF_INSN_UID_GET", "(", "insn_uid", ")", "->", "insn", ";", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "def_set", "&&", "REG_P", "(", "SET_DEST", "(", "def_set", ")", ")", "&&", "!", "HARD_REGISTER_P", "(", "SET_DEST", "(", "def_set", ")", ")", ")", "bitmap_set_bit", "(", "defs", ",", "REGNO", "(", "SET_DEST", "(", "def_set", ")", ")", ")", ";", "df_ref", "ref", ";", "df_ref", "def", ";", "for", "(", "ref", "=", "DF_INSN_UID_DEFS", "(", "insn_uid", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "!", "HARD_REGISTER_P", "(", "DF_REF_REG", "(", "ref", ")", ")", ")", "for", "(", "def", "=", "DF_REG_DEF_CHAIN", "(", "DF_REF_REGNO", "(", "ref", ")", ")", ";", "def", ";", "def", "=", "DF_REF_NEXT_REG", "(", "def", ")", ")", "analyze_register_chain", "(", "candidates", ",", "def", ")", ";", "for", "(", "ref", "=", "DF_INSN_UID_USES", "(", "insn_uid", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "ref", ")", ")", "analyze_register_chain", "(", "candidates", ",", "ref", ")", ";", "}", "</s>" ]

[ "Add", "instruction", "into", "a", "chain", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "search", "was", "aborted", "." ]

[ "i386", "\" Adding insn %d to chain #%d\\n\"" ]

[]

[ "<s>", "ATTRIBUTE_UNUSED", "static", "section", "*", "ia64_hpux_function_section", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "enum", "node_frequency", "freq", "ATTRIBUTE_UNUSED", ",", "bool", "startup", "ATTRIBUTE_UNUSED", ",", "bool", "exit", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL", ";", "}", "</s>" ]

[ "Always", "default", "to", ".text", "section", "until", "HP-UX", "linker", "is", "fixed", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "init", "(", "VLIWMachineScheduler", "*", "dag", ",", "const", "TargetSchedModel", "*", "smodel", ")", "{", "DAG", "=", "dag", ";", "SchedModel", "=", "smodel", ";", "CurrCycle", "=", "0", ";", "IssueCount", "=", "0", ";", "CriticalPathLength", "=", "DAG", "->", "getBBSize", "(", ")", "/", "SchedModel", "->", "getIssueWidth", "(", ")", ";", "if", "(", "DAG", "->", "getBBSize", "(", ")", "<", "50", ")", "CriticalPathLength", ">>=", "1", ";", "else", "{", "unsigned", "MaxPath", "=", "0", ";", "for", "(", "auto", "&", "SU", ":", "DAG", "->", "SUnits", ")", "MaxPath", "=", "std", "::", "max", "(", "MaxPath", ",", "isTop", "(", ")", "?", "SU", ".", "getHeight", "(", ")", ":", "SU", ".", "getDepth", "(", ")", ")", ";", "CriticalPathLength", "=", "std", "::", "max", "(", "CriticalPathLength", ",", "MaxPath", ")", "+", "1", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "SPIRV" ]

[]

[ "<s>", "SparcTargetLowering", "::", "ConstraintType", "SparcTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "Sparc", "Sparc", "Sparc", "1", "0" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "8", "&&", "\"Invalid register size\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPRd", ")", ",", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "8", "\"Invalid register size\"", "AVR::POPRd" ]

[]

[ "<s>", "static", "void", "pop", "(", "int", "rn", ")", "{", "rtx", "x", ";", "if", "(", "rn", "==", "FPUL_REG", ")", "x", "=", "gen_pop_fpul", "(", ")", ";", "else", "if", "(", "rn", "==", "FPSCR_REG", ")", "x", "=", "gen_pop_fpscr", "(", ")", ";", "else", "if", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A_DOUBLE", ")", "&&", "TARGET_FMOVD", "&&", "!", "TARGET_FPU_SINGLE", "&&", "FP_OR_XD_REGISTER_P", "(", "rn", ")", ")", "{", "if", "(", "FP_REGISTER_P", "(", "rn", ")", "&&", "(", "rn", "-", "FIRST_FP_REG", ")", "&", "1", ")", "return", ";", "x", "=", "gen_pop_4", "(", "gen_rtx_REG", "(", "DFmode", ",", "rn", ")", ")", ";", "}", "else", "if", "(", "TARGET_SH2E", "&&", "FP_REGISTER_P", "(", "rn", ")", ")", "x", "=", "gen_pop_e", "(", "gen_rtx_REG", "(", "SFmode", ",", "rn", ")", ")", ";", "else", "x", "=", "gen_pop", "(", "gen_rtx_REG", "(", "SImode", ",", "rn", ")", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "REG_NOTES", "(", "x", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "pop", "register", "RN", "from", "the", "stack", "." ]

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

[]

[ "<s>", "bool", "SparcAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "SparcOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "applyMnemonicAliases", "(", "Name", ",", "getAvailableFeatures", "(", ")", ",", "0", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "if", "(", "parseBranchModifiers", "(", "Operands", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "}", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SparcOperand::CreateToken", "0", "\"unexpected token\"", "\"unexpected token\"", "\"unexpected token\"", "\"unexpected token\"" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "AMDGPU" ]

[]

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

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

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TM", "=", "static_cast", "<", "const", "PPCTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "TII", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "SparcOperand", "*", "CreateReg", "(", "unsigned", "RegNum", ",", "unsigned", "Kind", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "SparcOperand", "*", "Op", "=", "new", "SparcOperand", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "Reg", ".", "Kind", "=", "(", "SparcOperand", "::", "RegisterKind", ")", "Kind", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "SparcOperand::RegisterKind" ]

[]

[ "<s>", "void", "RISCVTargetStreamer", "::", "emitTargetAttributes", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_4", ")", ";", "else", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_16", ")", ";", "std", "::", "string", "Arch", "=", "\"rv32\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "Feature64Bit", ")", ")", "Arch", "=", "\"rv64\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "Arch", "+=", "\"e1p9\"", ";", "else", "Arch", "+=", "\"i2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtM", ")", ")", "Arch", "+=", "\"_m2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtA", ")", ")", "Arch", "+=", "\"_a2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtF", ")", ")", "Arch", "+=", "\"_f2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtD", ")", ")", "Arch", "+=", "\"_d2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtC", ")", ")", "Arch", "+=", "\"_c2p0\"", ";", "emitTextAttribute", "(", "RISCVAttrs", "::", "ARCH", ",", "Arch", ")", ";", "}", "</s>" ]

[ "Emit", "the", "build", "attributes", "that", "only", "depend", "on", "the", "hardware", "that", "we", "expect", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureRV32E", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_4", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_16", "\"rv32\"", "RISCV::Feature64Bit", "\"rv64\"", "RISCV::FeatureRV32E", "\"e1p9\"", "\"i2p0\"", "RISCV::FeatureStdExtM", "\"_m2p0\"", "RISCV::FeatureStdExtA", "\"_a2p0\"", "RISCV::FeatureStdExtF", "\"_f2p0\"", "RISCV::FeatureStdExtD", "\"_d2p0\"", "RISCV::FeatureStdExtC", "\"_c2p0\"", "RISCVAttrs::ARCH" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSoftFloat", "(", "false", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "UseTCCInDIV", "(", "false", ")", ",", "HasEVA", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "nvptx_option_override", "(", "void", ")", "{", "init_machine_status", "=", "nvptx_init_machine_status", ";", "gcc_checking_assert", "(", "OPTION_SET_P", "(", "ptx_isa_option", ")", ")", ";", "handle_ptx_version_option", "(", ")", ";", "if", "(", "!", "OPTION_SET_P", "(", "flag_toplevel_reorder", ")", ")", "flag_toplevel_reorder", "=", "1", ";", "debug_nonbind_markers_p", "=", "0", ";", "if", "(", "!", "OPTION_SET_P", "(", "flag_no_common", ")", ")", "flag_no_common", "=", "1", ";", "HOST_WIDE_INT", "patch_area_size", ",", "patch_area_entry", ";", "parse_and_check_patch_area", "(", "flag_patchable_function_entry", ",", "false", ",", "&", "patch_area_size", ",", "&", "patch_area_entry", ")", ";", "if", "(", "patch_area_size", ">", "0", ")", "sorry", "(", "\"not generating patch area, nops not supported\"", ")", ";", "flag_var_tracking", "=", "0", ";", "if", "(", "nvptx_optimize", "<", "0", ")", "nvptx_optimize", "=", "optimize", ">", "0", ";", "declared_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "needed_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "declared_libfuncs_htab", "=", "hash_table", "<", "declared_libfunc_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "oacc_bcast_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__oacc_bcast\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "oacc_bcast_sym", ",", "DATA_AREA_SHARED", ")", ";", "oacc_bcast_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "oacc_bcast_partition", "=", "0", ";", "worker_red_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__worker_red\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "worker_red_sym", ",", "DATA_AREA_SHARED", ")", ";", "worker_red_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "vector_red_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__vector_red\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "vector_red_sym", ",", "DATA_AREA_SHARED", ")", ";", "vector_red_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "vector_red_partition", "=", "0", ";", "gang_private_shared_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__gang_private_shared\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "gang_private_shared_sym", ",", "DATA_AREA_SHARED", ")", ";", "gang_private_shared_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "diagnose_openacc_conflict", "(", "TARGET_GOMP", ",", "\"-mgomp\"", ")", ";", "diagnose_openacc_conflict", "(", "TARGET_SOFT_STACK", ",", "\"-msoft-stack\"", ")", ";", "diagnose_openacc_conflict", "(", "TARGET_UNIFORM_SIMT", ",", "\"-muniform-simt\"", ")", ";", "if", "(", "TARGET_GOMP", ")", "target_flags", "|=", "MASK_SOFT_STACK", "|", "MASK_UNIFORM_SIMT", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "nvptx", "1", "0", "1", "0", "\"not generating patch area, nops not supported\"", "0", "0", "0", "17", "17", "17", "\"__oacc_bcast\"", "0", "\"__worker_red\"", "\"__vector_red\"", "0", "\"__gang_private_shared\"", "\"-mgomp\"", "\"-msoft-stack\"", "\"-muniform-simt\"" ]

[]

[ "<s>", "bool", "AArch64StackTaggingPreRA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "MF", "=", "&", "Func", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "AFI", "=", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MFI", "=", "&", "MF", "->", "getFrameInfo", "(", ")", ";", "ReTags", ".", "clear", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Stack Tagging PreRA **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "SmallSetVector", "<", "int", ",", "8", ">", "TaggedSlots", ";", "for", "(", "auto", "&", "BB", ":", "*", "MF", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "TAGPstack", ")", "{", "ReTags", ".", "push_back", "(", "&", "I", ")", ";", "int", "FI", "=", "I", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "TaggedSlots", ".", "insert", "(", "FI", ")", ";", "assert", "(", "I", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "}", "}", "}", "if", "(", "ReTags", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "mayUseUncheckedLoadStore", "(", ")", ")", "uncheckLoadsAndStores", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"********** AArch64 Stack Tagging PreRA **********\\n\"", "\"********** Function: \"", "8", "AArch64::TAGPstack", "1", "2", "0" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"X86ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\"Base.Reg \"", ";", "if", "(", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "0", ")", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", "<<", "\" Scale\"", "<<", "Scale", "<<", "'\\n'", "<<", "\"IndexReg \"", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", "!=", "0", ")", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", "<<", "\"GV \"", ";", "if", "(", "GV", ")", "GV", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" CP \"", ";", "if", "(", "CP", ")", "CP", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "'\\n'", "<<", "\"ES \"", ";", "if", "(", "ES", ")", "dbgs", "(", ")", "<<", "ES", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "X86", "\"X86ISelAddressMode \"", "\"Base.Reg \"", "0", "\"nul\"", "\" Base.FrameIndex \"", "\" Scale\"", "\"IndexReg \"", "0", "\"nul\"", "\" Disp \"", "\"GV \"", "\"nul\"", "\" CP \"", "\"nul\"", "\"ES \"", "\"nul\"", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "bool", "TeakTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "Imm", ">=", "-", "32768", "&&", "Imm", "<=", "32767", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "32768", "32767" ]

[]

[ "<s>", "static", "void", "mimic_memory_attributes_and_flags", "(", "rtx", "new_mem_exp", ",", "const_rtx", "original_mem_exp", ")", "{", "RTX_FLAG", "(", "new_mem_exp", ",", "jump", ")", "=", "RTX_FLAG", "(", "original_mem_exp", ",", "jump", ")", ";", "RTX_FLAG", "(", "new_mem_exp", ",", "call", ")", "=", "RTX_FLAG", "(", "original_mem_exp", ",", "call", ")", ";", "RTX_FLAG", "(", "new_mem_exp", ",", "unchanging", ")", "=", "RTX_FLAG", "(", "original_mem_exp", ",", "unchanging", ")", ";", "RTX_FLAG", "(", "new_mem_exp", ",", "volatil", ")", "=", "RTX_FLAG", "(", "original_mem_exp", ",", "volatil", ")", ";", "RTX_FLAG", "(", "new_mem_exp", ",", "frame_related", ")", "=", "RTX_FLAG", "(", "original_mem_exp", ",", "frame_related", ")", ";", "RTX_FLAG", "(", "new_mem_exp", ",", "in_struct", ")", "=", "RTX_FLAG", "(", "original_mem_exp", ",", "in_struct", ")", ";", "RTX_FLAG", "(", "new_mem_exp", ",", "return_val", ")", "=", "RTX_FLAG", "(", "original_mem_exp", ",", "return_val", ")", ";", "struct", "mem_attrs", "original_attrs", "=", "*", "get_mem_attrs", "(", "original_mem_exp", ")", ";", "alias_set_type", "set", "=", "original_attrs", ".", "alias", ";", "set_mem_alias_set", "(", "new_mem_exp", ",", "set", ")", ";", "addr_space_t", "addrspace", "=", "original_attrs", ".", "addrspace", ";", "set_mem_addr_space", "(", "new_mem_exp", ",", "addrspace", ")", ";", "unsigned", "int", "align", "=", "original_attrs", ".", "align", ";", "set_mem_align", "(", "new_mem_exp", ",", "align", ")", ";", "tree", "expr", "=", "original_attrs", ".", "expr", ";", "set_mem_expr", "(", "new_mem_exp", ",", "expr", ")", ";", "if", "(", "original_attrs", ".", "offset_known_p", ")", "{", "HOST_WIDE_INT", "offset", "=", "original_attrs", ".", "offset", ";", "set_mem_offset", "(", "new_mem_exp", ",", "offset", ")", ";", "}", "else", "clear_mem_offset", "(", "new_mem_exp", ")", ";", "if", "(", "original_attrs", ".", "size_known_p", ")", "{", "HOST_WIDE_INT", "size", "=", "original_attrs", ".", "size", ";", "set_mem_size", "(", "new_mem_exp", ",", "size", ")", ";", "}", "else", "clear_mem_size", "(", "new_mem_exp", ")", ";", "}", "</s>" ]

[ "Make", "NEW_MEM_EXP", "'s", "attributes", "and", "flags", "resemble", "those", "of", "ORIGINAL_MEM_EXP", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "remove_non_convertible_regs", "(", "bitmap", "candidates", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "bitmap", "regs", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "candidates", ",", "0", ",", "id", ",", "bi", ")", "{", "rtx", "def_set", "=", "single_set", "(", "DF_INSN_UID_GET", "(", "id", ")", "->", "insn", ")", ";", "rtx", "reg", "=", "SET_DEST", "(", "def_set", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "bitmap_bit_p", "(", "regs", ",", "REGNO", "(", "reg", ")", ")", "||", "HARD_REGISTER_P", "(", "reg", ")", ")", "continue", ";", "for", "(", "df_ref", "def", "=", "DF_REG_DEF_CHAIN", "(", "REGNO", "(", "reg", ")", ")", ";", "def", ";", "def", "=", "DF_REF_NEXT_REG", "(", "def", ")", ")", "{", "if", "(", "!", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"r%d has non convertible definition in insn %d\\n\"", ",", "REGNO", "(", "reg", ")", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "bitmap_set_bit", "(", "regs", ",", "REGNO", "(", "reg", ")", ")", ";", "break", ";", "}", "}", "}", "EXECUTE_IF_SET_IN_BITMAP", "(", "regs", ",", "0", ",", "id", ",", "bi", ")", "{", "for", "(", "df_ref", "def", "=", "DF_REG_DEF_CHAIN", "(", "id", ")", ";", "def", ";", "def", "=", "DF_REF_NEXT_REG", "(", "def", ")", ")", "if", "(", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Removing insn %d from candidates list\\n\"", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "bitmap_clear_bit", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "}", "}", "BITMAP_FREE", "(", "regs", ")", ";", "}", "</s>" ]

[ "For", "a", "given", "bitmap", "of", "insn", "UIDs", "scans", "all", "instruction", "and", "remove", "insn", "from", "CANDIDATES", "in", "case", "it", "has", "both", "convertible", "and", "not", "convertible", "definitions", ".", "All", "insns", "in", "a", "bitmap", "are", "conversion", "candidates", "according", "to", "scalar_to_vector_candidate_p", ".", "Currently", "it", "implies", "all", "insns", "are", "single_set", "." ]

[ "i386", "0", "\"r%d has non convertible definition in insn %d\\n\"", "0", "\"Removing insn %d from candidates list\\n\"" ]

[]

[ "<s>", "MSP430Subtarget", "&", "MSP430Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "ExtendedInsts", "=", "false", ";", "HWMultMode", "=", "NoHWMult", ";", "StringRef", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"msp430\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "if", "(", "HWMultModeOption", "!=", "NoHWMult", ")", "HWMultMode", "=", "HWMultModeOption", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "\"msp430\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIRegisterInfo", "::", "getCFGStructurizerRegClass", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "case", "MVT", "::", "i32", ":", "return", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "}", "</s>" ]

[ "get", "the", "register", "class", "of", "the", "specified", "type", "to", "use", "in", "the", "CFGStructurizer" ]

[ "AMDGPU", "SI", "MVT::i32", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "bool", "MCS51FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MCS51Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "8", "&&", "\"Invalid register size\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "POPRd", ")", ",", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51", "8", "\"Invalid register size\"", "MCS51::POPRd" ]

[]

[ "<s>", "void", "h8300_init_once", "(", ")", "{", "static", "const", "char", "*", "const", "h8_push_ops", "[", "2", "]", "=", "{", "\"push\"", ",", "\"push.l\"", "}", ";", "static", "const", "char", "*", "const", "h8_pop_ops", "[", "2", "]", "=", "{", "\"pop\"", ",", "\"pop.l\"", "}", ";", "static", "const", "char", "*", "const", "h8_mov_ops", "[", "2", "]", "=", "{", "\"mov.w\"", ",", "\"mov.l\"", "}", ";", "if", "(", "TARGET_H8300", ")", "{", "cpu_type", "=", "(", "int", ")", "CPU_H8300", ";", "h8_reg_names", "=", "names_big", ";", "}", "else", "{", "cpu_type", "=", "(", "int", ")", "CPU_H8300H", ";", "h8_reg_names", "=", "names_extended", ";", "}", "h8_push_op", "=", "h8_push_ops", "[", "cpu_type", "]", ";", "h8_pop_op", "=", "h8_pop_ops", "[", "cpu_type", "]", ";", "h8_mov_op", "=", "h8_mov_ops", "[", "cpu_type", "]", ";", "if", "(", "!", "TARGET_H8300S", "&&", "TARGET_MAC", ")", "{", "error", "(", "\"-ms2600 is used without -ms\"", ")", ";", "target_flags", "|=", "1", ";", "}", "}", "</s>" ]

[ "Initialize", "various", "cpu", "specific", "globals", "at", "start", "up", "." ]

[ "h8300", "2", "\"push\"", "\"push.l\"", "2", "\"pop\"", "\"pop.l\"", "2", "\"mov.w\"", "\"mov.l\"", "\"-ms2600 is used without -ms\"", "1" ]

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX512", "(", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "bool", "YMMUsed", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "X86", "::", "VR256RegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YMMUsed", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "YMMUsed", ")", "{", "return", "false", ";", "}", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "*", "I", ")", ";", "if", "(", "checkFnHasLiveInYmm", "(", "MRI", ")", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "addDirtySuccessor", "(", "*", "*", "SI", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::VR256RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]

[]

[ "<s>", "Z80oldSubtarget", "&", "Z80oldSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "HasIdxHalfRegs", "=", "HasUndocOps", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "Z80old" ]

[]

[ "<s>", "unsigned", "ARMMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "getARMRegisterNumbering", "(", "Reg", ")", ";", "switch", "(", "Reg", ")", "{", "default", ":", "return", "RegNo", ";", "case", "ARM", "::", "Q0", ":", "case", "ARM", "::", "Q1", ":", "case", "ARM", "::", "Q2", ":", "case", "ARM", "::", "Q3", ":", "case", "ARM", "::", "Q4", ":", "case", "ARM", "::", "Q5", ":", "case", "ARM", "::", "Q6", ":", "case", "ARM", "::", "Q7", ":", "case", "ARM", "::", "Q8", ":", "case", "ARM", "::", "Q9", ":", "case", "ARM", "::", "Q10", ":", "case", "ARM", "::", "Q11", ":", "case", "ARM", "::", "Q12", ":", "case", "ARM", "::", "Q13", ":", "case", "ARM", "::", "Q14", ":", "case", "ARM", "::", "Q15", ":", "return", "2", "*", "RegNo", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unable to encode MCOperand!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM::Q0", "ARM::Q1", "ARM::Q2", "ARM::Q3", "ARM::Q4", "ARM::Q5", "ARM::Q6", "ARM::Q7", "ARM::Q8", "ARM::Q9", "ARM::Q10", "ARM::Q11", "ARM::Q12", "ARM::Q13", "ARM::Q14", "ARM::Q15", "2", "32", "\"Unable to encode MCOperand!\"" ]

[]

[ "<s>", "void", "c4x_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ")", "{", "tree", "param", ",", "next_param", ";", "cum", "->", "floats", "=", "cum", "->", "ints", "=", "0", ";", "cum", "->", "init", "=", "0", ";", "cum", "->", "var", "=", "0", ";", "cum", "->", "args", "=", "0", ";", "if", "(", "TARGET_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nc4x_init_cumulative_args (\"", ")", ";", "if", "(", "fntype", ")", "{", "tree", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fprintf", "(", "stderr", ",", "\"fntype code = %s, ret code = %s\"", ",", "tree_code_name", "[", "(", "int", ")", "TREE_CODE", "(", "fntype", ")", "]", ",", "tree_code_name", "[", "(", "int", ")", "TREE_CODE", "(", "ret_type", ")", "]", ")", ";", "}", "else", "fprintf", "(", "stderr", ",", "\"no fntype\"", ")", ";", "if", "(", "libname", ")", "fprintf", "(", "stderr", ",", "\", libname = %s\"", ",", "XSTR", "(", "libname", ",", "0", ")", ")", ";", "}", "cum", "->", "prototype", "=", "(", "fntype", "&&", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ";", "for", "(", "param", "=", "fntype", "?", "TYPE_ARG_TYPES", "(", "fntype", ")", ":", "0", ";", "param", ";", "param", "=", "next_param", ")", "{", "tree", "type", ";", "next_param", "=", "TREE_CHAIN", "(", "param", ")", ";", "type", "=", "TREE_VALUE", "(", "param", ")", ";", "if", "(", "type", "&&", "type", "!=", "void_type_node", ")", "{", "enum", "machine_mode", "mode", ";", "if", "(", "!", "next_param", ")", "cum", "->", "var", "=", "1", ";", "if", "(", "(", "mode", "=", "TYPE_MODE", "(", "type", ")", ")", ")", "{", "if", "(", "!", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "{", "if", "(", "mode", "==", "QFmode", "||", "mode", "==", "HFmode", ")", "cum", "->", "floats", "++", ";", "else", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "Pmode", ")", "cum", "->", "ints", "++", ";", "}", "}", "cum", "->", "args", "++", ";", "}", "}", "if", "(", "TARGET_DEBUG", ")", "fprintf", "(", "stderr", ",", "\"%s%s, args = %d)\\n\"", ",", "cum", "->", "prototype", "?", "\", prototype\"", ":", "\"\"", ",", "cum", "->", "var", "?", "\", variable args\"", ":", "\"\"", ",", "cum", "->", "args", ")", ";", "}", "</s>" ]

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

[ "c4x", "0", "0", "0", "0", "\"\\nc4x_init_cumulative_args (\"", "\"fntype code = %s, ret code = %s\"", "\"no fntype\"", "\", libname = %s\"", "0", "0", "1", "\"%s%s, args = %d)\\n\"", "\", prototype\"", "\"\"", "\", variable args\"", "\"\"" ]

[]

[ "<s>", "static", "int", "nds32_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "TARGET_PIPELINE_GRAYWOLF", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "{", "if", "(", "from", "==", "FP_REGS", "&&", "to", "!=", "FP_REGS", ")", "return", "3", ";", "if", "(", "from", "!=", "FP_REGS", "&&", "to", "==", "FP_REGS", ")", "return", "2", ";", "}", "else", "{", "if", "(", "(", "from", "==", "FP_REGS", "&&", "to", "!=", "FP_REGS", ")", "||", "(", "from", "!=", "FP_REGS", "&&", "to", "==", "FP_REGS", ")", ")", "return", "2", ";", "}", "}", "if", "(", "(", "from", "==", "FP_REGS", "&&", "to", "!=", "FP_REGS", ")", "||", "(", "from", "!=", "FP_REGS", "&&", "to", "==", "FP_REGS", ")", ")", "return", "3", ";", "else", "if", "(", "from", "==", "HIGH_REGS", "||", "to", "==", "HIGH_REGS", ")", "return", "optimize_size", "?", "6", ":", "2", ";", "else", "return", "2", ";", "}", "</s>" ]

[ "Describing", "Relative", "Costs", "of", "Operations", "." ]

[ "nds32", "8", "3", "2", "2", "3", "6", "2", "2" ]

[]

[ "<s>", "void", "MipsTargetELFStreamer", "::", "finish", "(", ")", "{", "MCAssembler", "&", "MCA", "=", "getStreamer", "(", ")", ".", "getAssembler", "(", ")", ";", "const", "MCObjectFileInfo", "&", "OFI", "=", "*", "MCA", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", ";", "MCSection", "&", "TextSection", "=", "*", "OFI", ".", "getTextSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "TextSection", ")", ";", "MCSection", "&", "DataSection", "=", "*", "OFI", ".", "getDataSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "DataSection", ")", ";", "MCSection", "&", "BSSSection", "=", "*", "OFI", ".", "getBSSSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "BSSSection", ")", ";", "TextSection", ".", "setAlignment", "(", "Align", "(", "std", "::", "max", "(", "16u", ",", "TextSection", ".", "getAlignment", "(", ")", ")", ")", ")", ";", "DataSection", ".", "setAlignment", "(", "Align", "(", "std", "::", "max", "(", "16u", ",", "DataSection", ".", "getAlignment", "(", ")", ")", ")", ")", ";", "BSSSection", ".", "setAlignment", "(", "Align", "(", "std", "::", "max", "(", "16u", ",", "BSSSection", ".", "getAlignment", "(", ")", ")", ")", ")", ";", "if", "(", "RoundSectionSizes", ")", "{", "MCStreamer", "&", "OS", "=", "getStreamer", "(", ")", ";", "for", "(", "MCSection", "&", "S", ":", "MCA", ")", "{", "MCSectionELF", "&", "Section", "=", "static_cast", "<", "MCSectionELF", "&", ">", "(", "S", ")", ";", "unsigned", "Alignment", "=", "Section", ".", "getAlignment", "(", ")", ";", "if", "(", "Alignment", ")", "{", "OS", ".", "SwitchSection", "(", "&", "Section", ")", ";", "if", "(", "Section", ".", "UseCodeAlign", "(", ")", ")", "OS", ".", "emitCodeAlignment", "(", "Alignment", ",", "&", "STI", ",", "Alignment", ")", ";", "else", "OS", ".", "emitValueToAlignment", "(", "Alignment", ",", "0", ",", "1", ",", "Alignment", ")", ";", "}", "}", "}", "const", "FeatureBitset", "&", "Features", "=", "STI", ".", "getFeatureBits", "(", ")", ";", "unsigned", "EFlags", "=", "MCA", ".", "getELFHeaderEFlags", "(", ")", ";", "if", "(", "getABI", "(", ")", ".", "IsO32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_ABI_O32", ";", "else", "if", "(", "getABI", "(", ")", ".", "IsN32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_ABI2", ";", "if", "(", "Features", "[", "Mips", "::", "FeatureGP64Bit", "]", ")", "{", "if", "(", "getABI", "(", ")", ".", "IsO32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_32BITMODE", ";", "}", "else", "if", "(", "Features", "[", "Mips", "::", "FeatureMips64r2", "]", "||", "Features", "[", "Mips", "::", "FeatureMips64", "]", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_32BITMODE", ";", "if", "(", "!", "Features", "[", "Mips", "::", "FeatureNoABICalls", "]", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_CPIC", ";", "if", "(", "Pic", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_PIC", "|", "ELF", "::", "EF_MIPS_CPIC", ";", "MCA", ".", "setELFHeaderEFlags", "(", "EFlags", ")", ";", "MipsELFStreamer", "&", "MEF", "=", "static_cast", "<", "MipsELFStreamer", "&", ">", "(", "Streamer", ")", ";", "MEF", ".", "EmitMipsOptionRecords", "(", ")", ";", "emitMipsAbiFlags", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "Mips", "Mips", "16u", "16u", "16u", "0", "1", "Mips::FeatureGP64Bit", "Mips::FeatureMips64r2", "Mips::FeatureMips64", "Mips::FeatureNoABICalls", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "MCRegisterInfo", "&", ",", "const", "Triple", "&", "TT", ")", "{", "return", "new", "WebAssemblyMCAsmInfo", "(", "TT", ")", ";", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "AAPAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "AAPMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "AAP" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "case", "ISD", "::", "BRIND", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented computed gotos\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented __builtin_return_address\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerAccessVectorElement", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerShift", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::FrameIndex", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::JumpTable", "ISD::BR_JT", "ISD::VASTART", "ISD::BlockAddress", "ISD::BRIND", "\"WebAssembly hasn't implemented computed gotos\"", "ISD::RETURNADDR", "\"WebAssembly hasn't implemented __builtin_return_address\"", "ISD::FRAMEADDR", "ISD::CopyToReg", "ISD::INTRINSIC_WO_CHAIN", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::INTRINSIC_VOID", "ISD::SIGN_EXTEND_INREG", "ISD::VECTOR_SHUFFLE", "ISD::SHL", "ISD::SRA", "ISD::SRL" ]

[]

[ "<s>", "bool", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "unsigned", "ExtraPredCycles", ",", "BranchProbability", "Probability", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "PowerPC" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CCAssignFnForCall", "(", "CallConv", ",", "isVarArg", ")", ")", ";", "}", "else", "{", "analyzeFormalArgumentsCompute", "(", "CCInfo", ",", "Ins", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "R600", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "PARAM_I_ADDRESS", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Alignment", "=", "MinAlign", "(", "VT", ".", "getStoreSize", "(", ")", ",", "PartOffset", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "PartOffset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "Alignment", ",", "MachineMemOperand", "::", "MONonTemporal", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "ISD::InputArg", "16", "ISD::InputArg", "8", "AMDGPU::isShader", "0", "ISD::InputArg", "AMDGPU::isShader", "R600::R600_Reg128RegClass", "AMDGPU", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "ISD::UNINDEXED", "MVT::i32", "MVT::i32" ]

[]

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

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

[ "NVPTX" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "PM", ".", "add", "(", "createX86MaxStackAlignmentHeuristicPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "rs6000_emit_set_const", "(", "rtx", "dest", ",", "rtx", "source", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "temp", ",", "set", ";", "rtx_insn", "*", "insn", ";", "HOST_WIDE_INT", "c", ";", "gcc_checking_assert", "(", "CONST_INT_P", "(", "source", ")", ")", ";", "c", "=", "INTVAL", "(", "source", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "source", ")", ")", ";", "return", "true", ";", "case", "E_SImode", ":", "temp", "=", "!", "can_create_pseudo_p", "(", ")", "?", "dest", ":", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "GEN_INT", "(", "c", "&", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IOR", "(", "SImode", ",", "temp", ",", "GEN_INT", "(", "c", "&", "0xffff", ")", ")", ")", ")", ";", "break", ";", "case", "E_DImode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "{", "rtx", "hi", ",", "lo", ";", "hi", "=", "operand_subword_force", "(", "dest", ",", "WORDS_BIG_ENDIAN", "==", "0", ",", "DImode", ")", ";", "lo", "=", "operand_subword_force", "(", "dest", ",", "WORDS_BIG_ENDIAN", "!=", "0", ",", "DImode", ")", ";", "emit_move_insn", "(", "hi", ",", "GEN_INT", "(", "c", ">>", "32", ")", ")", ";", "c", "=", "sext_hwi", "(", "c", ",", "32", ")", ";", "emit_move_insn", "(", "lo", ",", "GEN_INT", "(", "c", ")", ")", ";", "}", "else", "rs6000_emit_set_long_const", "(", "dest", ",", "c", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "insn", "=", "get_last_insn", "(", ")", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "GEN_INT", "(", "c", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "output", "insns", "to", "set", "TARGET", "equal", "to", "the", "constant", "C", "if", "it", "can", "be", "done", "in", "less", "than", "N", "insns", ".", "Do", "all", "computations", "in", "MODE", ".", "Returns", "the", "place", "where", "the", "output", "has", "been", "placed", "if", "it", "can", "be", "done", "and", "the", "insns", "have", "been", "emitted", ".", "If", "it", "would", "take", "more", "than", "N", "insns", ",", "zero", "is", "returned", "and", "no", "insns", "and", "emitted", "." ]

[ "rs6000", "0xffff", "0xffff", "0", "0", "32", "32" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "lowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "VE", "VE", "\"Should not custom lower this!\"", "ISD::ATOMIC_FENCE", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::LOAD", "ISD::STORE", "ISD::VASTART", "ISD::VAARG" ]

[]

[ "<s>", "bool", "sh_symbian_dllimport_name_p", "(", "const", "char", "*", "symbol", ")", "{", "return", "strncmp", "(", "DLL_IMPORT_PREFIX", ",", "symbol", ",", "strlen", "(", "DLL_IMPORT_PREFIX", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "SYMBOL", "is", "marked", "as", "being", "dllimport", "'d", "." ]

[ "sh", "0" ]

[]

[ "<s>", "bool", "SystemZAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "const", "MCRegisterInfo", "&", "MRI", "=", "*", "TM", ".", "getMCRegisterInfo", "(", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "MCOperand", "MCOp", ";", "if", "(", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "[", "0", "]", "==", "'N'", "&&", "!", "ExtraCode", "[", "1", "]", "&&", "MO", ".", "isReg", "(", ")", "&&", "SystemZ", "::", "GR128BitRegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MRI", ".", "getSubReg", "(", "MO", ".", "getReg", "(", ")", ",", "SystemZ", "::", "subreg_l64", ")", ")", ";", "else", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", "else", "{", "SystemZMCInstLower", "Lower", "(", "MF", "->", "getContext", "(", ")", ",", "*", "this", ")", ";", "MCOp", "=", "Lower", ".", "lowerOperand", "(", "MO", ")", ";", "}", "SystemZInstPrinter", "::", "printOperand", "(", "MCOp", ",", "MAI", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "1", "SystemZ::GR128BitRegClass", "SystemZ::subreg_l64", "SystemZ", "SystemZ" ]

[]

[ "<s>", "const", "char", "*", "msp430_select_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "if", "(", "argc", "==", "0", ")", "{", "error", "(", "\"expected an argument to %<msp430_select_cpu%>\"", ")", ";", "return", "NULL", ";", "}", "msp430_extract_mcu_data", "(", "argv", "[", "0", "]", ")", ";", "if", "(", "extracted_mcu_data", ".", "name", "!=", "NULL", ")", "{", "switch", "(", "extracted_mcu_data", ".", "revision", ")", "{", "case", "0", ":", "return", "\"-mcpu=msp430\"", ";", "case", "1", ":", "return", "\"-mcpu=msp430x\"", ";", "case", "2", ":", "return", "\"-mcpu=msp430xv2\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "NULL", ";", "}", "</s>" ]

[ "This", "spec", "function", "is", "called", "if", "the", "user", "has", "provided", "an", "-mmcu", "option", "without", "an", "-mcpu", "option", ".", "It", "will", "place", "the", "correct", "-mcpu", "option", "for", "the", "given", "-mmcu", "onto", "the", "command", "line", ",", "to", "ensure", "the", "correct", "ISA", "multilib", "is", "selected", "." ]

[ "msp430", "0", "\"expected an argument to %<msp430_select_cpu%>\"", "0", "0", "\"-mcpu=msp430\"", "1", "\"-mcpu=msp430x\"", "2", "\"-mcpu=msp430xv2\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getNumMicroOps", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "1", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "Class", "=", "Desc", ".", "getSchedClass", "(", ")", ";", "int", "ItinUOps", "=", "ItinData", "->", "getNumMicroOps", "(", "Class", ")", ";", "if", "(", "ItinUOps", ">=", "0", ")", "return", "ItinUOps", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected multi-uops instruction!\"", ")", ";", "case", "ARM", "::", "VLDMQIA", ":", "case", "ARM", "::", "VSTMQIA", ":", "return", "2", ";", "case", "ARM", "::", "VLDMDIA", ":", "case", "ARM", "::", "VLDMDIA_UPD", ":", "case", "ARM", "::", "VLDMDDB_UPD", ":", "case", "ARM", "::", "VLDMSIA", ":", "case", "ARM", "::", "VLDMSIA_UPD", ":", "case", "ARM", "::", "VLDMSDB_UPD", ":", "case", "ARM", "::", "VSTMDIA", ":", "case", "ARM", "::", "VSTMDIA_UPD", ":", "case", "ARM", "::", "VSTMDDB_UPD", ":", "case", "ARM", "::", "VSTMSIA", ":", "case", "ARM", "::", "VSTMSIA_UPD", ":", "case", "ARM", "::", "VSTMSDB_UPD", ":", "{", "unsigned", "NumRegs", "=", "MI", "->", "getNumOperands", "(", ")", "-", "Desc", ".", "getNumOperands", "(", ")", ";", "return", "(", "NumRegs", "/", "2", ")", "+", "(", "NumRegs", "%", "2", ")", "+", "1", ";", "}", "case", "ARM", "::", "LDMIA_RET", ":", "case", "ARM", "::", "LDMIA", ":", "case", "ARM", "::", "LDMDA", ":", "case", "ARM", "::", "LDMDB", ":", "case", "ARM", "::", "LDMIB", ":", "case", "ARM", "::", "LDMIA_UPD", ":", "case", "ARM", "::", "LDMDA_UPD", ":", "case", "ARM", "::", "LDMDB_UPD", ":", "case", "ARM", "::", "LDMIB_UPD", ":", "case", "ARM", "::", "STMIA", ":", "case", "ARM", "::", "STMDA", ":", "case", "ARM", "::", "STMDB", ":", "case", "ARM", "::", "STMIB", ":", "case", "ARM", "::", "STMIA_UPD", ":", "case", "ARM", "::", "STMDA_UPD", ":", "case", "ARM", "::", "STMDB_UPD", ":", "case", "ARM", "::", "STMIB_UPD", ":", "case", "ARM", "::", "tLDMIA", ":", "case", "ARM", "::", "tLDMIA_UPD", ":", "case", "ARM", "::", "tSTMIA_UPD", ":", "case", "ARM", "::", "tPOP_RET", ":", "case", "ARM", "::", "tPOP", ":", "case", "ARM", "::", "tPUSH", ":", "case", "ARM", "::", "t2LDMIA_RET", ":", "case", "ARM", "::", "t2LDMIA", ":", "case", "ARM", "::", "t2LDMDB", ":", "case", "ARM", "::", "t2LDMIA_UPD", ":", "case", "ARM", "::", "t2LDMDB_UPD", ":", "case", "ARM", "::", "t2STMIA", ":", "case", "ARM", "::", "t2STMDB", ":", "case", "ARM", "::", "t2STMIA_UPD", ":", "case", "ARM", "::", "t2STMDB_UPD", ":", "{", "unsigned", "NumRegs", "=", "MI", "->", "getNumOperands", "(", ")", "-", "Desc", ".", "getNumOperands", "(", ")", "+", "1", ";", "if", "(", "Subtarget", ".", "isCortexA8", "(", ")", ")", "{", "if", "(", "NumRegs", "<", "4", ")", "return", "2", ";", "int", "A8UOps", "=", "(", "NumRegs", "/", "2", ")", ";", "if", "(", "NumRegs", "%", "2", ")", "++", "A8UOps", ";", "return", "A8UOps", ";", "}", "else", "if", "(", "Subtarget", ".", "isCortexA9", "(", ")", ")", "{", "int", "A9UOps", "=", "(", "NumRegs", "/", "2", ")", ";", "if", "(", "(", "NumRegs", "%", "2", ")", "||", "!", "MI", "->", "hasOneMemOperand", "(", ")", "||", "(", "*", "MI", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", "<", "8", ")", "++", "A9UOps", ";", "return", "A9UOps", ";", "}", "else", "{", "return", "NumRegs", ";", "}", "}", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "issue", "slots", "required", "for", "this", "MI", "." ]

[ "ARM", "ARM", "1", "0", "\"Unexpected multi-uops instruction!\"", "ARM::VLDMQIA", "ARM::VSTMQIA", "2", "ARM::VLDMDIA", "ARM::VLDMDIA_UPD", "ARM::VLDMDDB_UPD", "ARM::VLDMSIA", "ARM::VLDMSIA_UPD", "ARM::VLDMSDB_UPD", "ARM::VSTMDIA", "ARM::VSTMDIA_UPD", "ARM::VSTMDDB_UPD", "ARM::VSTMSIA", "ARM::VSTMSIA_UPD", "ARM::VSTMSDB_UPD", "2", "2", "1", "ARM::LDMIA_RET", "ARM::LDMIA", "ARM::LDMDA", "ARM::LDMDB", "ARM::LDMIB", "ARM::LDMIA_UPD", "ARM::LDMDA_UPD", "ARM::LDMDB_UPD", "ARM::LDMIB_UPD", "ARM::STMIA", "ARM::STMDA", "ARM::STMDB", "ARM::STMIB", "ARM::STMIA_UPD", "ARM::STMDA_UPD", "ARM::STMDB_UPD", "ARM::STMIB_UPD", "ARM::tLDMIA", "ARM::tLDMIA_UPD", "ARM::tSTMIA_UPD", "ARM::tPOP_RET", "ARM::tPOP", "ARM::tPUSH", "ARM::t2LDMIA_RET", "ARM::t2LDMIA", "ARM::t2LDMDB", "ARM::t2LDMIA_UPD", "ARM::t2LDMDB_UPD", "ARM::t2STMIA", "ARM::t2STMDB", "ARM::t2STMIA_UPD", "ARM::t2STMDB_UPD", "1", "4", "2", "2", "2", "2", "2", "8" ]

[]

[ "<s>", "bool", "contains", "(", "MachineInstr", "&", "MI", ")", "{", "return", "Insts", ".", "count", "(", "&", "MI", ")", ">", "0", ";", "}", "</s>" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

[ "AArch64", "0" ]

[]

[ "<s>", "static", "rtx", "mips_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "base", ",", "addr", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "mips_tls_symbol_p", "(", "x", ")", ")", "return", "mips_legitimize_tls_address", "(", "x", ")", ";", "if", "(", "mips_split_symbol", "(", "NULL", ",", "x", ",", "mode", ",", "&", "addr", ")", ")", "return", "mips_force_address", "(", "addr", ",", "mode", ")", ";", "mips_split_plus", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "0", ")", "{", "if", "(", "!", "mips_valid_base_register_p", "(", "base", ",", "mode", ",", "false", ")", ")", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "base", ")", ";", "addr", "=", "mips_add_offset", "(", "NULL", ",", "base", ",", "offset", ")", ";", "return", "mips_force_address", "(", "addr", ",", "mode", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "implement", "LEGITIMIZE_ADDRESS", ".", "If", "*", "XLOC", "can", "be", "legitimized", "in", "a", "way", "that", "the", "generic", "machinery", "might", "not", "expect", ",", "put", "the", "new", "address", "in", "*", "XLOC", "and", "return", "true", ".", "MODE", "is", "the", "mode", "of", "the", "memory", "being", "accessed", "." ]

[ "mips", "0" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "EVT", "MBlazeTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "MBlaze", "MBlaze", "MVT::i32" ]

[]

[ "<s>", "void", "X86AsmParser", "::", "EmitInstruction", "(", "MCInst", "&", "Inst", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "Instrumentation", "->", "InstrumentInstruction", "(", "Inst", ",", "Operands", ",", "getContext", "(", ")", ",", "MII", ",", "Out", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "emit_predicate_relation_info", "(", ")", "{", "int", "i", ";", "for", "(", "i", "=", "n_basic_blocks", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "basic_block", "bb", "=", "BASIC_BLOCK", "(", "i", ")", ";", "int", "r", ";", "rtx", "head", "=", "bb", "->", "head", ";", "if", "(", "GET_CODE", "(", "head", ")", "!=", "CODE_LABEL", ")", "continue", ";", "if", "(", "GET_CODE", "(", "NEXT_INSN", "(", "head", ")", ")", "==", "NOTE", "&&", "NOTE_LINE_NUMBER", "(", "NEXT_INSN", "(", "head", ")", ")", "==", "NOTE_INSN_BASIC_BLOCK", ")", "head", "=", "NEXT_INSN", "(", "head", ")", ";", "for", "(", "r", "=", "PR_REG", "(", "0", ")", ";", "r", "<", "PR_REG", "(", "64", ")", ";", "r", "+=", "2", ")", "if", "(", "REGNO_REG_SET_P", "(", "bb", "->", "global_live_at_start", ",", "r", ")", ")", "{", "rtx", "p", "=", "gen_rtx_REG", "(", "BImode", ",", "r", ")", ";", "rtx", "n", "=", "emit_insn_after", "(", "gen_pred_rel_mutex", "(", "p", ")", ",", "head", ")", ";", "if", "(", "head", "==", "bb", "->", "end", ")", "bb", "->", "end", "=", "n", ";", "head", "=", "n", ";", "}", "}", "for", "(", "i", "=", "n_basic_blocks", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "basic_block", "bb", "=", "BASIC_BLOCK", "(", "i", ")", ";", "rtx", "insn", "=", "bb", "->", "head", ";", "while", "(", "1", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COND_EXEC", "&&", "find_reg_note", "(", "insn", ",", "REG_NORETURN", ",", "NULL_RTX", ")", ")", "{", "rtx", "b", "=", "emit_insn_before", "(", "gen_safe_across_calls_all", "(", ")", ",", "insn", ")", ";", "rtx", "a", "=", "emit_insn_after", "(", "gen_safe_across_calls_normal", "(", ")", ",", "insn", ")", ";", "if", "(", "bb", "->", "head", "==", "insn", ")", "bb", "->", "head", "=", "b", ";", "if", "(", "bb", "->", "end", "==", "insn", ")", "bb", "->", "end", "=", "a", ";", "}", "if", "(", "insn", "==", "bb", "->", "end", ")", "break", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Emit", "pseudo-ops", "for", "the", "assembler", "to", "describe", "predicate", "relations", ".", "At", "present", "this", "assumes", "that", "we", "only", "consider", "predicate", "pairs", "to", "be", "mutex", ",", "and", "that", "the", "assembler", "can", "deduce", "proper", "values", "from", "straight-line", "code", "." ]

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

[]

[ "<s>", "unsigned", "MSP430InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "return", "Desc", ".", "getSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

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

[]

[ "<s>", "EVT", "AAPTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "{", "return", "MVT", "::", "i16", ";", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "AAP", "AAP", "MVT::i16" ]

[]

[ "<s>", "static", "rtx", "emit_multi_reg_push", "(", "unsigned", "long", "mask", ",", "unsigned", "long", "dwarf_regs_mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "num_dwarf_regs", "=", "0", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", ";", "int", "dwarf_par_index", ";", "rtx", "tmp", ",", "reg", ";", "dwarf_regs_mask", "&=", "~", "(", "1", "<<", "PC_REGNUM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "num_dwarf_regs", "++", ";", "}", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "16", ")", ";", "gcc_assert", "(", "(", "dwarf_regs_mask", "&", "~", "mask", ")", "==", "0", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_dwarf_regs", "+", "1", ")", ")", ";", "dwarf_par_index", "=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "rtx", "dwarf_reg", "=", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", "&&", "i", "==", "IP_REGNUM", ")", "dwarf_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "RA_AUTH_CODE", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", "*", "num_regs", ")", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "SImode", ",", "stack_pointer_rtx", ")", ",", "dwarf_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", "dwarf_reg", "=", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", "&&", "i", "==", "IP_REGNUM", ")", "dwarf_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "RA_AUTH_CODE", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "if", "(", "dwarf_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "j", ")", ")", ",", "dwarf_reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "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", ")", ";", "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", "." ]

[ "arm", "0", "0", "1", "0", "1", "1", "16", "0", "1", "1", "0", "1", "0", "0", "4", "1", "1", "1", "0", "1", "1", "0", "1", "4", "1", "0", "4", "1", "0", "0" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "<=", "UINT32_MAX", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "static_cast", "<", "uint32_t", ">", "(", "Value", ")", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", "{", "Value", "=", "(", "uint32_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "Endian", "==", "support", "::", "little", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x10", ";", "support", "::", "endian", "::", "write32le", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x1", ";", "support", "::", "endian", "::", "write32be", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", ",", "Value", ",", "Endian", ")", ";", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "support::endian", "4", "support::endian", "support::endian", "8", "8", "support::little", "1", "0x10", "support::endian", "4", "1", "0x1", "support::endian", "4", "8", "8", "support::endian", "2" ]

[]

[ "<s>", "bool", "TPCImmToReg", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "if", "(", "!", "EnableTPCImmToReg", ")", "return", "false", ";", "MF", "=", "&", "Func", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "if", "(", "skipFunction", "(", "Func", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "processImmOperand", "(", "Func", ")", ";", "return", "NumReplaced", ">", "0", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "0" ]

[]

[ "<s>", "unsigned", "TriCoreRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TriCoreFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "TriCore", "::", "A14", ":", "TriCore", "::", "A10", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "TriCore", "TriCore::A14", "TriCore::A10" ]

[]

[ "<s>", "StringRef", "AArch64MCExpr", "::", "getVariantKindName", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "uint32_t", ">", "(", "getKind", "(", ")", ")", ")", "{", "case", "VK_CALL", ":", "return", "\"\"", ";", "case", "VK_LO12", ":", "return", "\":lo12:\"", ";", "case", "VK_ABS_G3", ":", "return", "\":abs_g3:\"", ";", "case", "VK_ABS_G2", ":", "return", "\":abs_g2:\"", ";", "case", "VK_ABS_G2_S", ":", "return", "\":abs_g2_s:\"", ";", "case", "VK_ABS_G2_NC", ":", "return", "\":abs_g2_nc:\"", ";", "case", "VK_ABS_G1", ":", "return", "\":abs_g1:\"", ";", "case", "VK_ABS_G1_S", ":", "return", "\":abs_g1_s:\"", ";", "case", "VK_ABS_G1_NC", ":", "return", "\":abs_g1_nc:\"", ";", "case", "VK_ABS_G0", ":", "return", "\":abs_g0:\"", ";", "case", "VK_ABS_G0_S", ":", "return", "\":abs_g0_s:\"", ";", "case", "VK_ABS_G0_NC", ":", "return", "\":abs_g0_nc:\"", ";", "case", "VK_DTPREL_G2", ":", "return", "\":dtprel_g2:\"", ";", "case", "VK_DTPREL_G1", ":", "return", "\":dtprel_g1:\"", ";", "case", "VK_DTPREL_G1_NC", ":", "return", "\":dtprel_g1_nc:\"", ";", "case", "VK_DTPREL_G0", ":", "return", "\":dtprel_g0:\"", ";", "case", "VK_DTPREL_G0_NC", ":", "return", "\":dtprel_g0_nc:\"", ";", "case", "VK_DTPREL_HI12", ":", "return", "\":dtprel_hi12:\"", ";", "case", "VK_DTPREL_LO12", ":", "return", "\":dtprel_lo12:\"", ";", "case", "VK_DTPREL_LO12_NC", ":", "return", "\":dtprel_lo12_nc:\"", ";", "case", "VK_TPREL_G2", ":", "return", "\":tprel_g2:\"", ";", "case", "VK_TPREL_G1", ":", "return", "\":tprel_g1:\"", ";", "case", "VK_TPREL_G1_NC", ":", "return", "\":tprel_g1_nc:\"", ";", "case", "VK_TPREL_G0", ":", "return", "\":tprel_g0:\"", ";", "case", "VK_TPREL_G0_NC", ":", "return", "\":tprel_g0_nc:\"", ";", "case", "VK_TPREL_HI12", ":", "return", "\":tprel_hi12:\"", ";", "case", "VK_TPREL_LO12", ":", "return", "\":tprel_lo12:\"", ";", "case", "VK_TPREL_LO12_NC", ":", "return", "\":tprel_lo12_nc:\"", ";", "case", "VK_TLSDESC_LO12", ":", "return", "\":tlsdesc_lo12:\"", ";", "case", "VK_ABS_PAGE", ":", "return", "\"\"", ";", "case", "VK_ABS_PAGE_NC", ":", "return", "\":pg_hi21_nc:\"", ";", "case", "VK_GOT_PAGE", ":", "return", "\":got:\"", ";", "case", "VK_GOT_LO12", ":", "return", "\":got_lo12:\"", ";", "case", "VK_GOTTPREL_PAGE", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_LO12_NC", ":", "return", "\":gottprel_lo12:\"", ";", "case", "VK_GOTTPREL_G1", ":", "return", "\":gottprel_g1:\"", ";", "case", "VK_GOTTPREL_G0_NC", ":", "return", "\":gottprel_g0_nc:\"", ";", "case", "VK_TLSDESC", ":", "return", "\"\"", ";", "case", "VK_TLSDESC_PAGE", ":", "return", "\":tlsdesc:\"", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "AArch64", "AArch64", "\"\"", "\":lo12:\"", "\":abs_g3:\"", "\":abs_g2:\"", "\":abs_g2_s:\"", "\":abs_g2_nc:\"", "\":abs_g1:\"", "\":abs_g1_s:\"", "\":abs_g1_nc:\"", "\":abs_g0:\"", "\":abs_g0_s:\"", "\":abs_g0_nc:\"", "\":dtprel_g2:\"", "\":dtprel_g1:\"", "\":dtprel_g1_nc:\"", "\":dtprel_g0:\"", "\":dtprel_g0_nc:\"", "\":dtprel_hi12:\"", "\":dtprel_lo12:\"", "\":dtprel_lo12_nc:\"", "\":tprel_g2:\"", "\":tprel_g1:\"", "\":tprel_g1_nc:\"", "\":tprel_g0:\"", "\":tprel_g0_nc:\"", "\":tprel_hi12:\"", "\":tprel_lo12:\"", "\":tprel_lo12_nc:\"", "\":tlsdesc_lo12:\"", "\"\"", "\":pg_hi21_nc:\"", "\":got:\"", "\":got_lo12:\"", "\":gottprel:\"", "\":gottprel_lo12:\"", "\":gottprel_g1:\"", "\":gottprel_g0_nc:\"", "\"\"", "\":tlsdesc:\"", "\"Invalid ELF symbol kind\"" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_recurse", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "startbitpos", ",", "rtx", "rvec", "[", "]", ",", "int", "*", "k", ")", "{", "tree", "f", ";", "for", "(", "f", "=", "TYPE_FIELDS", "(", "type", ")", ";", "f", ";", "f", "=", "DECL_CHAIN", "(", "f", ")", ")", "if", "(", "TREE_CODE", "(", "f", ")", "==", "FIELD_DECL", ")", "{", "HOST_WIDE_INT", "bitpos", "=", "startbitpos", ";", "tree", "ftype", "=", "TREE_TYPE", "(", "f", ")", ";", "machine_mode", "mode", ";", "if", "(", "ftype", "==", "error_mark_node", ")", "continue", ";", "mode", "=", "TYPE_MODE", "(", "ftype", ")", ";", "if", "(", "DECL_SIZE", "(", "f", ")", "!=", "0", "&&", "tree_fits_uhwi_p", "(", "bit_position", "(", "f", ")", ")", ")", "bitpos", "+=", "int_bit_position", "(", "f", ")", ";", "if", "(", "TREE_CODE", "(", "ftype", ")", "==", "RECORD_TYPE", ")", "rs6000_darwin64_record_arg_recurse", "(", "cum", ",", "ftype", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "else", "if", "(", "cum", "->", "named", "&&", "USE_FP_FOR_ARG_P", "(", "cum", ",", "mode", ")", ")", "{", "unsigned", "n_fpreg", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", ">>", "3", ";", "switch", "(", "mode", ")", "{", "case", "SCmode", ":", "mode", "=", "SFmode", ";", "break", ";", "case", "DCmode", ":", "mode", "=", "DFmode", ";", "break", ";", "case", "TCmode", ":", "mode", "=", "TFmode", ";", "break", ";", "default", ":", "break", ";", "}", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "if", "(", "cum", "->", "fregno", "+", "n_fpreg", ">", "FP_ARG_MAX_REG", "+", "1", ")", "{", "gcc_assert", "(", "cum", "->", "fregno", "==", "FP_ARG_MAX_REG", "&&", "(", "mode", "==", "TFmode", "||", "mode", "==", "TDmode", ")", ")", ";", "mode", "=", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "?", "DDmode", ":", "DFmode", ";", "cum", "->", "use_stack", "=", "1", ";", "}", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "fregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "if", "(", "mode", "==", "TFmode", "||", "mode", "==", "TDmode", ")", "cum", "->", "fregno", "++", ";", "}", "else", "if", "(", "cum", "->", "named", "&&", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "mode", ",", "1", ")", ")", "{", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "vregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "}", "else", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "cum", "->", "intoffset", "=", "bitpos", ";", "}", "}", "</s>" ]

[ "Recursive", "workhorse", "for", "the", "following", "." ]

[ "rs6000", "0", "7", "3", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "FrameIdx", "=", "0", ";", "}", "else", "if", "(", "CRSpillFrameIdx", ")", "{", "FrameIdx", "=", "CRSpillFrameIdx", ";", "}", "else", "{", "MachineFrameInfo", "*", "MFI", "=", "(", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ".", "getFrameInfo", "(", ")", ";", "FrameIdx", "=", "MFI", "->", "CreateFixedObject", "(", "(", "uint64_t", ")", "4", ",", "(", "int64_t", ")", "-", "4", ",", "true", ")", ";", "CRSpillFrameIdx", "=", "FrameIdx", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "PowerPC", "PPC", "PPC::CR2", "PPC::CR4", "PPC", "0", "4", "4" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", ")", "return", "true", ";", "}", "bool", "ReverseVEXT", ",", "isV_UNDEF", ";", "unsigned", "Imm", ",", "WhichResult", ";", "unsigned", "EltSize", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "return", "(", "EltSize", ">=", "32", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "16", ")", "||", "isVEXTMask", "(", "M", ",", "VT", ",", "ReverseVEXT", ",", "Imm", ")", "||", "isVTBLMask", "(", "M", ",", "VT", ")", "||", "isNEONTwoResultShuffleMask", "(", "M", ",", "VT", ",", "WhichResult", ",", "isV_UNDEF", ")", "||", "(", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", ")", "&&", "isReverseMask", "(", "M", ",", "VT", ")", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "ARM", "ARM", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "32", "0", "64", "32", "16", "MVT::v8i16", "MVT::v16i8" ]

[]

[ "<s>", "const", "TGSITargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "TGSI", "TGSI" ]

[]

[ "<s>", "unsigned", "MipsFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "if", "(", "!", "TargetSupported", ")", "return", "0", ";", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "(", "UnsupportedFPMode", ")", "?", "0", ":", "materializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "materializeGV", "(", "GV", ",", "VT", ")", ";", "else", "if", "(", "isa", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "materializeInt", "(", "C", ",", "VT", ")", ";", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "mips_restore_gp", "(", "void", ")", "{", "rtx", "address", ",", "slot", ";", "gcc_assert", "(", "TARGET_ABICALLS", "&&", "TARGET_OLDABI", ")", ";", "address", "=", "mips_add_offset", "(", "pic_offset_table_rtx", ",", "frame_pointer_needed", "?", "hard_frame_pointer_rtx", ":", "stack_pointer_rtx", ",", "current_function_outgoing_args_size", ")", ";", "slot", "=", "gen_rtx_MEM", "(", "Pmode", ",", "address", ")", ";", "emit_move_insn", "(", "pic_offset_table_rtx", ",", "slot", ")", ";", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Restore", "$", "gp", "from", "its", "save", "slot", ".", "Valid", "only", "when", "using", "o32", "or", "o64", "abicalls", "." ]

[ "mips" ]

[]

[ "<s>", "static", "Mfix", "*", "create_fix_barrier", "(", "Mfix", "*", "fix", ",", "HOST_WIDE_INT", "max_address", ")", "{", "HOST_WIDE_INT", "count", "=", "0", ";", "rtx_barrier", "*", "barrier", ";", "rtx_insn", "*", "from", "=", "fix", "->", "insn", ";", "rtx_insn", "*", "selected", "=", "NULL", ";", "int", "selected_cost", ";", "HOST_WIDE_INT", "selected_address", ";", "Mfix", "*", "new_fix", ";", "HOST_WIDE_INT", "max_count", "=", "max_address", "-", "fix", "->", "address", ";", "rtx_code_label", "*", "label", "=", "gen_label_rtx", "(", ")", ";", "selected_cost", "=", "arm_barrier_cost", "(", "from", ")", ";", "selected_address", "=", "fix", "->", "address", ";", "while", "(", "from", "&&", "count", "<", "max_count", ")", "{", "rtx_jump_table_data", "*", "tmp", ";", "int", "new_cost", ";", "gcc_assert", "(", "!", "BARRIER_P", "(", "from", ")", ")", ";", "if", "(", "LABEL_P", "(", "from", ")", ")", "count", "+=", "get_label_padding", "(", "from", ")", ";", "else", "count", "+=", "get_attr_length", "(", "from", ")", ";", "if", "(", "tablejump_p", "(", "from", ",", "NULL", ",", "&", "tmp", ")", ")", "{", "count", "+=", "get_jump_table_size", "(", "tmp", ")", ";", "new_cost", "=", "arm_barrier_cost", "(", "from", ")", ";", "if", "(", "count", "<", "max_count", "&&", "(", "!", "selected", "||", "new_cost", "<=", "selected_cost", ")", ")", "{", "selected", "=", "tmp", ";", "selected_cost", "=", "new_cost", ";", "selected_address", "=", "fix", "->", "address", "+", "count", ";", "}", "from", "=", "NEXT_INSN", "(", "tmp", ")", ";", "continue", ";", "}", "new_cost", "=", "arm_barrier_cost", "(", "from", ")", ";", "if", "(", "count", "<", "max_count", "&&", "(", "!", "selected", "||", "new_cost", "<=", "selected_cost", ")", ")", "{", "selected", "=", "from", ";", "selected_cost", "=", "new_cost", ";", "selected_address", "=", "fix", "->", "address", "+", "count", ";", "}", "from", "=", "NEXT_INSN", "(", "from", ")", ";", "}", "gcc_assert", "(", "selected", ")", ";", "if", "(", "CALL_P", "(", "selected", ")", ")", "{", "rtx_insn", "*", "next", "=", "NEXT_INSN", "(", "selected", ")", ";", "if", "(", "next", "&&", "NOTE_P", "(", "next", ")", "&&", "NOTE_KIND", "(", "next", ")", "==", "NOTE_INSN_CALL_ARG_LOCATION", ")", "selected", "=", "next", ";", "}", "from", "=", "emit_jump_insn_after", "(", "gen_jump", "(", "label", ")", ",", "selected", ")", ";", "JUMP_LABEL", "(", "from", ")", "=", "label", ";", "barrier", "=", "emit_barrier_after", "(", "from", ")", ";", "emit_label_after", "(", "label", ",", "barrier", ")", ";", "new_fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "new_fix", ")", ")", ";", "new_fix", "->", "insn", "=", "barrier", ";", "new_fix", "->", "address", "=", "selected_address", ";", "new_fix", "->", "next", "=", "fix", "->", "next", ";", "fix", "->", "next", "=", "new_fix", ";", "return", "new_fix", ";", "}", "</s>" ]

[ "Find", "the", "best", "place", "in", "the", "insn", "stream", "in", "the", "range", "(", "FIX-", ">", "address", ",", "MAX_ADDRESS", ")", "to", "forcibly", "insert", "a", "minipool", "barrier", ".", "Create", "the", "barrier", "by", "inserting", "a", "jump", "and", "add", "a", "new", "fix", "entry", "for", "it", "." ]

[ "arm", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI post-RA bundler\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI post-RA bundler\"" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "MI", ",", "unsigned", "*", "PredCost", ")", "const", "{", "if", "(", "!", "ItinData", "||", "UseOldLatencyCalc", ")", "return", "PPCGenInstrInfo", "::", "getInstrLatency", "(", "ItinData", ",", "MI", ",", "PredCost", ")", ";", "unsigned", "Latency", "=", "1", ";", "unsigned", "DefClass", "=", "MI", "->", "getDesc", "(", ")", ".", "getSchedClass", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", "||", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "int", "Cycle", "=", "ItinData", "->", "getOperandCycle", "(", "DefClass", ",", "i", ")", ";", "if", "(", "Cycle", "<", "0", ")", "continue", ";", "Latency", "=", "std", "::", "max", "(", "Latency", ",", "(", "unsigned", ")", "Cycle", ")", ";", "}", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "PowerPC", "PPC", "PPC", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "AArch64TTIImpl", "::", "getMaxPrefetchIterationsAhead", "(", ")", "{", "return", "ST", "->", "getMaxPrefetchIterationsAhead", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "prefetch", "distance", "in", "terms", "of", "loop", "iterations", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "StringRef", "getSymbol", "(", ")", "const", "{", "return", "S", ";", "}", "</s>" ]

[ "Get", "the", "target", "address", "and", "flags", "for", "the", "named", "symbol", "." ]

[ "CSKY" ]

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "OW", "->", "WriteZeros", "(", "Count", "%", "4", ")", ";", "Count", "/=", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "Count", ";", "++", "i", ")", "OW", "->", "write32", "(", "0xd503201f", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "4", "4", "0", "0xd503201f" ]

[]