Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "i386_pe_seh_fini", "(", "FILE", "*", "f", ",", "bool", "cold", ")", "{", "struct", "seh_frame_state", "*", "seh", ";", "if", "(", "!", "TARGET_SEH", ")", "return", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "seh", "=", "cfun", "->", "machine", "->", "seh", ";", "if", "(", "cold", "!=", "seh", "->", "in_cold_section", ")", "return", ";", "XDELETE", "(", "seh", ")", ";", "cfun", "->", "machine", "->", "seh", "=", "NULL", ";", "fputs", "(", "\"\\t.seh_endproc\\n\"", ",", "f", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assembler", "directive", "for", "the", "end", "of", "the", "function", "." ]

[ "i386", "\"\\t.seh_endproc\\n\"" ]

[]

[ "<s>", "unsigned", "int", "mips_sync_loop_insns", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "mips_branch_likely", "=", "TARGET_FIX_R10000", ";", "mips_process_sync_loop", "(", "insn", ",", "operands", ")", ";", "return", "mips_multi_num_insns", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "individual", "instructions", "in", "sync", "loop", "INSN", ",", "which", "has", "the", "operands", "given", "by", "OPERANDS", "." ]

[ "mips" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

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

[ "Worker", "function", "for", "TARGET_FUNCTION_VALUE_REGNO_P", "." ]

[ "stormy16" ]

[]

[ "<s>", "void", "HexagonEarlyIfConversion", "::", "removeBlock", "(", "MachineBasicBlock", "*", "B", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Removing block \"", "<<", "PrintMB", "(", "B", ")", "<<", "\"\\n\"", ")", ";", "MachineDomTreeNode", "*", "N", "=", "MDT", "->", "getNode", "(", "B", ")", ";", "MachineDomTreeNode", "*", "IDN", "=", "N", "->", "getIDom", "(", ")", ";", "if", "(", "IDN", ")", "{", "MachineBasicBlock", "*", "IDB", "=", "IDN", "->", "getBlock", "(", ")", ";", "typedef", "GraphTraits", "<", "MachineDomTreeNode", "*", ">", "GTN", ";", "typedef", "SmallVector", "<", "MachineDomTreeNode", "*", ",", "4", ">", "DTNodeVectType", ";", "DTNodeVectType", "Cn", "(", "GTN", "::", "child_begin", "(", "N", ")", ",", "GTN", "::", "child_end", "(", "N", ")", ")", ";", "for", "(", "DTNodeVectType", "::", "iterator", "I", "=", "Cn", ".", "begin", "(", ")", ",", "E", "=", "Cn", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "*", "SB", "=", "(", "*", "I", ")", "->", "getBlock", "(", ")", ";", "MDT", "->", "changeImmediateDominator", "(", "SB", ",", "IDB", ")", ";", "}", "}", "while", "(", "B", "->", "succ_size", "(", ")", ">", "0", ")", "B", "->", "removeSuccessor", "(", "B", "->", "succ_begin", "(", ")", ")", ";", "for", "(", "auto", "I", "=", "B", "->", "pred_begin", "(", ")", ",", "E", "=", "B", "->", "pred_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "removeSuccessor", "(", "B", ")", ";", "Deleted", ".", "insert", "(", "B", ")", ";", "MDT", "->", "eraseNode", "(", "B", ")", ";", "MFN", "->", "erase", "(", "B", "->", "getIterator", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "completely", "removes", "BB", "from", "all", "data", "structures", ",", "including", "all", "of", "the", "Loop", "objects", "it", "is", "nested", "in", "and", "our", "mapping", "from", "MachineBasicBlocks", "to", "loops", "." ]

[ "Hexagon", "Hexagon", "\"Removing block \"", "\"\\n\"", "4", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "swapOperands", "(", "MachineInstr", "&", "Inst", ")", "const", "{", "assert", "(", "Inst", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", ";", "MachineOperand", "Op1", "=", "Inst", ".", "getOperand", "(", "1", ")", ";", "Inst", ".", "RemoveOperand", "(", "1", ")", ";", "Inst", ".", "addOperand", "(", "Op1", ")", ";", "}", "</s>" ]

[ "Exchange", "the", "two", "operands", "to", "this", "instruction", "in", "such", "a", "way", "that", "it", "does", "not", "modify", "the", "semantics", "of", "the", "instruction", "." ]

[ "AMDGPU", "SI", "3", "1", "1" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "SIMachineFunctionInfo", "*", "MFI", "=", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "KillFlag", "=", "isKill", "?", "RegState", "::", "Kill", ":", "0", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TRI", "->", "getCommonSubClass", "(", "RC", ",", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ")", "{", "unsigned", "Lane", "=", "MFI", "->", "SpillTracker", ".", "reserveLanes", "(", "MRI", ",", "MBB", ".", "getParent", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_WRITELANE_B32", ")", ",", "MFI", "->", "SpillTracker", ".", "LaneVGPR", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addImm", "(", "Lane", ")", ";", "MFI", "->", "SpillTracker", ".", "addSpilledReg", "(", "FrameIndex", ",", "MFI", "->", "SpillTracker", ".", "LaneVGPR", ",", "Lane", ")", ";", "}", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "unsigned", "NumSubRegs", "=", "RC", "->", "getSize", "(", ")", "/", "4", ";", "unsigned", "FirstLane", "=", "MFI", "->", "SpillTracker", ".", "reserveLanes", "(", "MRI", ",", "MBB", ".", "getParent", "(", ")", ",", "NumSubRegs", ")", ";", "MFI", "->", "SpillTracker", ".", "addSpilledReg", "(", "FrameIndex", ",", "MFI", "->", "SpillTracker", ".", "LaneVGPR", ",", "FirstLane", ")", ";", "unsigned", "Opcode", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "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", ";", "default", ":", "llvm_unreachable", "(", "\"Cannot spill register class\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "MFI", "->", "SpillTracker", ".", "LaneVGPR", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "FrameIndex", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"VGPR spilling not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "0", "4", "8", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "\"Cannot spill register class\"", "\"VGPR spilling not supported\"" ]

[]

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

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "while", "(", "Result", "==", "Success", "&&", "!", "Complete", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "getContext", "(", ")", ".", "createMCInst", "(", ")", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "if", "(", "Size", ">", "HEXAGON_MAX_PACKET_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "auto", "ArchSTI", "=", "Hexagon_MC", "::", "getArchSubtarget", "(", "&", "STI", ")", ";", "const", "auto", "STI_", "=", "(", "ArchSTI", "!=", "nullptr", ")", "?", "*", "ArchSTI", ":", "STI", ";", "HexagonMCChecker", "Checker", "(", "getContext", "(", ")", ",", "*", "MCII", ",", "STI_", ",", "MI", ",", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "false", ")", ";", "if", "(", "!", "Checker", ".", "check", "(", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "remapInstruction", "(", "MI", ")", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "Hexagon", "Hexagon", "0", "Hexagon::BUNDLE", "0", "Hexagon", "Hexagon" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "!", "Subtarget", ".", "isUnalignedMem16Slow", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", ")", "{", "if", "(", "Size", ">=", "32", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", "{", "return", "MVT", "::", "v32i8", ";", "}", "if", "(", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v16i8", ";", "if", "(", "Subtarget", ".", "hasSSE1", "(", ")", "&&", "(", "Subtarget", ".", "is64Bit", "(", ")", "||", "Subtarget", ".", "hasX87", "(", ")", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "(", "!", "IsMemset", "||", "ZeroMemset", ")", "&&", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "32", "MVT::v32i8", "MVT::v16i8", "MVT::v4f32", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "ix86_function_arg_regno_p", "(", "int", "regno", ")", "{", "int", "i", ";", "enum", "calling_abi", "call_abi", ";", "const", "int", "*", "parm_regs", ";", "if", "(", "TARGET_MPX", "&&", "BND_REGNO_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "TARGET_MACHO", ")", "return", "(", "regno", "<", "REGPARM_MAX", "||", "(", "TARGET_SSE", "&&", "SSE_REGNO_P", "(", "regno", ")", "&&", "!", "fixed_regs", "[", "regno", "]", ")", ")", ";", "else", "return", "(", "regno", "<", "REGPARM_MAX", "||", "(", "TARGET_MMX", "&&", "MMX_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "<", "FIRST_MMX_REG", "+", "MMX_REGPARM_MAX", ")", ")", "||", "(", "TARGET_SSE", "&&", "SSE_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "<", "FIRST_SSE_REG", "+", "SSE_REGPARM_MAX", ")", ")", ")", ";", "}", "if", "(", "TARGET_SSE", "&&", "SSE_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "<", "FIRST_SSE_REG", "+", "SSE_REGPARM_MAX", ")", ")", "return", "true", ";", "call_abi", "=", "ix86_cfun_abi", "(", ")", ";", "if", "(", "call_abi", "==", "SYSV_ABI", "&&", "regno", "==", "AX_REG", ")", "return", "true", ";", "if", "(", "call_abi", "==", "MS_ABI", ")", "parm_regs", "=", "x86_64_ms_abi_int_parameter_registers", ";", "else", "parm_regs", "=", "x86_64_int_parameter_registers", ";", "for", "(", "i", "=", "0", ";", "i", "<", "(", "call_abi", "==", "MS_ABI", "?", "X86_64_MS_REGPARM_MAX", ":", "X86_64_REGPARM_MAX", ")", ";", "i", "++", ")", "if", "(", "regno", "==", "parm_regs", "[", "i", "]", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "register", "may", "be", "used", "to", "pass", "function", "parameters", "." ]

[ "i386", "0" ]

[]

[ "<s>", "static", "rtx", "arm_expand_neon_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "neon_builtin_datum", "*", "d", "=", "&", "neon_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_NEON_BASE", "]", ";", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "int", "is_void", "=", "0", ";", "int", "k", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "1", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "1", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_immediate", ")", "args", "[", "k", "]", "=", "NEON_ARG_CONSTANT", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_maybe_immediate", ")", "{", "rtx", "arg", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "(", "expr_args_k", ")", ")", ")", ";", "bool", "op_const_int_p", "=", "(", "CONST_INT_P", "(", "arg", ")", "&&", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "predicate", ")", "(", "arg", ",", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "mode", ")", ")", ";", "args", "[", "k", "]", "=", "op_const_int_p", "?", "NEON_ARG_CONSTANT", ":", "NEON_ARG_COPY_TO_REG", ";", "}", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_pointer", ")", "args", "[", "k", "]", "=", "NEON_ARG_MEMORY", ";", "else", "args", "[", "k", "]", "=", "NEON_ARG_COPY_TO_REG", ";", "}", "args", "[", "k", "]", "=", "NEON_ARG_STOP", ";", "return", "arm_expand_neon_args", "(", "target", ",", "d", "->", "mode", ",", "fcode", ",", "icode", ",", "!", "is_void", ",", "exp", ",", "args", "[", "1", "]", ",", "args", "[", "2", "]", ",", "args", "[", "3", "]", ",", "args", "[", "4", "]", ",", "NEON_ARG_STOP", ")", ";", "}", "</s>" ]

[ "Expand", "a", "Neon", "builtin", ",", "i.e", ".", "those", "registered", "only", "if", "TARGET_NEON", "holds", ".", "Most", "of", "these", "are", "``", "special", "''", "because", "they", "do", "n't", "have", "symbolic", "constants", "defined", "per-instruction", "or", "per", "instruction-variant", ".", "Instead", ",", "the", "required", "info", "is", "looked", "up", "in", "the", "table", "neon_builtin_data", "." ]

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

[]

[ "<s>", "int", "h8300_eightbit_data_p", "(", "tree", "decl", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "0", ";", "a", "=", "lookup_attribute", "(", "\"eightbit_data\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "DECL", "is", "a", "variable", "that", "'s", "in", "the", "eight", "bit", "data", "area", "." ]

[ "h8300", "0", "\"eightbit_data\"" ]

[]

[ "<s>", "int", "cris_cfun_uses_pic_table", "(", "void", ")", "{", "return", "crtl", "->", "uses_pic_offset_table", ";", "}", "</s>" ]

[ "Return", "current_function_uses_pic_offset_table", ".", "For", "use", "in", "cris.md", ",", "since", "some", "generated", "files", "do", "not", "include", "function.h", "." ]

[ "cris" ]

[]

[ "<s>", "void", "F2003fMCAsmStreamer", "::", "reset", "(", ")", "{", "LabelToEmit", ".", "clear", "(", ")", ";", "ExplicitCommentToEmit", ".", "clear", "(", ")", ";", "CommentToEmit", ".", "clear", "(", ")", ";", "Symbols", ".", "clear", "(", ")", ";", "CurrentAlignmentToValue", "=", "1", ";", "ValueBuffer", ".", "clear", "(", ")", ";", "MCStreamer", "::", "reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "F2003f", "F2003f", "1" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "llvm_unreachable", "(", "\"RelaxInstruction() unimplemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "\"RelaxInstruction() unimplemented\"" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "bool", "isARM", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "const", "ARMBaseInstrInfo", "&", "TII", ",", "int", "NumBytes", ",", "ARMCC", "::", "CondCodes", "Pred", "=", "ARMCC", "::", "AL", ",", "unsigned", "PredReg", "=", "0", ")", "{", "if", "(", "isARM", ")", "emitARMRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "SP", ",", "ARM", "::", "SP", ",", "NumBytes", ",", "Pred", ",", "PredReg", ",", "TII", ")", ";", "else", "emitT2RegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "SP", ",", "ARM", "::", "SP", ",", "NumBytes", ",", "Pred", ",", "PredReg", ",", "TII", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "ARM", "ARM", "ARM", "ARMCC::CondCodes", "ARMCC::AL", "0", "ARM", "ARM", "ARM::SP", "ARM::SP", "ARM::SP", "ARM::SP" ]

[]

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

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "OR1K" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "!", "isExpandISELEnabled", "(", "MF", ")", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function: \"", ";", "MF", ".", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "initialize", "(", "MF", ")", ";", "if", "(", "!", "collectISELInstructions", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"No ISEL instructions in this function\\n\"", ")", ";", "return", "false", ";", "}", "DumpISELInstructions", "(", ")", ";", "expandAndMergeISELs", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "\"Function: \"", "\"\\n\"", "\"No ISEL instructions in this function\\n\"" ]

[]

[ "<s>", "tree", "rs6000_builtin_reciprocal", "(", "tree", "fndecl", ")", "{", "switch", "(", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ")", "{", "case", "RS6000_BIF_XVSQRTDP", ":", "if", "(", "!", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "V2DFmode", ")", ")", "return", "NULL_TREE", ";", "return", "rs6000_builtin_decls", "[", "RS6000_BIF_RSQRT_2DF", "]", ";", "case", "RS6000_BIF_XVSQRTSP", ":", "if", "(", "!", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "V4SFmode", ")", ")", "return", "NULL_TREE", ";", "return", "rs6000_builtin_decls", "[", "RS6000_BIF_RSQRT_4SF", "]", ";", "default", ":", "return", "NULL_TREE", ";", "}", "}", "</s>" ]

[ "Returns", "a", "code", "for", "a", "target-specific", "builtin", "that", "implements", "reciprocal", "of", "the", "function", ",", "or", "NULL_TREE", "if", "not", "available", "." ]

[ "rs6000" ]

[]

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

[ "Allocate", "a", "chunk", "of", "memory", "for", "per-function", "machine-dependent", "data", "." ]

[ "iq2000" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "VE", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ve_reflong\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_srel32\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ve_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_pc_hi32\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ve_pc_lo32\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ve_got_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_got_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_gotoff_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_gotoff_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_plt_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_plt_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tls_gd_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tls_gd_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tpoff_hi32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_ve_tpoff_lo32\"", ",", "0", ",", "32", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "VE", "VE::NumTargetFixupKinds", "\"fixup_ve_reflong\"", "0", "32", "0", "\"fixup_ve_srel32\"", "0", "32", "\"fixup_ve_hi32\"", "0", "32", "0", "\"fixup_ve_lo32\"", "0", "32", "0", "\"fixup_ve_pc_hi32\"", "0", "32", "\"fixup_ve_pc_lo32\"", "0", "32", "\"fixup_ve_got_hi32\"", "0", "32", "0", "\"fixup_ve_got_lo32\"", "0", "32", "0", "\"fixup_ve_gotoff_hi32\"", "0", "32", "0", "\"fixup_ve_gotoff_lo32\"", "0", "32", "0", "\"fixup_ve_plt_hi32\"", "0", "32", "0", "\"fixup_ve_plt_lo32\"", "0", "32", "0", "\"fixup_ve_tls_gd_hi32\"", "0", "32", "0", "\"fixup_ve_tls_gd_lo32\"", "0", "32", "0", "\"fixup_ve_tpoff_hi32\"", "0", "32", "0", "\"fixup_ve_tpoff_lo32\"", "0", "32", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "bool", "avr_decl_flash_p", "(", "tree", "decl", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "||", "TREE_TYPE", "(", "decl", ")", "==", "error_mark_node", ")", "{", "return", "false", ";", "}", "return", "!", "ADDR_SPACE_GENERIC_P", "(", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "DECL", "is", "a", "VAR_DECL", "located", "in", "flash", "and", "FALSE", ",", "otherwise", "." ]

[ "avr" ]

[]

[ "<s>", "void", "DCPU16InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "DCPU16", "::", "MOV16rr", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "Dcpu16", "DCPU16", "DCPU16::MOV16rr" ]

[]

[ "<s>", "bool", "M88kCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ",", "Register", "SwiftErrorVReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "M88kSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "M88kSubtarget", ">", "(", ")", ";", "const", "M88kInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "Register", "ReturnAddrVReg", "=", "getFunctionLiveInPhysReg", "(", "MF", ",", "TII", ",", "M88k", "::", "R1", ",", "M88k", "::", "GPRRCRegClass", ",", "MIRBuilder", ".", "getDebugLoc", "(", ")", ")", ";", "MRI", ".", "setType", "(", "ReturnAddrVReg", ",", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "M88k", "::", "RET", ")", ";", "bool", "Success", "=", "true", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "ArgInfo", "OrigArg", "{", "VRegs", ",", "Val", "->", "getType", "(", ")", ",", "0", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "OutgoingValueAssigner", "ArgAssigner", "(", "RetCC_M88k", ")", ";", "OutgoingArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ")", ";", "Success", "=", "determineAndHandleAssignments", "(", "ArgHandler", ",", "ArgAssigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "}", "MIRBuilder", ".", "buildCopy", "(", "M88k", "::", "R1", ",", "ReturnAddrVReg", ")", ";", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "Success", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "M88k", "M88k", "M88k", "M88k", "M88k", "M88k::R1", "M88k::GPRRCRegClass", "0", "32", "M88k::RET", "8", "0", "M88k", "M88k::R1" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "unsigned", "Directive", "=", "Subtarget", ".", "getDarwinDirective", "(", ")", ";", "unsigned", "Opcode", ";", "switch", "(", "Directive", ")", "{", "default", ":", "Opcode", "=", "PPC", "::", "NOP", ";", "break", ";", "case", "PPC", "::", "DIR_PWR6", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR6", ";", "break", ";", "case", "PPC", "::", "DIR_PWR7", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "case", "PPC", "::", "DIR_PWR8", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "case", "PPC", "::", "DIR_PWR9", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "}", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "PowerPC", "PPC", "PPC::NOP", "PPC::DIR_PWR6", "PPC::NOP_GT_PWR6", "PPC::DIR_PWR7", "PPC::NOP_GT_PWR7", "PPC::DIR_PWR8", "PPC::NOP_GT_PWR7", "PPC::DIR_PWR9", "PPC::NOP_GT_PWR7" ]

[]

[ "<s>", "static", "rtx", "rs6000_longcall_ref", "(", "rtx", "call_ref", ",", "rtx", "arg", ")", "{", "const", "char", "*", "call_name", "=", "XSTR", "(", "call_ref", ",", "0", ")", ";", "if", "(", "*", "call_name", "==", "'.'", ")", "{", "while", "(", "*", "call_name", "==", "'.'", ")", "call_name", "++", ";", "tree", "node", "=", "get_identifier", "(", "call_name", ")", ";", "call_ref", "=", "gen_rtx_SYMBOL_REF", "(", "VOIDmode", ",", "IDENTIFIER_POINTER", "(", "node", ")", ")", ";", "}", "if", "(", "TARGET_PLTSEQ", ")", "{", "rtx", "base", "=", "const0_rtx", ";", "int", "regno", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGISTER", ")", ";", "regno", "=", "12", ";", "}", "else", "{", "if", "(", "flag_pic", ")", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ";", "regno", "=", "11", ";", "}", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "hi", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "base", ",", "call_ref", ",", "arg", ")", ",", "UNSPEC_PLT16_HA", ")", ";", "rtx", "lo", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "reg", ",", "call_ref", ",", "arg", ")", ",", "UNSPEC_PLT16_LO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "hi", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "lo", ")", ")", ";", "return", "reg", ";", "}", "return", "force_reg", "(", "Pmode", ",", "call_ref", ")", ";", "}", "</s>" ]

[ "Return", "a", "reference", "suitable", "for", "calling", "a", "function", "with", "the", "longcall", "attribute", "." ]

[ "rs6000", "0", "12", "11", "3", "3" ]

[]

[ "<s>", "DecodeStatus", "ARMDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "assert", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "ModeThumb", "]", "&&", "\"Asked to disassemble an ARM instruction but Subtarget is in Thumb \"", "\"mode!\"", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "Insn", "=", "(", "Bytes", "[", "3", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "2", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "1", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "0", "]", "<<", "0", ")", ";", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "DecoderTableARM32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "checkDecodedInstruction", "(", "MI", ",", "Size", ",", "Address", ",", "OS", ",", "CS", ",", "Insn", ",", "Result", ")", ";", "}", "struct", "DecodeTable", "{", "const", "uint8_t", "*", "P", ";", "bool", "DecodePred", ";", "}", ";", "const", "DecodeTable", "Tables", "[", "]", "=", "{", "{", "DecoderTableVFP32", ",", "false", "}", ",", "{", "DecoderTableVFPV832", ",", "false", "}", ",", "{", "DecoderTableNEONData32", ",", "true", "}", ",", "{", "DecoderTableNEONLoadStore32", ",", "true", "}", ",", "{", "DecoderTableNEONDup32", ",", "true", "}", ",", "{", "DecoderTablev8NEON32", ",", "false", "}", ",", "{", "DecoderTablev8Crypto32", ",", "false", "}", ",", "}", ";", "for", "(", "auto", "Table", ":", "Tables", ")", "{", "Result", "=", "decodeInstruction", "(", "Table", ".", "P", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "if", "(", "Table", ".", "DecodePred", "&&", "!", "DecodePredicateOperand", "(", "MI", ",", "0xE", ",", "Address", ",", "this", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "return", "Result", ";", "}", "}", "Size", "=", "4", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "ARM", "ARM", "ARM::ModeThumb", "\"Asked to disassemble an ARM instruction but Subtarget is in Thumb \"", "\"mode!\"", "4", "0", "3", "24", "2", "16", "1", "8", "0", "0", "ARM", "4", "4", "0xE", "4" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Instruction Selection\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Instruction Selection\"" ]

[]

[ "<s>", "static", "rtx", "mep_convert_arg", "(", "machine_mode", "mode", ",", "rtx", "arg", ")", "{", "if", "(", "GET_MODE", "(", "arg", ")", "!=", "mode", "&&", "register_operand", "(", "arg", ",", "VOIDmode", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "arg", ")", ")", "==", "GET_MODE_SIZE", "(", "mode", ")", ")", "return", "simplify_gen_subreg", "(", "mode", ",", "arg", ",", "GET_MODE", "(", "arg", ")", ",", "0", ")", ";", "return", "arg", ";", "}", "</s>" ]

[ "If", "ARG", "is", "a", "register", "operand", "that", "is", "the", "same", "size", "as", "MODE", ",", "convert", "it", "to", "MODE", "using", "a", "subreg", ".", "Otherwise", "return", "ARG", "as-is", "." ]

[ "mep", "0" ]

[]

[ "<s>", "bool", "aarch64_sve_ldr_operand_p", "(", "rtx", "op", ")", "{", "struct", "aarch64_address_info", "addr", ";", "return", "(", "MEM_P", "(", "op", ")", "&&", "aarch64_classify_address", "(", "&", "addr", ",", "XEXP", "(", "op", ",", "0", ")", ",", "GET_MODE", "(", "op", ")", ",", "false", ",", "ADDR_QUERY_ANY", ")", "&&", "addr", ".", "type", "==", "ADDRESS_REG_IMM", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "MEM", "operand", "for", "an", "SVE", "LDR", "instruction", ".", "The", "conditions", "for", "STR", "are", "the", "same", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "unsigned", "ReservedCPURegs", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "AT", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "GP", ",", "Mips", "::", "SP", ",", "Mips", "::", "FP", ",", "Mips", "::", "RA", "}", ";", "static", "const", "unsigned", "ReservedCPU64Regs", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "AT_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "GP_64", ",", "Mips", "::", "SP_64", ",", "Mips", "::", "FP_64", ",", "Mips", "::", "RA_64", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPU64Regs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPU64Regs", "[", "I", "]", ")", ";", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "AFGR64RegisterClass", "->", "begin", "(", ")", ";", "Reg", "!=", "Mips", "::", "AFGR64RegisterClass", "->", "end", "(", ")", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "else", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "CPU64RegsRegisterClass", "->", "begin", "(", ")", ";", "Reg", "!=", "Mips", "::", "CPU64RegsRegisterClass", "->", "end", "(", ")", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "FGR64RegisterClass", "->", "begin", "(", ")", ";", "Reg", "!=", "Mips", "::", "FGR64RegisterClass", "->", "end", "(", ")", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "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", "." ]

[ "Mips", "Mips", "Mips::ZERO", "Mips::AT", "Mips::K0", "Mips::K1", "Mips::GP", "Mips::SP", "Mips::FP", "Mips::RA", "Mips::ZERO_64", "Mips::AT_64", "Mips::K0_64", "Mips::K1_64", "Mips::GP_64", "Mips::SP_64", "Mips::FP_64", "Mips::RA_64", "0", "Mips", "0", "Mips::AFGR64RegisterClass", "Mips::AFGR64RegisterClass", "Mips::CPU64RegsRegisterClass", "Mips::CPU64RegsRegisterClass", "Mips::FGR64RegisterClass", "Mips::FGR64RegisterClass" ]

[]

[ "<s>", "static", "bool", "spu_vector_alignment_reachable", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "is_packed", ")", "{", "if", "(", "is_packed", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "iff", ",", "data", "reference", "of", "TYPE", "can", "reach", "vector", "alignment", "(", "16", ")", "after", "applying", "N", "number", "of", "iterations", ".", "This", "routine", "does", "not", "determine", "how", "may", "iterations", "are", "required", "to", "reach", "desired", "alignment", "." ]

[ "spu" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_arg", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "arg", ".", "end_marker_p", "(", ")", "||", "!", "arg", ".", "named", ")", "return", "NULL_RTX", ";", "return", "gen_reg_rtx", "(", "arg", ".", "mode", ")", ";", "}", "</s>" ]

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

[ "nvptx" ]

[]

[ "<s>", "bool", "sh2a_function_vector_p", "(", "tree", "func", ")", "{", "tree", "list", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "list", "=", "SH_ATTRIBUTES", "(", "func", ")", ";", "while", "(", "list", ")", "{", "if", "(", "is_attribute_p", "(", "\"function_vector\"", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "true", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "FUNC", "has", "been", "assigned", "the", "attribute", "``", "function_vector", "''", "." ]

[ "sh", "\"function_vector\"" ]

[]

[ "<s>", "enum", "reg_class", "arm_mode_base_reg_class", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_HAVE_MVE", "&&", "(", "mode", "==", "E_V8QImode", "||", "mode", "==", "E_V4QImode", "||", "mode", "==", "E_V4HImode", ")", ")", "return", "LO_REGS", ";", "return", "MODE_BASE_REG_REG_CLASS", "(", "mode", ")", ";", "}", "</s>" ]

[ "If", "given", "mode", "matches", ",", "load", "from", "memory", "to", "LO_REGS", ".", "(", "i.e", "[", "Rn", "]", ",", "Rn", "<", "=", "LO_REGS", ")", "." ]

[ "arm" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Shrink-wrapping not yet supported\"", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "bool", "ARMLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TL", "=", "STI", "->", "getTargetLowering", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "RS", "=", "new", "RegScavenger", "(", ")", ";", "isThumb2", "=", "AFI", "->", "isThumb2Function", "(", ")", ";", "isThumb1", "=", "AFI", "->", "isThumbFunction", "(", ")", "&&", "!", "isThumb2", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "LoadStoreMultipleOpti", "(", "MBB", ")", ";", "if", "(", "STI", "->", "hasV5TOps", "(", ")", ")", "Modified", "|=", "MergeReturnIntoLDM", "(", "MBB", ")", ";", "}", "delete", "RS", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "const", "MCObjectFileInfo", "::", "Environment", "Format", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getObjectFileType", "(", ")", ";", "bool", "IsMachO", "=", "Format", "==", "MCObjectFileInfo", "::", "IsMachO", ";", "bool", "IsCOFF", "=", "Format", "==", "MCObjectFileInfo", "::", "IsCOFF", ";", "auto", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ".", "lower", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".arch\"", ")", "parseDirectiveArch", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cpu\"", ")", "parseDirectiveCPU", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".ltorg\"", "||", "IDVal", "==", "\".pool\"", ")", "parseDirectiveLtorg", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".unreq\"", ")", "parseDirectiveUnreq", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".inst\"", ")", "parseDirectiveInst", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_negate_ra_state\"", ")", "parseDirectiveCFINegateRAState", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_b_key_frame\"", ")", "parseDirectiveCFIBKeyFrame", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".arch_extension\"", ")", "parseDirectiveArchExtension", "(", "Loc", ")", ";", "else", "if", "(", "IsMachO", ")", "{", "if", "(", "IDVal", "==", "MCLOHDirectiveName", "(", ")", ")", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "else", "return", "true", ";", "}", "else", "if", "(", "IsCOFF", ")", "{", "if", "(", "IDVal", "==", "\".seh_stackalloc\"", ")", "parseDirectiveSEHAllocStack", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_endprologue\"", ")", "parseDirectiveSEHPrologEnd", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_r19r20_x\"", ")", "parseDirectiveSEHSaveR19R20X", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_fplr\"", ")", "parseDirectiveSEHSaveFPLR", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_fplr_x\"", ")", "parseDirectiveSEHSaveFPLRX", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_reg\"", ")", "parseDirectiveSEHSaveReg", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_reg_x\"", ")", "parseDirectiveSEHSaveRegX", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_regp\"", ")", "parseDirectiveSEHSaveRegP", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_regp_x\"", ")", "parseDirectiveSEHSaveRegPX", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_lrpair\"", ")", "parseDirectiveSEHSaveLRPair", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_freg\"", ")", "parseDirectiveSEHSaveFReg", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_freg_x\"", ")", "parseDirectiveSEHSaveFRegX", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_fregp\"", ")", "parseDirectiveSEHSaveFRegP", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_fregp_x\"", ")", "parseDirectiveSEHSaveFRegPX", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_set_fp\"", ")", "parseDirectiveSEHSetFP", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_add_fp\"", ")", "parseDirectiveSEHAddFP", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_nop\"", ")", "parseDirectiveSEHNop", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_save_next\"", ")", "parseDirectiveSEHSaveNext", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_startepilogue\"", ")", "parseDirectiveSEHEpilogStart", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_endepilogue\"", ")", "parseDirectiveSEHEpilogEnd", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_trap_frame\"", ")", "parseDirectiveSEHTrapFrame", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_pushframe\"", ")", "parseDirectiveSEHMachineFrame", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_context\"", ")", "parseDirectiveSEHContext", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_clear_unwound_to_call\"", ")", "parseDirectiveSEHClearUnwoundToCall", "(", "Loc", ")", ";", "else", "return", "true", ";", "}", "else", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\".arch\"", "\".cpu\"", "\".tlsdesccall\"", "\".ltorg\"", "\".pool\"", "\".unreq\"", "\".inst\"", "\".cfi_negate_ra_state\"", "\".cfi_b_key_frame\"", "\".arch_extension\"", "\".seh_stackalloc\"", "\".seh_endprologue\"", "\".seh_save_r19r20_x\"", "\".seh_save_fplr\"", "\".seh_save_fplr_x\"", "\".seh_save_reg\"", "\".seh_save_reg_x\"", "\".seh_save_regp\"", "\".seh_save_regp_x\"", "\".seh_save_lrpair\"", "\".seh_save_freg\"", "\".seh_save_freg_x\"", "\".seh_save_fregp\"", "\".seh_save_fregp_x\"", "\".seh_set_fp\"", "\".seh_add_fp\"", "\".seh_nop\"", "\".seh_save_next\"", "\".seh_startepilogue\"", "\".seh_endepilogue\"", "\".seh_trap_frame\"", "\".seh_pushframe\"", "\".seh_context\"", "\".seh_clear_unwound_to_call\"" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "Optional", "<", "Hexagon", "::", "ArchEnum", ">", "ArchVer", "=", "Hexagon", "::", "GetCpu", "(", "Hexagon", "::", "CpuTable", ",", "CPUString", ")", ";", "if", "(", "ArchVer", ")", "HexagonArchVersion", "=", "*", "ArchVer", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseAudioOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "if", "(", "isTinyCore", "(", ")", ")", "{", "if", "(", "!", "EnableBSBSched", ".", "getPosition", "(", ")", ")", "UseBSBScheduling", "=", "false", ";", "}", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "reset", "(", "Hexagon", "::", "FeatureDuplex", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "Hexagon::GetCpu", "Hexagon::CpuTable", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

[ "<s>", "int", "arc_output_commutative_cond_exec", "(", "rtx", "*", "operands", ",", "bool", "output_p", ")", "{", "enum", "rtx_code", "commutative_op", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "const", "char", "*", "pat", "=", "NULL", ";", "gcc_assert", "(", "!", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", ")", ";", "switch", "(", "commutative_op", ")", "{", "case", "AND", ":", "if", "(", "satisfies_constraint_C1p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bmsk%? %0,%1,%Z2\"", ";", "else", "if", "(", "satisfies_constraint_C2p", "(", "operands", "[", "2", "]", ")", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "(", "~", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ")", ";", "pat", "=", "\"bmskn%? %0,%1,%Z2\"", ";", "}", "else", "if", "(", "satisfies_constraint_Ccp", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bclr%? %0,%1,%M2\"", ";", "else", "if", "(", "satisfies_constraint_CnL", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bic%? %0,%1,%n2-1\"", ";", "break", ";", "case", "IOR", ":", "if", "(", "satisfies_constraint_C0p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bset%? %0,%1,%z2\"", ";", "break", ";", "case", "XOR", ":", "if", "(", "satisfies_constraint_C0p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bxor%? %0,%1,%z2\"", ";", "break", ";", "case", "PLUS", ":", "return", "arc_output_addsi", "(", "operands", ",", "true", ",", "output_p", ")", ";", "default", ":", "break", ";", "}", "if", "(", "output_p", ")", "output_asm_insn", "(", "pat", "?", "pat", ":", "\"%O3.%d5 %0,%1,%2\"", ",", "operands", ")", ";", "if", "(", "pat", "||", "REG_P", "(", "operands", "[", "2", "]", ")", "||", "satisfies_constraint_L", "(", "operands", "[", "2", "]", ")", ")", "return", "4", ";", "return", "8", ";", "}", "</s>" ]

[ "Emit", "code", "for", "an", "commutative_cond_exec", "instruction", "with", "OPERANDS", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "." ]

[ "arc", "3", "1", "2", "\"bmsk%? %0,%1,%Z2\"", "2", "2", "2", "\"bmskn%? %0,%1,%Z2\"", "2", "\"bclr%? %0,%1,%M2\"", "2", "\"bic%? %0,%1,%n2-1\"", "2", "\"bset%? %0,%1,%z2\"", "2", "\"bxor%? %0,%1,%z2\"", "\"%O3.%d5 %0,%1,%2\"", "2", "2", "4", "8" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "zeroExtend", "(", "unsigned", "Reg", ",", "const", "Value", "*", "V", ",", "MVT", "::", "SimpleValueType", "From", ",", "MVT", "::", "SimpleValueType", "To", ")", "{", "if", "(", "To", "==", "MVT", "::", "i64", ")", "{", "if", "(", "From", "==", "MVT", "::", "i64", ")", "return", "copyValue", "(", "Reg", ")", ";", "Reg", "=", "zeroExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "Register", "Result", "=", "createResultReg", "(", "&", "WebAssembly", "::", "I64RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "WebAssembly", "::", "I64_EXTEND_U_I32", ")", ",", "Result", ")", ".", "addReg", "(", "Reg", ")", ";", "return", "Result", ";", "}", "if", "(", "To", "==", "MVT", "::", "i32", ")", "return", "zeroExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "a", "new", "range", "in", "the", "specified", "integer", "type", ",", "which", "must", "be", "strictly", "larger", "than", "the", "current", "type", "." ]

[ "WebAssembly", "WebAssembly", "MVT::SimpleValueType", "MVT::SimpleValueType", "MVT::i64", "MVT::i64", "WebAssembly::I64RegClass", "WebAssembly::I64_EXTEND_U_I32", "MVT::i32", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM pre- register allocation load / store optimization pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM pre- register allocation load / store optimization pass\"" ]

[]

[ "<s>", "int", "sh_loop_align", "(", "rtx", "label", ")", "{", "rtx", "next", "=", "label", ";", "do", "next", "=", "next_nonnote_insn", "(", "next", ")", ";", "while", "(", "next", "&&", "GET_CODE", "(", "next", ")", "==", "CODE_LABEL", ")", ";", "if", "(", "!", "next", "||", "!", "INSN_P", "(", "next", ")", "||", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "==", "ADDR_DIFF_VEC", "||", "recog_memoized", "(", "next", ")", "==", "CODE_FOR_consttable_2", ")", "return", "0", ";", "return", "align_loops_log", ";", "}", "</s>" ]

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

[ "sh", "0" ]

[]

[ "<s>", "static", "int", "tilegx_multiply_get_num_ops", "(", "const", "struct", "tilegx_multiply_insn_seq", "*", "seq", ")", "{", "int", "i", ";", "for", "(", "i", "=", "tilegx_multiply_insn_seq_MAX_OPERATIONS", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "tilegx_multiply_get_opcode", "(", "&", "seq", "->", "op", "[", "i", "]", ")", "!=", "CODE_FOR_nothing", ")", "return", "i", "+", "1", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "length", "of", "the", "'op", "'", "array", "." ]

[ "tilegx", "1", "0", "1" ]

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "SparcFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isV9", "(", ")", "||", "!", "Subtarget", ".", "hasHardQuad", "(", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STQFri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcEvenReg", "=", "getSubReg", "(", "SrcReg", ",", "SP", "::", "sub_even64", ")", ";", "unsigned", "SrcOddReg", "=", "getSubReg", "(", "SrcReg", ",", "SP", "::", "sub_odd64", ")", ";", "MachineInstr", "*", "StMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcEvenReg", ")", ";", "replaceFI", "(", "MF", ",", "*", "StMI", ",", "*", "StMI", ",", "dl", ",", "0", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "SP", "::", "STDFri", ")", ")", ";", "MI", ".", "getOperand", "(", "2", ")", ".", "setReg", "(", "SrcOddReg", ")", ";", "Offset", "+=", "8", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "LDQFri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "DestEvenReg", "=", "getSubReg", "(", "DestReg", ",", "SP", "::", "sub_even64", ")", ";", "unsigned", "DestOddReg", "=", "getSubReg", "(", "DestReg", ",", "SP", "::", "sub_odd64", ")", ";", "MachineInstr", "*", "LdMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestEvenReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ";", "replaceFI", "(", "MF", ",", "*", "LdMI", ",", "*", "LdMI", ",", "dl", ",", "1", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "SP", "::", "LDDFri", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestOddReg", ")", ";", "Offset", "+=", "8", ";", "}", "}", "replaceFI", "(", "MF", ",", "II", ",", "MI", ",", "dl", ",", "FIOperandNum", ",", "Offset", ",", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP", "SP", "0", "\"Unexpected\"", "Sparc", "Sparc", "Sparc", "1", "SP::STQFri", "2", "SP::sub_even64", "SP::sub_odd64", "SP::STDFri", "0", "0", "SP::STDFri", "2", "8", "SP::LDQFri", "0", "SP::sub_even64", "SP::sub_odd64", "SP::LDDFri", "0", "1", "SP::LDDFri", "0", "8" ]

[]

[ "<s>", "void", "PIC16AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "128" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Encode Literals\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Encode Literals\"" ]

[]

[ "<s>", "SDNode", "*", "MipsDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "NULL", ";", "}", "std", "::", "pair", "<", "bool", ",", "SDNode", "*", ">", "Ret", "=", "selectNode", "(", "Node", ")", ";", "if", "(", "Ret", ".", "first", ")", "return", "Ret", ".", "second", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "assert", "(", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", "<=", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getAlignment", "(", ")", "&&", "\"Unexpected unaligned loads/stores.\"", ")", ";", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Mips", "Mips", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::GLOBAL_OFFSET_TABLE", "ISD::LOAD", "ISD::STORE", "8", "\"Unexpected unaligned loads/stores.\"", "\"=> \"", "\"\\n\"" ]

[]

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

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

[ "AVR", "AVR" ]

[]

[ "<s>", "unsigned", "X86TTIImpl", "::", "getScalarizationOverhead", "(", "Type", "*", "Ty", ",", "bool", "Insert", ",", "bool", "Extract", ")", "{", "assert", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "\"Can only scalarize vectors\"", ")", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Ty", "->", "getVectorNumElements", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "Insert", ")", "Cost", "+=", "getVectorInstrCost", "(", "Instruction", "::", "InsertElement", ",", "Ty", ",", "i", ")", ";", "if", "(", "Extract", ")", "Cost", "+=", "getVectorInstrCost", "(", "Instruction", "::", "ExtractElement", ",", "Ty", ",", "i", ")", ";", "}", "return", "Cost", ";", "}", "</s>" ]

[ "Estimate", "the", "overhead", "of", "scalarizing", "an", "instruction", "." ]

[ "X86", "X86", "\"Can only scalarize vectors\"", "0", "0" ]

[]

[ "<s>", "const", "CallLowering", "*", "M68kSubtarget", "::", "getCallLowering", "(", ")", "const", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "bool", "rs6000_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "type", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "FLOAT128_IEEE_P", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 IEEE 128-bit\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "int_size_in_bytes", "(", "type", ")", "<", "0", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: variable size\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: AltiVec\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_pass_big_vectors", "=", "false", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: synthetic vector\\n\"", ")", ";", "if", "(", "!", "warned_for_pass_big_vectors", ")", "{", "warning", "(", "0", ",", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", ")", ";", "warned_for_pass_big_vectors", "=", "true", ";", "}", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "A", "C", "expression", "that", "indicates", "when", "an", "argument", "must", "be", "passed", "by", "reference", ".", "If", "nonzero", "for", "an", "argument", ",", "a", "copy", "of", "that", "argument", "is", "made", "in", "memory", "and", "a", "pointer", "to", "the", "argument", "is", "passed", "instead", "of", "the", "argument", "itself", ".", "The", "pointer", "is", "passed", "in", "whatever", "way", "is", "appropriate", "for", "passing", "a", "pointer", "to", "that", "type", ".", "Under", "V.4", ",", "aggregates", "and", "long", "double", "are", "passed", "by", "reference", ".", "As", "an", "extension", "to", "all", "32-bit", "ABIs", ",", "AltiVec", "vectors", "are", "passed", "by", "reference", "unless", "the", "AltiVec", "vector", "extension", "ABI", "is", "in", "force", ".", "As", "an", "extension", "to", "all", "ABIs", ",", "variable", "sized", "types", "are", "passed", "by", "reference", "." ]

[ "rs6000", "0", "\"function_arg_pass_by_reference: V4 IEEE 128-bit\\n\"", "1", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", "1", "0", "\"function_arg_pass_by_reference: variable size\\n\"", "1", "\"function_arg_pass_by_reference: AltiVec\\n\"", "1", "16", "8", "\"function_arg_pass_by_reference: synthetic vector\\n\"", "0", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", "1", "0" ]

[]

[ "<s>", "virtual", "const", "WDC65816RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "WDC65816", "WDC" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isMOVLMask", "(", "M", ",", "VT", ")", "||", "isSHUFPMask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasAVX", "(", ")", ")", "||", "isPSHUFDMask", "(", "M", ",", "VT", ")", "||", "isPSHUFHWMask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasAVX2", "(", ")", ")", "||", "isPSHUFLWMask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasAVX2", "(", ")", ")", "||", "isPALIGNRMask", "(", "M", ",", "VT", ",", "Subtarget", ")", "||", "isUNPCKLMask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasAVX2", "(", ")", ")", "||", "isUNPCKHMask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasAVX2", "(", ")", ")", "||", "isUNPCKL_v_undef_Mask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasAVX2", "(", ")", ")", "||", "isUNPCKH_v_undef_Mask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasAVX2", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "64", "2", "0" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SAVErr", ",", "SAVEri", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "regFP", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I6", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "regFP", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "nullptr", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "unsigned", "regInRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I7", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "O7", ",", "true", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "nullptr", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "Sparc", "SP", "SP::I6", "SP::I7", "SP::O7" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "recombine_lvx_stvx_patterns", "(", "function", "*", "fun", ")", "{", "int", "i", ";", "basic_block", "bb", ";", "rtx_insn", "*", "insn", ";", "int", "num_insns", "=", "get_max_uid", "(", ")", ";", "del_info", "*", "to_delete", "=", "XCNEWVEC", "(", "del_info", ",", "num_insns", ")", ";", "FOR_ALL_BB_FN", "(", "bb", ",", "fun", ")", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "insn_is_load_p", "(", "insn", ")", "&&", "insn_is_swap_p", "(", "insn", ")", ")", "recombine_lvx_pattern", "(", "insn", ",", "to_delete", ")", ";", "else", "if", "(", "insn_is_store_p", "(", "insn", ")", "&&", "insn_is_swap_p", "(", "insn", ")", ")", "recombine_stvx_pattern", "(", "insn", ",", "to_delete", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "num_insns", ";", "i", "++", ")", "if", "(", "to_delete", "[", "i", "]", ".", "replace", ")", "{", "rtx", "swap_body", "=", "PATTERN", "(", "to_delete", "[", "i", "]", ".", "replace_insn", ")", ";", "rtx", "src_reg", "=", "XEXP", "(", "SET_SRC", "(", "swap_body", ")", ",", "0", ")", ";", "rtx", "copy", "=", "gen_rtx_SET", "(", "SET_DEST", "(", "swap_body", ")", ",", "src_reg", ")", ";", "rtx_insn", "*", "new_insn", "=", "emit_insn_before", "(", "copy", ",", "to_delete", "[", "i", "]", ".", "replace_insn", ")", ";", "set_block_for_insn", "(", "new_insn", ",", "BLOCK_FOR_INSN", "(", "to_delete", "[", "i", "]", ".", "replace_insn", ")", ")", ";", "df_insn_rescan", "(", "new_insn", ")", ";", "df_insn_delete", "(", "to_delete", "[", "i", "]", ".", "replace_insn", ")", ";", "remove_insn", "(", "to_delete", "[", "i", "]", ".", "replace_insn", ")", ";", "to_delete", "[", "i", "]", ".", "replace_insn", "->", "set_deleted", "(", ")", ";", "}", "free", "(", "to_delete", ")", ";", "}", "</s>" ]

[ "Look", "for", "patterns", "created", "from", "builtin", "lvx", "and", "stvx", "calls", ",", "and", "canonicalize", "them", "to", "be", "properly", "recognized", "as", "such", "." ]

[ "rs6000", "0", "0" ]

[]

[ "<s>", "static", "int", "riscv_flatten_aggregate_argument", "(", "const_tree", "type", ",", "riscv_aggregate_field", "fields", "[", "2", "]", ",", "bool", "ignore_zero_width_bit_field_p", ")", "{", "if", "(", "!", "type", "||", "TREE_CODE", "(", "type", ")", "!=", "RECORD_TYPE", ")", "return", "-", "1", ";", "return", "riscv_flatten_aggregate_field", "(", "type", ",", "fields", ",", "0", ",", "0", ",", "ignore_zero_width_bit_field_p", ")", ";", "}", "</s>" ]

[ "Identify", "candidate", "aggregates", "for", "passing", "in", "floating-point", "registers", ".", "Candidates", "have", "at", "most", "two", "fields", "after", "flattening", "." ]

[ "riscv", "2", "1", "0", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Chain", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDValue", "TCChain", "=", "Chain", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "return", "false", ";", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "X86ISD", "::", "RET_FLAG", ")", "return", "false", ";", "if", "(", "UI", "->", "getNumOperands", "(", ")", ">", "4", ")", "return", "false", ";", "if", "(", "UI", "->", "getNumOperands", "(", ")", "==", "4", "&&", "UI", "->", "getOperand", "(", "UI", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "!=", "MVT", "::", "Glue", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "if", "(", "!", "HasRet", ")", "return", "false", ";", "Chain", "=", "TCChain", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "0", "ISD::FP_EXTEND", "X86ISD::RET_FLAG", "4", "4", "1", "MVT::Glue" ]

[]

[ "<s>", "int", "IA64RegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "assert", "(", "0", "&&", "\"What is the dwarf register number\"", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

[ "IA64", "IA64", "0", "\"What is the dwarf register number\"", "1" ]

[]

[ "<s>", "static", "enum", "flt_eval_method", "aarch64_excess_precision", "(", "enum", "excess_precision_type", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "EXCESS_PRECISION_TYPE_FAST", ":", "case", "EXCESS_PRECISION_TYPE_STANDARD", ":", "return", "(", "TARGET_FP_F16INST", "?", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16", ":", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ")", ";", "case", "EXCESS_PRECISION_TYPE_IMPLICIT", ":", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "FLT_EVAL_METHOD_UNPREDICTABLE", ";", "}", "</s>" ]

[ "Set", "the", "value", "of", "FLT_EVAL_METHOD", ".", "ISO/IEC", "TS", "18661-3", "defines", "two", "values", "that", "we", "'d", "like", "to", "make", "use", "of", ":", "0", ":", "evaluate", "all", "operations", "and", "constants", ",", "whose", "semantic", "type", "has", "at", "most", "the", "range", "and", "precision", "of", "type", "float", ",", "to", "the", "range", "and", "precision", "of", "float", ";", "evaluate", "all", "other", "operations", "and", "constants", "to", "the", "range", "and", "precision", "of", "the", "semantic", "type", ";", "N", ",", "where", "_FloatN", "is", "a", "supported", "interchange", "floating", "type", "evaluate", "all", "operations", "and", "constants", ",", "whose", "semantic", "type", "has", "at", "most", "the", "range", "and", "precision", "of", "_FloatN", "type", ",", "to", "the", "range", "and", "precision", "of", "the", "_FloatN", "type", ";", "evaluate", "all", "other", "operations", "and", "constants", "to", "the", "range", "and", "precision", "of", "the", "semantic", "type", ";", "If", "we", "have", "the", "ARMv8.2-A", "extensions", "then", "we", "support", "_Float16", "in", "native", "precision", ",", "so", "we", "should", "set", "this", "to", "16", ".", "Otherwise", ",", "we", "support", "the", "type", ",", "but", "want", "to", "evaluate", "expressions", "in", "float", "precision", ",", "so", "set", "this", "to", "0", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "isSafeToMoveRegClassDefs", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "isSafeToMoveRegClassDefs", "-", "Return", "true", "if", "it", "'s", "safe", "to", "move", "a", "machine", "instruction", "that", "defines", "the", "specified", "register", "class", "." ]

[ "R600" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "static", "void", "avr_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "if", "(", "TREE_CODE", "(", "node", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "node", ")", "||", "DECL_EXTERNAL", "(", "node", ")", ")", "&&", "avr_progmem_p", "(", "node", ",", "*", "attributes", ")", ")", "{", "static", "const", "char", "dsec", "[", "]", "=", "\".progmem.data\"", ";", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"section\"", ")", ",", "build_tree_list", "(", "NULL", ",", "build_string", "(", "strlen", "(", "dsec", ")", ",", "dsec", ")", ")", ",", "*", "attributes", ")", ";", "TREE_READONLY", "(", "node", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Add", "the", "section", "attribute", "if", "the", "variable", "is", "in", "progmem", "." ]

[ "avr", "\".progmem.data\"", "\"section\"", "1" ]

[]

[ "<s>", "const", "Function", "&", "getFunction", "(", ")", "const", "{", "return", "Fn", ";", "}", "</s>" ]

[ "getFunction", "-", "Return", "this", "trace", "'s", "parent", "function", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "XNCMPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createXNCMISelDag", "(", "getXNCMTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "XNCM", "XNCM" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "AI", ")", ")", "return", "0", ";", "MVT", "VT", ";", "if", "(", "!", "isLoadTypeLegal", "(", "AI", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2ADDri", ":", "ARM", "::", "ADDri", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "ResultReg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ",", "0", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "0", ")", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "0", "ARM::t2ADDri", "ARM::ADDri", "0", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM Execution Domain Fix\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM Execution Domain Fix\"" ]

[]

[ "<s>", "int", "SparcRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "assert", "(", "0", "&&", "\"What is the dwarf register number\"", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

[ "Sparc", "Sparc", "0", "\"What is the dwarf register number\"", "1" ]

[]

[ "<s>", "static", "bool", "reg_offset_addressing_ok_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "case", "E_V1TImode", ":", "case", "E_TImode", ":", "case", "E_TFmode", ":", "case", "E_KFmode", ":", "if", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", ")", "return", "mode_supports_dq_form", "(", "mode", ")", ";", "break", ";", "case", "E_OOmode", ":", "case", "E_XOmode", ":", "return", "TARGET_MMA", ";", "case", "E_SDmode", ":", "if", "(", "TARGET_NO_SDMODE_STACK", ")", "return", "false", ";", "break", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Subroutines", "of", "rs6000_legitimize_address", "and", "rs6000_legitimate_address_p", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "HexagonGenInsert", "::", "isConstant", "(", "unsigned", "VR", ")", "const", "{", "const", "BitTracker", "::", "RegisterCell", "&", "RC", "=", "CMS", "->", "lookup", "(", "VR", ")", ";", "uint16_t", "W", "=", "RC", ".", "width", "(", ")", ";", "for", "(", "uint16_t", "i", "=", "0", ";", "i", "<", "W", ";", "++", "i", ")", "{", "const", "BitTracker", "::", "BitValue", "&", "BV", "=", "RC", "[", "i", "]", ";", "if", "(", "BV", ".", "is", "(", "0", ")", "||", "BV", ".", "is", "(", "1", ")", ")", "continue", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "we", "know", "the", "value", "of", "all", "bits", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_report_sve_required", "(", "void", ")", "{", "static", "bool", "reported_p", "=", "false", ";", "if", "(", "reported_p", ")", "return", ";", "error", "(", "\"this operation requires the SVE ISA extension\"", ")", ";", "inform", "(", "input_location", ",", "\"you can enable SVE using the command-line\"", "\" option %<-march%>, or by using the %<target%>\"", "\" attribute or pragma\"", ")", ";", "reported_p", "=", "true", ";", "}", "</s>" ]

[ "Report", "when", "we", "try", "to", "do", "something", "that", "requires", "SVE", "when", "SVE", "is", "disabled", ".", "This", "is", "an", "error", "of", "last", "resort", "and", "is", "n't", "very", "high-quality", ".", "It", "usually", "involves", "attempts", "to", "measure", "the", "vector", "length", "in", "some", "way", "." ]

[ "aarch64", "\"this operation requires the SVE ISA extension\"", "\"you can enable SVE using the command-line\"", "\" option %<-march%>, or by using the %<target%>\"", "\" attribute or pragma\"" ]

[]

[ "<s>", "BitVector", "SPURegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "SPU", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "SPU", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "SPU", "::", "R2", ")", ";", "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", "." ]

[ "CellSPU", "SPU", "SPU::R0", "SPU::R1", "SPU::R2" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "hasHighOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "const", "MachineInstr", "*", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "*", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "switch", "(", "DefMI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "DIVSDrm", ":", "case", "X86", "::", "DIVSDrm_Int", ":", "case", "X86", "::", "DIVSDrr", ":", "case", "X86", "::", "DIVSDrr_Int", ":", "case", "X86", "::", "DIVSSrm", ":", "case", "X86", "::", "DIVSSrm_Int", ":", "case", "X86", "::", "DIVSSrr", ":", "case", "X86", "::", "DIVSSrr_Int", ":", "case", "X86", "::", "SQRTPDm", ":", "case", "X86", "::", "SQRTPDm_Int", ":", "case", "X86", "::", "SQRTPDr", ":", "case", "X86", "::", "SQRTPDr_Int", ":", "case", "X86", "::", "SQRTPSm", ":", "case", "X86", "::", "SQRTPSm_Int", ":", "case", "X86", "::", "SQRTPSr", ":", "case", "X86", "::", "SQRTPSr_Int", ":", "case", "X86", "::", "SQRTSDm", ":", "case", "X86", "::", "SQRTSDm_Int", ":", "case", "X86", "::", "SQRTSDr", ":", "case", "X86", "::", "SQRTSDr_Int", ":", "case", "X86", "::", "SQRTSSm", ":", "case", "X86", "::", "SQRTSSm_Int", ":", "case", "X86", "::", "SQRTSSr", ":", "case", "X86", "::", "SQRTSSr_Int", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Compute", "operand", "latency", "between", "a", "def", "of", "'Reg", "'", "and", "a", "use", "in", "the", "current", "loop", "." ]

[ "X86", "X86", "X86::DIVSDrm", "X86::DIVSDrm_Int", "X86::DIVSDrr", "X86::DIVSDrr_Int", "X86::DIVSSrm", "X86::DIVSSrm_Int", "X86::DIVSSrr", "X86::DIVSSrr_Int", "X86::SQRTPDm", "X86::SQRTPDm_Int", "X86::SQRTPDr", "X86::SQRTPDr_Int", "X86::SQRTPSm", "X86::SQRTPSm_Int", "X86::SQRTPSr", "X86::SQRTPSr_Int", "X86::SQRTSDm", "X86::SQRTSDm_Int", "X86::SQRTSDr", "X86::SQRTSDr_Int", "X86::SQRTSSm", "X86::SQRTSSm_Int", "X86::SQRTSSr", "X86::SQRTSSr_Int" ]

[]

[ "<s>", "static", "void", "parse_mtune_ctrl_str", "(", "bool", "dump", ")", "{", "if", "(", "!", "ix86_tune_ctrl_string", ")", "return", ";", "char", "*", "next_feature_string", "=", "NULL", ";", "char", "*", "curr_feature_string", "=", "xstrdup", "(", "ix86_tune_ctrl_string", ")", ";", "char", "*", "orig", "=", "curr_feature_string", ";", "int", "i", ";", "do", "{", "bool", "clear", "=", "false", ";", "next_feature_string", "=", "strchr", "(", "curr_feature_string", ",", "','", ")", ";", "if", "(", "next_feature_string", ")", "*", "next_feature_string", "++", "=", "'\\0'", ";", "if", "(", "*", "curr_feature_string", "==", "'^'", ")", "{", "curr_feature_string", "++", ";", "clear", "=", "true", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "X86_TUNE_LAST", ";", "i", "++", ")", "{", "if", "(", "!", "strcmp", "(", "curr_feature_string", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ")", "{", "ix86_tune_features", "[", "i", "]", "=", "!", "clear", ";", "if", "(", "dump", ")", "fprintf", "(", "stderr", ",", "\"Explicitly %s feature %s\\n\"", ",", "clear", "?", "\"clear\"", ":", "\"set\"", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ";", "break", ";", "}", "}", "if", "(", "i", "==", "X86_TUNE_LAST", ")", "error", "(", "\"unknown parameter to option -mtune-ctrl: %s\"", ",", "clear", "?", "curr_feature_string", "-", "1", ":", "curr_feature_string", ")", ";", "curr_feature_string", "=", "next_feature_string", ";", "}", "while", "(", "curr_feature_string", ")", ";", "free", "(", "orig", ")", ";", "}", "</s>" ]

[ "parse", "-mtune-ctrl=", "option", ".", "When", "DUMP", "is", "true", ",", "print", "the", "features", "that", "are", "explicitly", "set", "." ]

[ "i386", "0", "\"Explicitly %s feature %s\\n\"", "\"clear\"", "\"set\"", "\"unknown parameter to option -mtune-ctrl: %s\"", "1" ]

[]

[ "<s>", "static", "void", "s390_reg_clobbered_rtx", "(", "rtx", "setreg", ",", "const_rtx", "set_insn", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "char", "*", "regs_ever_clobbered", "=", "(", "char", "*", ")", "data", ";", "unsigned", "int", "i", ",", "regno", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "setreg", ")", ";", "if", "(", "GET_CODE", "(", "setreg", ")", "==", "SUBREG", ")", "{", "rtx", "inner", "=", "SUBREG_REG", "(", "setreg", ")", ";", "if", "(", "!", "GENERAL_REG_P", "(", "inner", ")", "&&", "!", "FP_REG_P", "(", "inner", ")", ")", "return", ";", "regno", "=", "subreg_regno", "(", "setreg", ")", ";", "}", "else", "if", "(", "GENERAL_REG_P", "(", "setreg", ")", "||", "FP_REG_P", "(", "setreg", ")", ")", "regno", "=", "REGNO", "(", "setreg", ")", ";", "else", "return", ";", "for", "(", "i", "=", "regno", ";", "i", "<", "end_hard_regno", "(", "mode", ",", "regno", ")", ";", "i", "++", ")", "regs_ever_clobbered", "[", "i", "]", "=", "1", ";", "}", "</s>" ]

[ "Helper", "function", "for", "s390_regs_ever_clobbered", ".", "Sets", "the", "fields", "in", "DATA", "for", "all", "clobbered", "hard", "regs", "in", "SETREG", "." ]

[ "s390", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TM", "=", "static_cast", "<", "const", "PPCTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "TII", "=", "TM", "->", "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", "bool", "or1k_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "FLAG_REGS", ")", "return", "mode", "==", "BImode", ";", "return", "true", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_HARD_REGNO_MODE_OK", ".", "Returns", "true", "if", "the", "hard", "register", "REGNO", "is", "ok", "for", "storing", "values", "of", "mode", "MODE", "." ]

[ "or1k" ]

[]

[ "<s>", "ArrayRef", "<", "uint64_t", ">", "getReferencedAddresses", "(", ")", "const", "override", "{", "return", "ReferencedAddresses", ";", "}", "</s>" ]

[ "Get", "the", "MCSymbolizer", "'s", "list", "of", "addresses", "that", "were", "referenced", "by", "symbolizable", "operands", "but", "not", "resolved", "to", "a", "symbol", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AMDGPUCFGStructurizer", "::", "prepare", "(", ")", "{", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"AMDGPUCFGStructurizer::prepare\\n\"", ";", ")", ";", "orderBlocks", "(", "FuncRep", ")", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "DEFAULT_VEC_SLOTS", ">", "RetBlks", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "It", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineLoop", "*", "LoopRep", "=", "(", "*", "It", ")", ";", "MBBVector", "ExitingMBBs", ";", "LoopRep", "->", "getExitingBlocks", "(", "ExitingMBBs", ")", ";", "if", "(", "ExitingMBBs", ".", "size", "(", ")", "==", "0", ")", "{", "MachineBasicBlock", "*", "DummyExitBlk", "=", "normalizeInfiniteLoopExit", "(", "LoopRep", ")", ";", "if", "(", "DummyExitBlk", ")", "RetBlks", ".", "push_back", "(", "DummyExitBlk", ")", ";", "}", "}", "for", "(", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "::", "const_iterator", "It", "=", "OrderedBlks", ".", "begin", "(", ")", ",", "E", "=", "OrderedBlks", ".", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "*", "It", ";", "removeUnconditionalBranch", "(", "MBB", ")", ";", "removeRedundantConditionalBranch", "(", "MBB", ")", ";", "if", "(", "isReturnBlock", "(", "MBB", ")", ")", "{", "RetBlks", ".", "push_back", "(", "MBB", ")", ";", "}", "assert", "(", "MBB", "->", "succ_size", "(", ")", "<=", "2", ")", ";", "}", "if", "(", "RetBlks", ".", "size", "(", ")", ">=", "2", ")", "{", "addDummyExitBlock", "(", "RetBlks", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "R600", "\"AMDGPUCFGStructurizer::prepare\\n\"", "0", "2", "2" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "TII", "->", "get", "(", "Opcode", ")", ".", "mayStore", "(", ")", "&&", "!", "TII", "->", "isGather4", "(", "Opcode", ")", ")", "{", "return", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "}", "if", "(", "Opcode", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Opcode", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "V_DIV_SCALE_F32", ":", "case", "AMDGPU", "::", "V_DIV_SCALE_F64", ":", "{", "SDValue", "Src0", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Src1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Src2", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "if", "(", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "&&", "(", "Src0", "==", "Src1", "||", "Src0", "==", "Src2", ")", ")", "break", ";", "MVT", "VT", "=", "Src0", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "VT", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "UndefReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ",", "VT", ")", ";", "SDValue", "ImpDef", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "UndefReg", ",", "Src0", ",", "SDValue", "(", ")", ")", ";", "if", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "if", "(", "Src1", ".", "isMachineOpcode", "(", ")", "&&", "Src1", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src1", ";", "else", "if", "(", "Src2", ".", "isMachineOpcode", "(", ")", "&&", "Src2", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src2", ";", "else", "{", "assert", "(", "Src1", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", ";", "Src0", "=", "UndefReg", ";", "Src1", "=", "UndefReg", ";", "}", "}", "else", "break", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "Ops", "=", "{", "Src0", ",", "Src1", ",", "Src2", "}", ";", "for", "(", "unsigned", "I", "=", "3", ",", "N", "=", "Node", "->", "getNumOperands", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "I", ")", ")", ";", "Ops", ".", "push_back", "(", "ImpDef", ".", "getValue", "(", "1", ")", ")", ";", "return", "DAG", ".", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "Node", ")", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ")", ";", "}", "default", ":", "break", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE", "AMDGPU::V_DIV_SCALE_F32", "AMDGPU::V_DIV_SCALE_F64", "0", "1", "2", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "4", "3", "1" ]

[]

[ "<s>", "virtual", "unsigned", "getJumpTableEncoding", "(", ")", "const", "{", "return", "MachineJumpTableInfo", "::", "EK_Custom32", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "bool", "is_load_p", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_itanium_class", "insn_class", "=", "ia64_safe_itanium_class", "(", "insn", ")", ";", "return", "(", "(", "insn_class", "==", "ITANIUM_CLASS_LD", "||", "insn_class", "==", "ITANIUM_CLASS_FLD", ")", "&&", "get_attr_check_load", "(", "insn", ")", "==", "CHECK_LOAD_NO", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "INSN", "is", "a", "load", "(", "either", "normal", "or", "speculative", ",", "but", "not", "a", "speculation", "check", ")", ",", "FALSE", "otherwise", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "void", "write_ovld_static_init", "(", "void", ")", "{", "fprintf", "(", "init_file", ",", "\"ovldrecord rs6000_overload_info[RS6000_OVLD_MAX \"", "\"- RS6000_OVLD_NONE] =\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" { /* RS6000_OVLD_NONE: */\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" \\\"\\\", NULL\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" },\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "curr_ovld_stanza", ";", "i", "++", ")", "{", "fprintf", "(", "init_file", ",", "\" { /* RS6000_OVLD_%s: */\\n\"", ",", "ovld_stanzas", "[", "i", "]", ".", "stanza_id", ")", ";", "fprintf", "(", "init_file", ",", "\" /* ovld_name */\\t\\\"%s\\\",\\n\"", ",", "ovld_stanzas", "[", "i", "]", ".", "intern_name", ")", ";", "fprintf", "(", "init_file", ",", "\" /* first_instance */\\tNULL\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" },\\n\"", ")", ";", "}", "fprintf", "(", "init_file", ",", "\" };\\n\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"ovlddata rs6000_instance_info[RS6000_INST_MAX] =\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" { /* RS6000_INST_NONE: */\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" \\\"\\\", RS6000_BIF_NONE, NULL_TREE, NULL\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" },\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "curr_ovld", ";", "i", "++", ")", "{", "fprintf", "(", "init_file", ",", "\" { /* RS6000_INST_%s: */\\n\"", ",", "ovlds", "[", "i", "]", ".", "ovld_id_name", ")", ";", "fprintf", "(", "init_file", ",", "\" /* bifname */\\t\\\"%s\\\",\\n\"", ",", "ovlds", "[", "i", "]", ".", "proto", ".", "bifname", ")", ";", "fprintf", "(", "init_file", ",", "\" /* bifid */\\tRS6000_BIF_%s,\\n\"", ",", "ovlds", "[", "i", "]", ".", "bif_id_name", ")", ";", "fprintf", "(", "init_file", ",", "\" /* fntype */\\t0,\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" /* next */\\t\"", ")", ";", "if", "(", "i", "<", "curr_ovld", "&&", "!", "strcmp", "(", "ovlds", "[", "i", "+", "1", "]", ".", "proto", ".", "bifname", ",", "ovlds", "[", "i", "]", ".", "proto", ".", "bifname", ")", ")", "fprintf", "(", "init_file", ",", "\"&rs6000_instance_info[RS6000_INST_%s]\\n\"", ",", "ovlds", "[", "i", "+", "1", "]", ".", "ovld_id_name", ")", ";", "else", "fprintf", "(", "init_file", ",", "\"NULL\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" },\\n\"", ")", ";", "}", "fprintf", "(", "init_file", ",", "\" };\\n\\n\"", ")", ";", "}", "</s>" ]

[ "Write", "the", "decls", "and", "initializers", "for", "rs6000_overload_info", "[", "]", "and", "rs6000_instance_info", "[", "]", "." ]

[ "rs6000", "\"ovldrecord rs6000_overload_info[RS6000_OVLD_MAX \"", "\"- RS6000_OVLD_NONE] =\\n\"", "\" {\\n\"", "\" { /* RS6000_OVLD_NONE: */\\n\"", "\" \\\"\\\", NULL\\n\"", "\" },\\n\"", "0", "\" { /* RS6000_OVLD_%s: */\\n\"", "\" /* ovld_name */\\t\\\"%s\\\",\\n\"", "\" /* first_instance */\\tNULL\\n\"", "\" },\\n\"", "\" };\\n\\n\"", "\"ovlddata rs6000_instance_info[RS6000_INST_MAX] =\\n\"", "\" {\\n\"", "\" { /* RS6000_INST_NONE: */\\n\"", "\" \\\"\\\", RS6000_BIF_NONE, NULL_TREE, NULL\\n\"", "\" },\\n\"", "0", "\" { /* RS6000_INST_%s: */\\n\"", "\" /* bifname */\\t\\\"%s\\\",\\n\"", "\" /* bifid */\\tRS6000_BIF_%s,\\n\"", "\" /* fntype */\\t0,\\n\"", "\" /* next */\\t\"", "1", "\"&rs6000_instance_info[RS6000_INST_%s]\\n\"", "1", "\"NULL\\n\"", "\" },\\n\"", "\" };\\n\\n\"" ]

[]

[ "<s>", "Register", "X86TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "Register", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"esp\"", ",", "X86", "::", "ESP", ")", ".", "Case", "(", "\"rsp\"", ",", "X86", "::", "RSP", ")", ".", "Case", "(", "\"ebp\"", ",", "X86", "::", "EBP", ")", ".", "Case", "(", "\"rbp\"", ",", "X86", "::", "RBP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", "==", "X86", "::", "EBP", "||", "Reg", "==", "X86", "::", "RBP", ")", "{", "if", "(", "!", "TFI", ".", "hasFP", "(", "MF", ")", ")", "report_fatal_error", "(", "\"register \"", "+", "StringRef", "(", "RegName", ")", "+", "\" is allocatable: function has no frame pointer\"", ")", ";", "else", "{", "const", "X86RegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "Register", "FrameReg", "=", "RegInfo", "->", "getPtrSizedFrameRegister", "(", "MF", ")", ";", "assert", "(", "(", "FrameReg", "==", "X86", "::", "EBP", "||", "FrameReg", "==", "X86", "::", "RBP", ")", "&&", "\"Invalid Frame Register!\"", ")", ";", "}", "}", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "X86", "X86", "\"esp\"", "X86::ESP", "\"rsp\"", "X86::RSP", "\"ebp\"", "X86::EBP", "\"rbp\"", "X86::RBP", "0", "X86::EBP", "X86::RBP", "\"register \"", "\" is allocatable: function has no frame pointer\"", "X86", "X86::EBP", "X86::RBP", "\"Invalid Frame Register!\"", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "bool", "ix86_vec_interleave_v2df_operator_ok", "(", "rtx", "operands", "[", "3", "]", ",", "bool", "high", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "return", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "+", "high", "]", ")", ";", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "MEM_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "the", "operands", "to", "a", "vec_interleave_", "{", "high", ",", "low", "}", "v2df", "are", "ok", ",", "keeping", "in", "mind", "the", "possible", "movddup", "alternative", "." ]

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

[]

[ "<s>", "void", "cris_expand_return", "(", "bool", "on_stack", ")", "{", "emit_jump_insn", "(", "gen_rtx_RETURN", "(", "VOIDmode", ")", ")", ";", "CRIS_ASSERT", "(", "cfun", "->", "machine", "->", "return_type", "!=", "CRIS_RETINSN_RET", "||", "!", "on_stack", ")", ";", "CRIS_ASSERT", "(", "cfun", "->", "machine", "->", "return_type", "!=", "CRIS_RETINSN_JUMP", "||", "on_stack", ")", ";", "cfun", "->", "machine", "->", "return_type", "=", "on_stack", "?", "CRIS_RETINSN_JUMP", ":", "CRIS_RETINSN_RET", ";", "}", "</s>" ]

[ "Expand", "a", "return", "insn", "(", "just", "one", "insn", ")", "marked", "as", "using", "SRP", "or", "stack", "slot", "depending", "on", "parameter", "ON_STACK", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "alpha_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "if", "(", "mode", "==", "DImode", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "8", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", "return", "true", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "LINKAGE_SYMBOL_REF_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "!", "strict", "&&", "NONSTRICT_REG_OK_FP_BASE_P", "(", "x", ")", "&&", "GET_CODE", "(", "ofs", ")", "==", "CONST_INT", ")", "return", "true", ";", "if", "(", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", "&&", "CONSTANT_ADDRESS_P", "(", "ofs", ")", ")", "return", "true", ";", "}", "}", "else", "if", "(", "TARGET_EXPLICIT_RELOCS", ")", "{", "if", "(", "small_symbolic_operand", "(", "x", ",", "Pmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "!", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", ")", "return", "false", ";", "if", "(", "local_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "dtp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "tp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "legitimate_address_p", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "For", "Alpha", ",", "we", "have", "either", "a", "constant", "address", "or", "the", "sum", "of", "a", "register", "and", "a", "constant", "address", ",", "or", "just", "a", "register", ".", "For", "DImode", ",", "any", "of", "those", "forms", "can", "be", "surrounded", "with", "an", "AND", "that", "clear", "the", "low-order", "three", "bits", ";", "this", "is", "an", "``", "unaligned", "''", "access", "." ]

[ "alpha", "1", "1", "8", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "getTgtMemIntrinsic", "(", "IntrinsicInst", "*", "Inst", ",", "MemIntrinsicInfo", "&", "Info", ")", "{", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvw4x", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvd2x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvw4x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvl", ":", "case", "Intrinsic", "::", "ppc_vsx_lxvll", ":", "case", "Intrinsic", "::", "ppc_mma_lxvp", ":", "{", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "0", ")", ";", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "false", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "ppc_altivec_stvx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvw4x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvw4x_be", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvl", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvll", ":", "case", "Intrinsic", "::", "ppc_mma_stxvp", ":", "{", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "1", ")", ";", "Info", ".", "ReadMem", "=", "false", ";", "Info", ".", "WriteMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "Intrinsic::ppc_altivec_lvx", "Intrinsic::ppc_altivec_lvxl", "Intrinsic::ppc_altivec_lvebx", "Intrinsic::ppc_altivec_lvehx", "Intrinsic::ppc_altivec_lvewx", "Intrinsic::ppc_vsx_lxvd2x", "Intrinsic::ppc_vsx_lxvw4x", "Intrinsic::ppc_vsx_lxvd2x_be", "Intrinsic::ppc_vsx_lxvw4x_be", "Intrinsic::ppc_vsx_lxvl", "Intrinsic::ppc_vsx_lxvll", "Intrinsic::ppc_mma_lxvp", "0", "Intrinsic::ppc_altivec_stvx", "Intrinsic::ppc_altivec_stvxl", "Intrinsic::ppc_altivec_stvebx", "Intrinsic::ppc_altivec_stvehx", "Intrinsic::ppc_altivec_stvewx", "Intrinsic::ppc_vsx_stxvd2x", "Intrinsic::ppc_vsx_stxvw4x", "Intrinsic::ppc_vsx_stxvd2x_be", "Intrinsic::ppc_vsx_stxvw4x_be", "Intrinsic::ppc_vsx_stxvl", "Intrinsic::ppc_vsx_stxvll", "Intrinsic::ppc_mma_stxvp", "1" ]

[]

[ "<s>", "bool", "mem_operand_gpr", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", ";", "int", "extra", ";", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "op", "=", "address_offset", "(", "addr", ")", ";", "if", "(", "op", "==", "NULL_RTX", ")", "return", "true", ";", "offset", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "offset", "&", "3", ")", "!=", "0", ")", "return", "false", ";", "extra", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ";", "if", "(", "extra", "<", "0", ")", "extra", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "offset", "=", "(", "(", "offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "return", "offset", "+", "0x8000", "<", "0x10000u", "-", "extra", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "MEM", "operand", "is", "a", "memory", "operand", "suitable", "for", "use", "with", "a", "(", "full", "width", ",", "possibly", "multiple", ")", "gpr", "load/store", ".", "On", "powerpc64", "this", "means", "the", "offset", "must", "be", "divisible", "by", "4", ".", "Implements", "'", "Y", "'", "constraint", ".", "Accept", "direct", ",", "indexed", ",", "offset", ",", "lo_sum", "and", "tocref", ".", "Since", "this", "is", "a", "constraint", "function", "we", "know", "the", "operand", "has", "satisfied", "a", "suitable", "memory", "predicate", ".", "Offsetting", "a", "lo_sum", "should", "not", "be", "allowed", ",", "except", "where", "we", "know", "by", "alignment", "that", "a", "32k", "boundary", "is", "not", "crossed", ".", "Note", "that", "by", "``", "offsetting", "''", "here", "we", "mean", "a", "further", "offset", "to", "access", "parts", "of", "the", "MEM", ".", "It", "'s", "fine", "to", "have", "a", "lo_sum", "where", "the", "inner", "address", "is", "offset", "from", "a", "sym", ",", "since", "the", "same", "sym+offset", "will", "appear", "in", "the", "high", "part", "of", "the", "address", "calculation", "." ]

[ "powerpcspe", "0", "3", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0x8000", "0x10000u" ]

[]

[ "<s>", "static", "ARMCC", "::", "CondCodes", "getPredicate", "(", "const", "MachineInstr", "*", "MI", ",", "const", "Thumb2InstrInfo", "*", "TII", ")", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "tBcc", "||", "Opc", "==", "ARM", "::", "t2Bcc", ")", "return", "ARMCC", "::", "AL", ";", "return", "TII", "->", "getPredicate", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "the", "comparison", "predicate", "underlying", "the", "intrinsic", "." ]

[ "ARM", "ARMCC::CondCodes", "ARM::tBcc", "ARM::t2Bcc", "ARMCC::AL" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "Count", ";", "++", "i", ")", "OW", "->", "Write8", "(", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "0", "0" ]

[]

[ "<s>", "bool", "splitFramePushPop", "(", ")", "const", "{", "return", "isTargetMachO", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "frame", "setup", "is", "split", "into", "two", "separate", "pushes", "(", "first", "r0-r7", ",", "lr", "then", "r8-r11", ")", ",", "principally", "so", "that", "the", "frame", "pointer", "is", "adjacent", "to", "lr", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "cfiDefCfaOffset", "(", "nullptr", ",", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", ".", "getFrameIdx", "(", ")", ")", ";", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "bool", "is64", "=", "getPointerSize", "(", ")", "==", "8", ";", "return", "createPPCMachObjectWriter", "(", "OS", ",", "is64", ",", "(", "is64", "?", "MachO", "::", "CPU_TYPE_POWERPC64", ":", "MachO", "::", "CPU_TYPE_POWERPC", ")", ",", "MachO", "::", "CPU_SUBTYPE_POWERPC_ALL", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

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

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

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

[]

[ "<s>", "const", "LegalizerInfo", "*", "PPCSubtarget", "::", "getLegalizerInfo", "(", ")", "const", "{", "return", "Legalizer", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "void", "vr4130_align_insns", "(", "void", ")", "{", "struct", "mips_sim", "state", ";", "rtx", "insn", ",", "subinsn", ",", "last", ",", "last2", ",", "next", ";", "bool", "aligned_p", ";", "dfa_start", "(", ")", ";", "last", "=", "0", ";", "last2", "=", "0", ";", "aligned_p", "=", "true", ";", "mips_sim_init", "(", "&", "state", ",", "alloca", "(", "state_size", "(", ")", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "0", ";", "insn", "=", "next", ")", "{", "unsigned", "int", "length", ";", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "vr4130_avoid_branch_rt_conflict", "(", "insn", ")", ";", "if", "(", "USEFUL_INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBINSN", "(", "subinsn", ",", "insn", ")", "{", "mips_sim_wait_insn", "(", "&", "state", ",", "subinsn", ")", ";", "if", "(", "state", ".", "insns_left", "!=", "state", ".", "issue_rate", "&&", "!", "CALL_P", "(", "subinsn", ")", ")", "{", "if", "(", "subinsn", "==", "SEQ_BEGIN", "(", "insn", ")", "&&", "aligned_p", ")", "{", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last2", ")", ";", "aligned_p", "=", "false", ";", "}", "else", "if", "(", "subinsn", "!=", "SEQ_BEGIN", "(", "insn", ")", "&&", "!", "aligned_p", ")", "{", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last", ")", ";", "aligned_p", "=", "true", ";", "}", "}", "mips_sim_issue_insn", "(", "&", "state", ",", "subinsn", ")", ";", "}", "mips_sim_finish_insn", "(", "&", "state", ",", "insn", ")", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", ">", "0", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "SEQ_BEGIN", "(", "insn", ")", ")", "&&", "(", "recog_memoized", "(", "insn", ")", "<", "0", "||", "length", ">=", "8", ")", ")", "{", "next", "=", "emit_insn_after", "(", "gen_align", "(", "GEN_INT", "(", "3", ")", ")", ",", "insn", ")", ";", "next", "=", "NEXT_INSN", "(", "next", ")", ";", "mips_sim_next_cycle", "(", "&", "state", ")", ";", "aligned_p", "=", "true", ";", "}", "else", "if", "(", "length", "&", "4", ")", "aligned_p", "=", "!", "aligned_p", ";", "last2", "=", "last", ";", "last", "=", "insn", ";", "}", "if", "(", "LABEL_P", "(", "insn", ")", "&&", "label_to_alignment", "(", "insn", ")", ">=", "3", ")", "aligned_p", "=", "true", ";", "}", "dfa_finish", "(", ")", ";", "}", "</s>" ]

[ "Implement", "-mvr4130-align", ".", "Go", "through", "each", "basic", "block", "and", "simulate", "the", "processor", "pipeline", ".", "If", "we", "find", "that", "a", "pair", "of", "instructions", "could", "execute", "in", "parallel", ",", "and", "the", "first", "of", "those", "instruction", "is", "not", "8-byte", "aligned", ",", "insert", "a", "nop", "to", "make", "it", "aligned", "." ]

[ "mips", "0", "0", "0", "0", "0", "8", "3", "4", "3" ]

[]