Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "rtx", "rs6000_emit_stack_reset", "(", "rs6000_stack_t", "*", "info", ",", "rtx", "frame_reg_rtx", ",", "HOST_WIDE_INT", "frame_off", ",", "unsigned", "updt_regno", ")", "{", "rtx", "updt_reg_rtx", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "(", "TARGET_SPE_ABI", "&&", "info", "->", "spe_64bit_regs_used", "!=", "0", "&&", "info", "->", "first_gp_reg_save", "!=", "32", ")", ")", "rs6000_emit_stack_tie", "(", "frame_reg_rtx", ",", "frame_pointer_needed", ")", ";", "updt_reg_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "updt_regno", ")", ";", "if", "(", "frame_off", "!=", "0", ")", "return", "emit_insn", "(", "gen_add3_insn", "(", "updt_reg_rtx", ",", "frame_reg_rtx", ",", "GEN_INT", "(", "frame_off", ")", ")", ")", ";", "else", "if", "(", "REGNO", "(", "frame_reg_rtx", ")", "!=", "updt_regno", ")", "return", "emit_move_insn", "(", "updt_reg_rtx", ",", "frame_reg_rtx", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Emit", "a", "sequence", "of", "insns", ",", "including", "a", "stack", "tie", "if", "needed", ",", "for", "resetting", "the", "stack", "pointer", ".", "If", "UPDT_REGNO", "is", "not", "1", ",", "then", "do", "n't", "reset", "the", "stack", "pointer", ",", "but", "move", "the", "base", "of", "the", "frame", "into", "reg", "UPDT_REGNO", "for", "use", "by", "out-of-line", "register", "restore", "routines", "." ]

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

[]

[ "<s>", "static", "int", "shmedia_target_regs_stack_adjust", "(", "HARD_REG_SET", "*", "live_regs_mask", ")", "{", "if", "(", "shmedia_space_reserved_for_target_registers", ")", "return", "shmedia_target_regs_stack_space", "(", "live_regs_mask", ")", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Decide", "how", "much", "space", "to", "reserve", "for", "callee-save", "target", "registers", "in", "case", "target", "register", "allocation", "wants", "to", "use", "them", ".", "LIVE_REGS_MASK", "is", "the", "register", "mask", "calculated", "by", "calc_live_regs", "." ]

[ "sh", "0" ]

[]

[ "<s>", "bool", "Z80oldInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Z80old", "::", "LD8r0", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "Z80old", "Z80old", "Z80old::LD8r0" ]

[]

[ "<s>", "int", "frv_frame_pointer_required", "(", "void", ")", "{", "if", "(", "!", "TARGET_LINKED_FP", ")", "return", "!", "current_function_sp_is_unchanging", ";", "if", "(", "!", "current_function_is_leaf", ")", "return", "TRUE", ";", "if", "(", "get_frame_size", "(", ")", "!=", "0", ")", "return", "TRUE", ";", "if", "(", "cfun", "->", "stdarg", ")", "return", "TRUE", ";", "if", "(", "!", "current_function_sp_is_unchanging", ")", "return", "TRUE", ";", "if", "(", "!", "TARGET_FDPIC", "&&", "flag_pic", "&&", "cfun", "->", "uses_pic_offset_table", ")", "return", "TRUE", ";", "if", "(", "profile_flag", ")", "return", "TRUE", ";", "if", "(", "cfun", "->", "machine", "->", "frame_needed", ")", "return", "TRUE", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "On", "frv", ",", "create", "a", "frame", "whenever", "we", "need", "to", "create", "stack", "." ]

[ "frv", "0" ]

[]

[ "<s>", "FastISel", "*", "X86TargetLowering", "::", "createFastISel", "(", "MachineFunction", "&", "mf", ",", "MachineModuleInfo", "*", "mmo", ",", "DwarfWriter", "*", "dw", ",", "DenseMap", "<", "const", "Value", "*", ",", "unsigned", ">", "&", "vm", ",", "DenseMap", "<", "const", "BasicBlock", "*", ",", "MachineBasicBlock", "*", ">", "&", "bm", ",", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "&", "am", ",", "SmallSet", "<", "Instruction", "*", ",", "8", ">", "&", "cil", ")", "{", "return", "X86", "::", "createFastISel", "(", "mf", ",", "mmo", ",", "dw", ",", "vm", ",", "bm", ",", "am", ",", "cil", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "X86", "X86", "8", "X86::createFastISel" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "Register", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "Register", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "MBBI", "->", "isTerminator", "(", ")", ")", "MBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "std", "::", "prev", "(", "MBBI", ")", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "--", "MBBI", ";", "}", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MF", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "auto", "LastFrameDestroy", "=", "MBBI", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", "+", "RVFI", "->", "getRVVPadding", "(", ")", ";", "uint64_t", "RealStackSize", "=", "StackSize", "+", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "uint64_t", "FPOffset", "=", "RealStackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "uint64_t", "RVVStackSize", "=", "RVFI", "->", "getRVVStackSize", "(", ")", ";", "if", "(", "RI", "->", "hasStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "FPOffset", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "else", "{", "if", "(", "RVVStackSize", ")", "adjustStackForRVV", "(", "MF", ",", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "RVVStackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "FirstSPAdjustAmount", ")", "{", "uint64_t", "SecondSPAdjustAmount", "=", "MFI", ".", "getStackSize", "(", ")", "-", "FirstSPAdjustAmount", ";", "assert", "(", "SecondSPAdjustAmount", ">", "0", "&&", "\"SecondSPAdjustAmount should be greater than zero\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "SecondSPAdjustAmount", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "FirstSPAdjustAmount", ")", "StackSize", "=", "FirstSPAdjustAmount", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "emitSCSEpilogue", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "\"frame pointer should not have been eliminated\"", "0", "\"SecondSPAdjustAmount should be greater than zero\"" ]

[]

[ "<s>", "bool", "SIDebuggerInsertNops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "debuggerInsertNops", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", ")", "return", "false", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DenseSet", "<", "unsigned", ">", "NopInserted", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", "||", "!", "MI", "->", "getDebugLoc", "(", ")", ")", "continue", ";", "auto", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NopInserted", ".", "find", "(", "DL", ".", "getLine", "(", ")", ")", "==", "NopInserted", ".", "end", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "*", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_NOP", ")", ")", ".", "addImm", "(", "0", ")", ";", "NopInserted", ".", "insert", "(", "DL", ".", "getLine", "(", ")", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "SI", "SI", "AMDGPU::S_NOP", "0" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'a'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isReg", "(", ")", ")", "{", "O", "<<", "\"[\"", "<<", "ARMInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "case", "'c'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "O", "<<", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'P'", ":", "case", "'q'", ":", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'H'", ":", "report_fatal_error", "(", "\"llvm does not support 'Q', 'R', and 'H' modifiers!\"", ")", ";", "return", "true", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "1", "0", "0", "\"[\"", "ARM", "\"]\"", "\"llvm does not support 'Q', 'R', and 'H' modifiers!\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_PCS_RegMask", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

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

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

[ "CSKY" ]

[]

[ "<s>", "bool", "check_if_valid_regno_const", "(", "rtx", "*", "operands", ",", "int", "opno", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "opno", "]", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "CONST_INT", ":", "return", "true", ";", "default", ":", "error", "(", "\"register number must be a compile-time constant. \"", "\"Try giving higher optimization levels\"", ")", ";", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "operands", "[", "opno", "]", "is", "a", "valid", "compile-time", "constant", "to", "be", "used", "as", "register", "number", "in", "the", "code", "for", "builtins", ".", "Else", "it", "flags", "an", "error", "and", "returns", "false", "." ]

[ "arc", "\"register number must be a compile-time constant. \"", "\"Try giving higher optimization levels\"" ]

[]

[ "<s>", "static", "void", "output_return_instrumentation", "(", "void", ")", "{", "if", "(", "ix86_instrument_return", "!=", "instrument_return_none", "&&", "flag_fentry", "&&", "!", "DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT", "(", "cfun", "->", "decl", ")", ")", "{", "if", "(", "ix86_flag_record_return", ")", "fprintf", "(", "asm_out_file", ",", "\"1:\\n\"", ")", ";", "switch", "(", "ix86_instrument_return", ")", "{", "case", "instrument_return_call", ":", "fprintf", "(", "asm_out_file", ",", "\"\\tcall\\t__return__\\n\"", ")", ";", "break", ";", "case", "instrument_return_nop5", ":", "fprintf", "(", "asm_out_file", ",", "ASM_BYTE", "\"0x0f, 0x1f, 0x44, 0x00, 0x00\\n\"", ")", ";", "break", ";", "case", "instrument_return_none", ":", "break", ";", "}", "if", "(", "ix86_flag_record_return", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.section __return_loc, \\\"a\\\",@progbits\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.%s 1b\\n\"", ",", "TARGET_64BIT", "?", "\"quad\"", ":", "\"long\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.previous\\n\"", ")", ";", "}", "}", "}", "</s>" ]

[ "Output", "return", "instrumentation", "for", "current", "function", "if", "needed", "." ]

[ "i386", "\"1:\\n\"", "\"\\tcall\\t__return__\\n\"", "\"0x0f, 0x1f, 0x44, 0x00, 0x00\\n\"", "\"\\t.section __return_loc, \\\"a\\\",@progbits\\n\"", "\"\\t.%s 1b\\n\"", "\"quad\"", "\"long\"", "\"\\t.previous\\n\"" ]

[]

[ "<s>", "static", "bool", "sh_cannot_modify_jumps_p", "(", ")", "{", "return", "(", "TARGET_SHMEDIA", "&&", "(", "reload_in_progress", "||", "reload_completed", ")", ")", ";", "}", "</s>" ]

[ "SHmedia", "requires", "registers", "for", "branches", ",", "so", "we", "ca", "n't", "generate", "new", "branches", "past", "reload", "." ]

[ "sh" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Immed", ")", "const", "{", "if", "(", "Immed", "<", "0", ")", "Immed", "*=", "-", "1", ";", "return", "isLegalAddImmediate", "(", "Immed", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "0", "1" ]

[]

[ "<s>", "unsigned", "AVRMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isDFPImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "bit_cast", "<", "double", ">", "(", "MO", ".", "getDFPImm", "(", ")", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "enableAggressiveFMAFusion", "(", "LLT", "Ty", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "always", "benefits", "from", "combining", "into", "FMA", "for", "a", "given", "value", "type", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "StringRef", "NamedImmMapper", "::", "toString", "(", "uint32_t", "Value", ",", "bool", "&", "Valid", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumPairs", ";", "++", "i", ")", "{", "if", "(", "Pairs", "[", "i", "]", ".", "Value", "==", "Value", ")", "{", "Valid", "=", "true", ";", "return", "Pairs", "[", "i", "]", ".", "Name", ";", "}", "}", "Valid", "=", "false", ";", "return", "StringRef", "(", ")", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "AArch64", "0" ]

[]

[ "<s>", "FastISel", "*", "X86", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ")", "{", "return", "new", "X86FastISel", "(", "funcInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "X86", "X86::createFastISel", "X86" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "canUseAsPrologue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "*", "TmpMBB", "=", "const_cast", "<", "MachineBasicBlock", "*", ">", "(", "&", "MBB", ")", ";", "return", "findScratchRegister", "(", "TmpMBB", ",", "false", ",", "nullptr", ")", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "prologue", "for", "the", "target", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "emitFill", "(", "const", "MCExpr", "&", "NumBytes", ",", "uint64_t", "FillValue", ",", "SMLoc", "Loc", ")", "override", "{", "EmitDataMappingSymbol", "(", ")", ";", "MCObjectStreamer", "::", "emitFill", "(", "NumBytes", ",", "FillValue", ",", "Loc", ")", ";", "}", "</s>" ]

[ "Emit", "Size", "bytes", "worth", "of", "the", "value", "specified", "by", "FillValue", "." ]

[ "AArch64" ]

[]

[ "<s>", "unsigned", "AArch64RegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "A", ",", "const", "RegisterBank", "&", "B", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MOSAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "unsigned", "ModuleEFlags", "=", "0", ";", "for", "(", "const", "Function", "&", "F", ":", "M", ")", "{", "const", "MOSSubtarget", "&", "STI", "=", "static_cast", "<", "const", "MOSSubtarget", "&", ">", "(", "*", "TM", ".", "getSubtargetImpl", "(", "F", ")", ")", ";", "const", "unsigned", "EFlags", "=", "STI", ".", "getEFlags", "(", ")", ";", "if", "(", "!", "MOS", "::", "checkEFlagsCompatibility", "(", "EFlags", ",", "ModuleEFlags", ")", ")", "{", "F", ".", "getContext", "(", ")", ".", "emitError", "(", "\"Function '\"", "+", "F", ".", "getName", "(", ")", "+", "\"' uses bad MOS \"", "\"feature combination from rest of module.\\n\"", "\"Function: \"", "+", "MOS", "::", "makeEFlagsString", "(", "EFlags", ")", "+", "\"Module: \"", "+", "MOS", "::", "makeEFlagsString", "(", "ModuleEFlags", ")", ")", ";", "report_fatal_error", "(", "\"Bad MOS feature combination\"", ")", ";", "}", "ModuleEFlags", "|=", "EFlags", ";", "}", "bool", "SaveFlag", "=", "OutStreamer", "->", "getUseAssemblerInfoForParsing", "(", ")", ";", "OutStreamer", "->", "setUseAssemblerInfoForParsing", "(", "true", ")", ";", "MCAssembler", "*", "Assembler", "=", "OutStreamer", "->", "getAssemblerPtr", "(", ")", ";", "OutStreamer", "->", "setUseAssemblerInfoForParsing", "(", "SaveFlag", ")", ";", "if", "(", "Assembler", ")", "Assembler", "->", "setELFHeaderEFlags", "(", "ModuleEFlags", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "MOS", "MOS", "0", "MOS", "MOS", "MOS::checkEFlagsCompatibility", "\"Function '\"", "\"' uses bad MOS \"", "\"feature combination from rest of module.\\n\"", "\"Function: \"", "MOS::makeEFlagsString", "\"Module: \"", "MOS::makeEFlagsString", "\"Bad MOS feature combination\"" ]

[]

[ "<s>", "bool", "SITypeRewriter", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "Attribute", "A", "=", "F", ".", "getFnAttribute", "(", "\"ShaderType\"", ")", ";", "unsigned", "ShaderType", "=", "ShaderType", "::", "COMPUTE", ";", "if", "(", "A", ".", "isStringAttribute", "(", ")", ")", "{", "StringRef", "Str", "=", "A", ".", "getValueAsString", "(", ")", ";", "Str", ".", "getAsInteger", "(", "0", ",", "ShaderType", ")", ";", "}", "if", "(", "ShaderType", "==", "ShaderType", "::", "COMPUTE", ")", "return", "false", ";", "visit", "(", "F", ")", ";", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"ShaderType\"", "0" ]

[]

[ "<s>", "unsigned", "SHUXIInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "SHUXI", "::", "JMP", "&&", "I", "->", "getOpcode", "(", ")", "!=", "SHUXI", "::", "JCC", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "\"code size not handled\"", "0", "SHUXI::JMP", "SHUXI::JCC" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "X86", "::", "ENDBR64", "||", "Opcode", "==", "X86", "::", "ENDBR32", "||", "Opcode", "==", "X86", "::", "LDTILECFG", ")", "return", "true", ";", "return", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "X86", "X86", "X86::ENDBR64", "X86::ENDBR32", "X86::LDTILECFG" ]

[]

[ "<s>", "SDValue", "DLXTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "DLX", "DLX" ]

[]

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

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

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

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "PPCTargetMachine", "&", "TM", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "TargetTriple", "(", "TT", ")", ",", "IsPPC64", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64", "||", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", ")", ",", "TM", "(", "TM", ")", ",", "FrameLowering", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "TSInfo", "(", "TM", ".", "getDataLayout", "(", ")", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "CSKYAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "OS", "<<", "\"(\"", "<<", "CSKYInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\", 0)\"", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"(\"", "CSKY", "\", 0)\"" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveAArch64CodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "}", "if", "(", "this", "->", "Options", ".", "TLSSize", "==", "0", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "||", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Kernel", ")", "&&", "this", "->", "Options", ".", "TLSSize", ">", "32", ")", "this", "->", "Options", ".", "TLSSize", "=", "32", ";", "else", "if", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Tiny", "&&", "this", "->", "Options", ".", "TLSSize", ">", "24", ")", "this", "->", "Options", ".", "TLSSize", "=", "24", ";", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", "&&", "TT", ".", "getArch", "(", ")", "!=", "Triple", "::", "aarch64_32", "&&", "!", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", ")", "{", "setGlobalISel", "(", "true", ")", ";", "setGlobalISelAbort", "(", "GlobalISelAbortMode", "::", "Disable", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "true", ")", ";", "setSupportsDebugEntryValues", "(", "true", ")", ";", "}", "</s>" ]

[ "Create", "an", "AArch64", "architecture", "model", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "0", "24", "32", "32", "24", "24" ]

[]

[ "<s>", "int", "zero_and_one", "(", "rtx", "operand1", ",", "rtx", "operand2", ")", "{", "return", "GET_CODE", "(", "operand1", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "operand2", ")", "==", "CONST_INT", "&&", "(", "(", "(", "INTVAL", "(", "operand1", ")", "==", "0", ")", "&&", "(", "INTVAL", "(", "operand2", ")", "==", "1", ")", ")", "||", "(", "(", "INTVAL", "(", "operand1", ")", "==", "1", ")", "&&", "(", "INTVAL", "(", "operand2", ")", "==", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "operands", "are", "the", "constants", "0", "and", "1", "." ]

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

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "Reg", "==", "FramePtr", "&&", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectIndexBegin", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Delay Slot Killer\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Delay Slot Killer\"" ]

[]

[ "<s>", "static", "int", "ix86_reloc_rw_mask", "(", "void", ")", "{", "return", "(", "flag_pic", "||", "!", "ix86_direct_extern_access", ")", "?", "3", ":", "0", ";", "}", "</s>" ]

[ "If", "flag_pic", "or", "ix86_direct_extern_access", "is", "false", ",", "then", "neither", "local", "nor", "global", "relocs", "should", "be", "placed", "in", "readonly", "memory", "." ]

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

[]

[ "<s>", "void", "emitTagType", "(", "const", "MCSymbolWasm", "*", ")", "override", "{", "}", "</s>" ]

[ ".tagtype" ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "const", "char", "*", "s390_invalid_arg_for_unprototyped_fn", "(", "const_tree", "typelist", ",", "const_tree", "funcdecl", ",", "const_tree", "val", ")", "{", "return", "(", "(", "TARGET_VX_ABI", "&&", "typelist", "==", "0", "&&", "VECTOR_TYPE_P", "(", "TREE_TYPE", "(", "val", ")", ")", "&&", "(", "funcdecl", "==", "NULL_TREE", "||", "(", "TREE_CODE", "(", "funcdecl", ")", "==", "FUNCTION_DECL", "&&", "DECL_BUILT_IN_CLASS", "(", "funcdecl", ")", "!=", "BUILT_IN_MD", ")", ")", ")", "?", "N_", "(", "\"vector argument passed to unprototyped function\"", ")", ":", "NULL", ")", ";", "}", "</s>" ]

[ "The", "VX", "ABI", "differs", "for", "vararg", "functions", ".", "Therefore", "we", "need", "the", "prototype", "of", "the", "callee", "to", "be", "available", "when", "passing", "vector", "type", "values", "." ]

[ "s390", "0", "\"vector argument passed to unprototyped function\"" ]

[]

[ "<s>", "static", "rtx", "sh_struct_value_rtx", "(", "tree", "fndecl", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_HITACHI", "||", "sh_attr_renesas_p", "(", "fndecl", ")", ")", "return", "0", ";", "return", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ";", "}", "</s>" ]

[ "The", "Renesas", "calling", "convention", "does", "n't", "quite", "fit", "into", "this", "scheme", "since", "the", "address", "is", "passed", "like", "an", "invisible", "argument", ",", "but", "one", "that", "is", "always", "passed", "in", "memory", "." ]

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

[]

[ "<s>", "static", "rtx_insn", "*", "alphaev4_next_group", "(", "rtx_insn", "*", "insn", ",", "int", "*", "pin_use", ",", "int", "*", "plen", ")", "{", "int", "len", ",", "in_use", ";", "len", "=", "in_use", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "goto", "next_and_done", ";", "while", "(", "1", ")", "{", "enum", "alphaev4_pipe", "pipe", ";", "pipe", "=", "alphaev4_insn_pipe", "(", "insn", ")", ";", "switch", "(", "pipe", ")", "{", "case", "EV4_STOP", ":", "if", "(", "in_use", ")", "goto", "done", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "len", "=", "-", "1", ";", "else", "len", "=", "get_attr_length", "(", "insn", ")", ";", "goto", "next_and_done", ";", "case", "EV4_IBX", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "else", "in_use", "|=", "EV4_IB0", "|", "EV4_IBX", ";", "break", ";", "case", "EV4_IB0", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "!", "(", "in_use", "&", "EV4_IBX", ")", "||", "(", "in_use", "&", "EV4_IB1", ")", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "in_use", "|=", "EV4_IB0", ";", "break", ";", "case", "EV4_IB1", ":", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "4", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "goto", "next_and_done", ";", "next", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "goto", "done", ";", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "goto", "done", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "insn", ")", "==", "USE", ")", "goto", "next", ";", "}", "next_and_done", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "done", ":", "*", "plen", "=", "len", ";", "*", "pin_use", "=", "in_use", ";", "return", "insn", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "output_return", "(", "rtx", "insn", ")", "{", "if", "(", "sparc_leaf_function_p", ")", "{", "gcc_assert", "(", "!", "current_function_calls_eh_return", ")", ";", "return", "\"jmp\\t%%o7+%)%#\"", ";", "}", "else", "{", "if", "(", "current_function_calls_eh_return", ")", "{", "gcc_assert", "(", "!", "final_sequence", ")", ";", "if", "(", "!", "flag_delayed_branch", ")", "fputs", "(", "\"\\tadd\\t%fp, %g1, %fp\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_V9", ")", "fputs", "(", "\"\\treturn\\t%i7+8\\n\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\trestore\\n\\tjmp\\t%o7+8\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "flag_delayed_branch", ")", "fputs", "(", "\"\\t add\\t%sp, %g1, %sp\\n\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\t nop\\n\"", ",", "asm_out_file", ")", ";", "}", "else", "if", "(", "final_sequence", ")", "{", "rtx", "delay", ",", "pat", ";", "delay", "=", "NEXT_INSN", "(", "insn", ")", ";", "gcc_assert", "(", "delay", ")", ";", "pat", "=", "PATTERN", "(", "delay", ")", ";", "if", "(", "TARGET_V9", "&&", "!", "epilogue_renumber", "(", "&", "pat", ",", "1", ")", ")", "{", "epilogue_renumber", "(", "&", "pat", ",", "0", ")", ";", "return", "\"return\\t%%i7+%)%#\"", ";", "}", "else", "{", "output_asm_insn", "(", "\"jmp\\t%%i7+%)\"", ",", "NULL", ")", ";", "output_restore", "(", "pat", ")", ";", "PATTERN", "(", "delay", ")", "=", "gen_blockage", "(", ")", ";", "INSN_CODE", "(", "delay", ")", "=", "-", "1", ";", "}", "}", "else", "{", "if", "(", "TARGET_V9", ")", "return", "\"return\\t%%i7+%)\\n\\t nop\"", ";", "else", "if", "(", "flag_delayed_branch", ")", "return", "\"jmp\\t%%i7+%)\\n\\t restore\"", ";", "else", "return", "\"restore\\n\\tjmp\\t%%o7+%)\\n\\t nop\"", ";", "}", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "return", "." ]

[ "sparc", "\"jmp\\t%%o7+%)%#\"", "\"\\tadd\\t%fp, %g1, %fp\\n\"", "\"\\treturn\\t%i7+8\\n\"", "\"\\trestore\\n\\tjmp\\t%o7+8\\n\"", "\"\\t add\\t%sp, %g1, %sp\\n\"", "\"\\t nop\\n\"", "1", "0", "\"return\\t%%i7+%)%#\"", "\"jmp\\t%%i7+%)\"", "1", "\"return\\t%%i7+%)\\n\\t nop\"", "\"jmp\\t%%i7+%)\\n\\t restore\"", "\"restore\\n\\tjmp\\t%%o7+%)\\n\\t nop\"", "\"\"" ]

[]

[ "<s>", "const", "MipsGNULDBackend", "&", "getTarget", "(", ")", "const", "{", "return", "m_Target", ";", "}", "</s>" ]

[ "getTarget", "-", "Return", "the", "target", "machine", "this", "machine", "code", "is", "compiled", "with" ]

[ "Mips", "Mips" ]

[]

[ "<s>", "Optional", "<", "RegImmPair", ">", "ARMBaseInstrInfo", "::", "isAddImmediate", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "Reg", ")", "const", "{", "int", "Sign", "=", "1", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "int64_t", "Offset", "=", "0", ";", "if", "(", "Reg", "!=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "return", "None", ";", "if", "(", "Opcode", "==", "ARM", "::", "SUBri", ")", "Sign", "=", "-", "1", ";", "else", "if", "(", "Opcode", "!=", "ARM", "::", "ADDri", ")", "return", "None", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "None", ";", "Offset", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "*", "Sign", ";", "return", "RegImmPair", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "Offset", "}", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "an", "instruction", "that", "adds", "an", "immediate", "value", "and", "a", "register", ",", "and", "stores", "the", "result", "in", "the", "given", "register", "Reg", ",", "return", "a", "pair", "of", "the", "source", "register", "and", "the", "offset", "which", "has", "been", "added", "." ]

[ "ARM", "ARM", "1", "0", "0", "ARM::SUBri", "1", "ARM::ADDri", "0", "1", "2", "2", "1" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", "&&", "!", "MF", ".", "getFunction", "(", ")", "->", "hasAddressTaken", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "int64_t", "NumBytes", ",", "bool", "InEpilogue", ")", "const", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "if", "(", "Offset", ">", "Chunk", ")", "{", "unsigned", "Reg", "=", "0", ";", "if", "(", "isSub", "&&", "!", "isEAXLiveIn", "(", "MBB", ")", ")", "Reg", "=", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ";", "else", "Reg", "=", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "unsigned", "Opc", "=", "Is64Bit", "?", "X86", "::", "MOV64ri", ":", "X86", "::", "MOV32ri", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addImm", "(", "Offset", ")", ";", "Opc", "=", "isSub", "?", "getSUBrrOpcode", "(", "Is64Bit", ")", ":", "getADDrrOpcode", "(", "Is64Bit", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addReg", "(", "Reg", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "=", "0", ";", "continue", ";", "}", "}", "uint64_t", "ThisVal", "=", "std", "::", "min", "(", "Offset", ",", "Chunk", ")", ";", "if", "(", "ThisVal", "==", "(", "Is64Bit", "?", "8", ":", "4", ")", ")", "{", "unsigned", "Reg", "=", "isSub", "?", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ":", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "unsigned", "Opc", "=", "isSub", "?", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ":", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "!", "isSub", ")", "|", "getUndefRegState", "(", "isSub", ")", ")", ";", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "else", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "Offset", "-=", "ThisVal", ";", "continue", ";", "}", "}", "MachineInstrBuilder", "MI", "=", "BuildStackAdjustment", "(", "MBB", ",", "MBBI", ",", "DL", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ",", "InEpilogue", ")", ";", "if", "(", "isSub", ")", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "else", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "0", "1LL", "31", "1", "0", "X86::RAX", "X86::EAX", "X86::MOV64ri", "X86::MOV32ri", "3", "0", "8", "4", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::POP64r", "X86::POP32r" ]

[]

[ "<s>", "void", "xtensa_split_DI_reg_imm", "(", "rtx", "*", "operands", ")", "{", "rtx", "lowpart", ",", "highpart", ";", "if", "(", "WORDS_BIG_ENDIAN", ")", "split_double", "(", "operands", "[", "1", "]", ",", "&", "highpart", ",", "&", "lowpart", ")", ";", "else", "split_double", "(", "operands", "[", "1", "]", ",", "&", "lowpart", ",", "&", "highpart", ")", ";", "operands", "[", "3", "]", "=", "highpart", ";", "operands", "[", "2", "]", "=", "gen_highpart", "(", "SImode", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "1", "]", "=", "lowpart", ";", "operands", "[", "0", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Split", "a", "DImode", "pair", "of", "reg", "(", "operand", "[", "0", "]", ")", "and", "const_int", "(", "operand", "[", "1", "]", ")", "into", "two", "SImode", "pairs", ",", "the", "low-part", "(", "operands", "[", "0", "]", "and", "[", "1", "]", ")", "and", "the", "high-part", "(", "operands", "[", "2", "]", "and", "[", "3", "]", ")", "." ]

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

[]

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

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

[ "NVPTX", "\"NVPTX DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "tree", "ix86_stack_protect_fail", "(", "void", ")", "{", "return", "TARGET_64BIT", "?", "default_external_stack_protect_fail", "(", ")", ":", "default_hidden_stack_protect_fail", "(", ")", ";", "}", "</s>" ]

[ "For", "32-bit", "code", "we", "can", "save", "PIC", "register", "setup", "by", "using", "__stack_chk_fail_local", "hidden", "function", "instead", "of", "calling", "__stack_chk_fail", "directly", ".", "64-bit", "code", "does", "n't", "need", "to", "setup", "any", "PIC", "register", ",", "so", "it", "is", "better", "to", "call", "__stack_chk_fail", "directly", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx_insn", "*", "find_next_cycle_insn", "(", "rtx_insn", "*", "insn", ",", "int", "clock", ")", "{", "rtx_insn", "*", "t", "=", "insn", ";", "if", "(", "GET_MODE", "(", "t", ")", "==", "TImode", ")", "t", "=", "next_real_insn", "(", "t", ")", ";", "while", "(", "t", "&&", "GET_MODE", "(", "t", ")", "!=", "TImode", ")", "t", "=", "next_real_insn", "(", "t", ")", ";", "if", "(", "t", "&&", "insn_get_clock", "(", "t", ")", "==", "clock", ")", "return", "t", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Scan", "forwards", "from", "INSN", "until", "we", "find", "the", "next", "insn", "that", "has", "mode", "TImode", "(", "indicating", "it", "starts", "a", "new", "cycle", ")", ",", "and", "occurs", "in", "cycle", "CLOCK", ".", "Return", "it", "if", "we", "find", "such", "an", "insn", ",", "NULL_RTX", "otherwise", "." ]

[ "c6x" ]

[]

[ "<s>", "bool", "function_instance", "::", "reads_global_state_p", "(", ")", "const", "{", "unsigned", "int", "flags", "=", "call_properties", "(", ")", ";", "if", "(", "flags", "&", "CP_READ_FPCR", ")", "return", "true", ";", "return", "flags", "&", "(", "CP_READ_MEMORY", "|", "CP_READ_FFR", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "calls", "to", "the", "function", "could", "read", "some", "form", "of", "global", "state", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "mips_expand_vi_general", "(", "machine_mode", "vmode", ",", "machine_mode", "imode", ",", "unsigned", "nelt", ",", "unsigned", "nvar", ",", "rtx", "target", ",", "rtx", "vals", ")", "{", "rtx", "mem", "=", "assign_stack_temp", "(", "vmode", ",", "GET_MODE_SIZE", "(", "vmode", ")", ")", ";", "unsigned", "int", "i", ",", "isize", "=", "GET_MODE_SIZE", "(", "imode", ")", ";", "if", "(", "nvar", "<", "nelt", ")", "mips_expand_vi_constant", "(", "vmode", ",", "nelt", ",", "mem", ",", "vals", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "mips_constant_elt_p", "(", "x", ")", ")", "emit_move_insn", "(", "adjust_address", "(", "mem", ",", "imode", ",", "i", "*", "isize", ")", ",", "x", ")", ";", "}", "emit_move_insn", "(", "target", ",", "mem", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "mips_expand_vec_init", ",", "expand", "anything", "via", "memory", "." ]

[ "mips", "0", "0" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "static", "void", "visium_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", "ATTRIBUTE_UNUSED", ")", "{", "const", "CUMULATIVE_ARGS", "*", "ca", "=", "&", "crtl", "->", "args", ".", "info", ";", "int", "gp_saved", "=", "MAX_ARGS_IN_GP_REGISTERS", "-", "ca", "->", "grcount", ";", "int", "fp_saved", "=", "(", "TARGET_FPU", "?", "MAX_ARGS_IN_FP_REGISTERS", "-", "ca", "->", "frcount", ":", "0", ")", ";", "int", "named_stack_size", "=", "ca", "->", "stack_words", "*", "UNITS_PER_WORD", ",", "offset", ";", "tree", "f_ovfl", ",", "f_gbase", ",", "f_fbase", ",", "f_gbytes", ",", "f_fbytes", ";", "tree", "ovfl", ",", "gbase", ",", "gbytes", ",", "fbase", ",", "fbytes", ",", "t", ";", "f_ovfl", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_gbase", "=", "TREE_CHAIN", "(", "f_ovfl", ")", ";", "f_fbase", "=", "TREE_CHAIN", "(", "f_gbase", ")", ";", "f_gbytes", "=", "TREE_CHAIN", "(", "f_fbase", ")", ";", "f_fbytes", "=", "TREE_CHAIN", "(", "f_gbytes", ")", ";", "ovfl", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ovfl", ")", ",", "valist", ",", "f_ovfl", ",", "NULL_TREE", ")", ";", "gbase", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_gbase", ")", ",", "valist", ",", "f_gbase", ",", "NULL_TREE", ")", ";", "fbase", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_fbase", ")", ",", "valist", ",", "f_fbase", ",", "NULL_TREE", ")", ";", "gbytes", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_gbytes", ")", ",", "valist", ",", "f_gbytes", ",", "NULL_TREE", ")", ";", "fbytes", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_fbytes", ")", ",", "valist", ",", "f_fbytes", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovfl", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "named_stack_size", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ovfl", ")", ",", "ovfl", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "gbase", ")", ",", "virtual_incoming_args_rtx", ")", ";", "offset", "=", "MAX_ARGS_IN_GP_REGISTERS", "*", "UNITS_PER_WORD", ";", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "offset", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "gbase", ")", ",", "gbase", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "fp_saved", ")", "{", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "fbase", ")", ",", "virtual_incoming_args_rtx", ")", ";", "offset", "=", "gp_saved", "*", "UNITS_PER_WORD", "+", "MAX_ARGS_IN_FP_REGISTERS", "*", "UNITS_PER_HWFPVALUE", ";", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "offset", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "fbase", ")", ",", "fbase", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "gbytes", ")", ",", "gbytes", ",", "size_int", "(", "gp_saved", "*", "UNITS_PER_WORD", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "fbytes", ")", ",", "fbytes", ",", "size_int", "(", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Implement", "`", "va_start", "'", "for", "varargs", "and", "stdarg", "." ]

[ "visium", "0" ]

[]

[ "<s>", "static", "bool", "no_global_regs_above", "(", "int", "first_greg", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", "-", "first_greg", ";", "i", "++", ")", "if", "(", "global_regs", "[", "first_greg", "+", "i", "]", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Look", "for", "user-defined", "global", "regs", ".", "We", "should", "not", "save", "and", "restore", "these", ",", "and", "can", "not", "use", "stmw/lmw", "if", "there", "are", "any", "in", "its", "range", "." ]

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

[]

[ "<s>", "bool", "NVPTXPassConfig", "::", "addInstSelector", "(", ")", "{", "const", "NVPTXSubtarget", "&", "ST", "=", "*", "getTM", "<", "NVPTXTargetMachine", ">", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "addPass", "(", "createLowerAggrCopies", "(", ")", ")", ";", "addPass", "(", "createAllocaHoisting", "(", ")", ")", ";", "addPass", "(", "createNVPTXISelDag", "(", "getNVPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "ST", ".", "hasImageHandles", "(", ")", ")", "addPass", "(", "createNVPTXReplaceImageHandlesPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "insertEdge", "(", "unsigned", "Reg", ")", "{", "return", "Edges", ".", "insert", "(", "Reg", ")", ".", "second", ";", "}", "</s>" ]

[ "Update", "the", "call", "graph", "after", "inserting", "a", "new", "edge", "." ]

[ "X86" ]

[]

[ "<s>", "static", "int", "sign_bit_position", "(", "const", "rtx", "op", ")", "{", "const", "int", "sz", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ";", "return", "sz", "*", "8", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "sign", "bit", "position", "for", "given", "OP", "'s", "mode", "." ]

[ "pru", "8", "1" ]

[]

[ "<s>", "static", "rtx", "copy_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE", "(", "op", ")", "!=", "VOIDmode", ")", "{", "if", "(", "REG_P", "(", "op", ")", ")", "op", "=", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "op", ")", ")", ";", "else", "{", "op", "=", "copy_rtx", "(", "op", ")", ";", "PUT_MODE", "(", "op", ",", "mode", ")", ";", "}", "}", "return", "op", ";", "}", "</s>" ]

[ "Copy", "OP", "and", "change", "its", "mode", "to", "MODE", "." ]

[ "m68k" ]

[]

[ "<s>", "static", "void", "xstormy16_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "*", "cum", "<", "NUM_ARGUMENT_REGISTERS", "&&", "*", "cum", "+", "XSTORMY16_WORD_SIZE", "(", "type", ",", "mode", ")", ">", "NUM_ARGUMENT_REGISTERS", ")", "*", "cum", "=", "NUM_ARGUMENT_REGISTERS", ";", "*", "cum", "+=", "XSTORMY16_WORD_SIZE", "(", "type", ",", "mode", ")", ";", "}", "</s>" ]

[ "Update", "CUM", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", ".", "The", "values", "MODE", ",", "TYPE", "and", "NAMED", "describe", "that", "argument", ".", "Once", "this", "is", "done", ",", "the", "variable", "CUM", "is", "suitable", "for", "analyzing", "the", "*", "following", "*", "argument", "with", "`", "TARGET_FUNCTION_ARG", "'", ",", "etc", ".", "This", "function", "need", "not", "do", "anything", "if", "the", "argument", "in", "question", "was", "passed", "on", "the", "stack", ".", "The", "compiler", "knows", "how", "to", "track", "the", "amount", "of", "stack", "space", "used", "for", "arguments", "without", "any", "special", "help", ".", "However", ",", "it", "makes", "life", "easier", "for", "xstormy16_build_va_list", "if", "it", "does", "update", "the", "word", "count", "." ]

[ "stormy16" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemchr", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src", ",", "SDValue", "Char", ",", "SDValue", "Length", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "EVT", "PtrVT", "=", "Src", ".", "getValueType", "(", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "PtrVT", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "Length", "=", "DAG", ".", "getZExtOrTrunc", "(", "Length", ",", "DL", ",", "PtrVT", ")", ";", "Char", "=", "DAG", ".", "getZExtOrTrunc", "(", "Char", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Char", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "Char", ",", "DAG", ".", "getConstant", "(", "255", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Limit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Src", ",", "Length", ")", ";", "SDValue", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SEARCH_STRING", ",", "DL", ",", "VTs", ",", "Chain", ",", "Limit", ",", "Src", ",", "Char", ")", ";", "Chain", "=", "End", ".", "getValue", "(", "1", ")", ";", "SDValue", "Glue", "=", "End", ".", "getValue", "(", "2", ")", ";", "SmallVector", "<", "SDValue", ",", "5", ">", "Ops", ";", "Ops", ".", "push_back", "(", "End", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "PtrVT", ")", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST", ",", "MVT", "::", "i32", ")", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "SystemZ", "::", "CCMASK_SRST_FOUND", ",", "MVT", "::", "i32", ")", ")", ";", "Ops", ".", "push_back", "(", "Glue", ")", ";", "VTs", "=", "DAG", ".", "getVTList", "(", "PtrVT", ",", "MVT", "::", "Glue", ")", ";", "End", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "SELECT_CCMASK", ",", "DL", ",", "VTs", ",", "Ops", ")", ";", "return", "std", "::", "make_pair", "(", "End", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memchr", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::Other", "MVT::Glue", "MVT::i32", "ISD::AND", "MVT::i32", "255", "MVT::i32", "ISD::ADD", "SystemZISD::SEARCH_STRING", "1", "2", "5", "0", "SystemZ::CCMASK_SRST", "MVT::i32", "SystemZ::CCMASK_SRST_FOUND", "MVT::i32", "MVT::Glue", "SystemZISD::SELECT_CCMASK" ]

[]

[ "<s>", "bool", "NVPTXAssignValidGlobalNames", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "for", "(", "GlobalVariable", "&", "GV", ":", "M", ".", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "hasLocalLinkage", "(", ")", ")", "{", "GV", ".", "setName", "(", "cleanUpName", "(", "GV", ".", "getName", "(", ")", ")", ")", ";", "}", "}", "for", "(", "Function", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "if", "(", "F", ".", "hasLocalLinkage", "(", ")", ")", "F", ".", "setName", "(", "cleanUpName", "(", "F", ".", "getName", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "MipsFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "NewReg", "=", "0", ";", "int", "NewImm", "=", "0", ";", "bool", "ATUsed", "=", "false", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "}", "if", "(", "StackSize", ")", "{", "ATUsed", "=", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "StackSize", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "NewReg", ")", ".", "addImm", "(", "NewImm", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "0", "0", "0", "Mips::ADDu", "Mips::SP", "Mips::FP", "Mips::ZERO", "Mips::SP", "Mips::ADDiu", "Mips::SP", "Mips::ATMACRO" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "{", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin_Or_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::InputArg", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "bool", "arm_must_pass_in_stack", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "TARGET_AAPCS_BASED", ")", "return", "must_pass_in_stack_var_size", "(", "mode", ",", "type", ")", ";", "else", "return", "must_pass_in_stack_var_size_or_pad", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "type", "must", "be", "passed", "in", "memory", ".", "For", "AAPCS", ",", "small", "aggregates", "(", "padded", "to", "the", "size", "of", "a", "word", ")", "should", "be", "passed", "in", "a", "register", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "SlotSize", "=", "RegInfo", "->", "getSlotSize", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "0", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfo", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "SpillSlotOffset", "-=", "std", "::", "abs", "(", "SpillSlotOffset", ")", "%", "RC", "->", "getAlignment", "(", ")", ";", "SpillSlotOffset", "-=", "RC", "->", "getSize", "(", ")", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", "->", "ensureMaxAlignment", "(", "RC", "->", "getAlignment", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "static", "void", "nds32_emit_stack_v3push", "(", "unsigned", "Rb", ",", "unsigned", "Re", ",", "unsigned", "imm8u", ")", "{", "unsigned", "regno", ";", "int", "num_use_regs", ";", "int", "par_index", ";", "int", "offset", ";", "rtx", "reg", ";", "rtx", "mem", ";", "rtx", "push_rtx", ";", "rtx", "adjust_sp_rtx", ";", "rtx", "parallel_insn", ";", "num_use_regs", "=", "Re", "-", "Rb", "+", "1", "+", "3", ";", "parallel_insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_use_regs", "+", "1", ")", ")", ";", "par_index", "=", "0", ";", "offset", "=", "-", "(", "num_use_regs", "*", "4", ")", ";", "for", "(", "regno", "=", "Rb", ";", "regno", "<=", "Re", ";", "regno", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "}", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "FP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "LP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "offset", "=", "-", "(", "num_use_regs", "*", "4", ")", ";", "adjust_sp_rtx", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", "-", "imm8u", ")", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "adjust_sp_rtx", ";", "RTX_FRAME_RELATED_P", "(", "adjust_sp_rtx", ")", "=", "1", ";", "parallel_insn", "=", "emit_insn", "(", "parallel_insn", ")", ";", "RTX_FRAME_RELATED_P", "(", "parallel_insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Function", "to", "create", "a", "parallel", "rtx", "pattern", "which", "presents", "stack", "v3push", "behavior", ".", "The", "overall", "concept", "are", ":", "``", "push", "registers", "to", "memory", "''", ",", "``", "adjust", "stack", "pointer", "''", "." ]

[ "nds32", "1", "3", "1", "0", "4", "0", "1", "4", "0", "1", "4", "0", "1", "4", "0", "1", "4", "4", "0", "1", "1" ]

[]

[ "<s>", "int", "ARMAsmParser", "::", "tryParseRegister", "(", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "-", "1", ";", "std", "::", "string", "upperCase", "=", "Tok", ".", "getString", "(", ")", ".", "str", "(", ")", ";", "std", "::", "string", "lowerCase", "=", "LowercaseString", "(", "upperCase", ")", ";", "unsigned", "RegNum", "=", "MatchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "!", "RegNum", ")", "{", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"r13\"", ",", "ARM", "::", "SP", ")", ".", "Case", "(", "\"r14\"", ",", "ARM", "::", "LR", ")", ".", "Case", "(", "\"r15\"", ",", "ARM", "::", "PC", ")", ".", "Case", "(", "\"ip\"", ",", "ARM", "::", "R12", ")", ".", "Default", "(", "0", ")", ";", "}", "if", "(", "!", "RegNum", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "{", "SMLoc", "SIdx", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "const", "MCExpr", "*", "ImmVal", ";", "SMLoc", "ExprLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "getParser", "(", ")", ".", "ParseExpression", "(", "ImmVal", ")", ")", "return", "MatchOperand_ParseFail", ";", "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "ImmVal", ")", ";", "if", "(", "!", "MCE", ")", "{", "TokError", "(", "\"immediate value expected for vector index\"", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "SMLoc", "E", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RBrac", ")", ")", "{", "Error", "(", "E", ",", "\"']' expected\"", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateVectorIndex", "(", "MCE", "->", "getValue", "(", ")", ",", "SIdx", ",", "E", ",", "getContext", "(", ")", ")", ")", ";", "}", "return", "RegNum", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "ARM", "ARM", "1", "\"r13\"", "ARM::SP", "\"r14\"", "ARM::LR", "\"r15\"", "ARM::PC", "\"ip\"", "ARM::R12", "0", "1", "\"immediate value expected for vector index\"", "\"']' expected\"", "ARM" ]

[]

[ "<s>", "static", "bool", "visium_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "rtx", "base", ";", "unsigned", "int", "regno", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "!", "rtx_ok_for_offset_p", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "else", "base", "=", "x", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "SUBREG", ")", "base", "=", "SUBREG_REG", "(", "base", ")", ";", "if", "(", "!", "REG_P", "(", "base", ")", ")", "return", "false", ";", "regno", "=", "REGNO", "(", "base", ")", ";", "if", "(", "strict", ")", "return", "REGNO_OK_FOR_BASE_P", "(", "regno", ")", ";", "return", "BASE_REGISTER_P", "(", "regno", ")", "||", "regno", ">=", "FIRST_PSEUDO_REGISTER", ";", "}", "</s>" ]

[ "Return", "whether", "X", "is", "a", "legitimate", "memory", "address", "for", "a", "memory", "operand", "of", "mode", "MODE", ".", "Legitimate", "addresses", "are", "defined", "in", "two", "variants", ":", "a", "strict", "variant", "and", "a", "non-strict", "one", ".", "The", "STRICT", "parameter", "chooses", "which", "variant", "is", "desired", "by", "the", "caller", ".", "The", "strict", "variant", "is", "used", "in", "the", "reload", "pass", ".", "It", "must", "be", "defined", "so", "that", "any", "pseudo-register", "that", "has", "not", "been", "allocated", "a", "hard", "register", "is", "considered", "a", "memory", "reference", ".", "This", "is", "because", "in", "contexts", "where", "some", "kind", "of", "register", "is", "required", ",", "a", "pseudo-register", "with", "no", "hard", "register", "must", "be", "rejected", ".", "For", "non-hard", "registers", ",", "the", "strict", "variant", "should", "look", "up", "the", "`", "reg_renumber", "'", "array", ";", "it", "should", "then", "proceed", "using", "the", "hard", "register", "number", "in", "the", "array", ",", "or", "treat", "the", "pseudo", "as", "a", "memory", "reference", "if", "the", "array", "holds", "`", "-1", "'", ".", "The", "non-strict", "variant", "is", "used", "in", "other", "passes", ".", "It", "must", "be", "defined", "to", "accept", "all", "pseudo-registers", "in", "every", "context", "where", "some", "kind", "of", "register", "is", "required", "." ]

[ "visium", "1", "0" ]

[]

[ "<s>", "static", "int", "optimal_immediate_sequence", "(", "enum", "rtx_code", "code", ",", "unsigned", "HOST_WIDE_INT", "val", ",", "struct", "four_ints", "*", "return_sequence", ")", "{", "int", "best_consecutive_zeros", "=", "0", ";", "int", "i", ";", "int", "best_start", "=", "0", ";", "int", "insns1", ",", "insns2", ";", "struct", "four_ints", "tmp_sequence", ";", "if", "(", "TARGET_ARM", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "+=", "2", ")", "{", "int", "consecutive_zeros", "=", "0", ";", "if", "(", "!", "(", "val", "&", "(", "3", "<<", "i", ")", ")", ")", "{", "while", "(", "(", "i", "<", "32", ")", "&&", "!", "(", "val", "&", "(", "3", "<<", "i", ")", ")", ")", "{", "consecutive_zeros", "+=", "2", ";", "i", "+=", "2", ";", "}", "if", "(", "consecutive_zeros", ">", "best_consecutive_zeros", ")", "{", "best_consecutive_zeros", "=", "consecutive_zeros", ";", "best_start", "=", "i", "-", "consecutive_zeros", ";", "}", "i", "-=", "2", ";", "}", "}", "}", "insns1", "=", "optimal_immediate_sequence_1", "(", "code", ",", "val", ",", "return_sequence", ",", "best_start", ")", ";", "if", "(", "best_start", "!=", "0", "&&", "(", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", ")", "<<", "best_start", ")", "<", "val", ")", ")", "{", "insns2", "=", "optimal_immediate_sequence_1", "(", "code", ",", "val", ",", "&", "tmp_sequence", ",", "0", ")", ";", "if", "(", "insns2", "<=", "insns1", ")", "{", "*", "return_sequence", "=", "tmp_sequence", ";", "insns1", "=", "insns2", ";", "}", "}", "return", "insns1", ";", "}", "</s>" ]

[ "Return", "a", "sequence", "of", "integers", ",", "in", "RETURN_SEQUENCE", "that", "fit", "into", "ARM/THUMB2", "immediates", ",", "and", "add", "up", "to", "VAL", ".", "Thr", "function", "return", "value", "gives", "the", "number", "of", "insns", "required", "." ]

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

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "ARM", "::", "fixup_arm_thumb_br", ":", "{", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", "-", "4", ";", "return", "Offset", ">", "2046", "||", "Offset", "<", "-", "2048", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_bcc", ":", "{", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", "-", "4", ";", "return", "Offset", ">", "254", "||", "Offset", "<", "-", "256", ";", "}", "case", "ARM", "::", "fixup_thumb_adr_pcrel_10", ":", "case", "ARM", "::", "fixup_arm_thumb_cp", ":", "{", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", "-", "4", ";", "return", "Offset", ">", "1020", "||", "Offset", "<", "0", "||", "Offset", "&", "3", ";", "}", "}", "llvm_unreachable", "(", "\"Unexpected fixup kind in fixupNeedsRelaxation()!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::fixup_arm_thumb_br", "4", "2046", "2048", "ARM::fixup_arm_thumb_bcc", "4", "254", "256", "ARM::fixup_thumb_adr_pcrel_10", "ARM::fixup_arm_thumb_cp", "4", "1020", "0", "3", "\"Unexpected fixup kind in fixupNeedsRelaxation()!\"" ]

[]

[ "<s>", "int", "s390_mem_constraint", "(", "const", "char", "*", "str", ",", "rtx", "op", ")", "{", "char", "c", "=", "str", "[", "0", "]", ";", "switch", "(", "c", ")", "{", "case", "'A'", ":", "if", "(", "!", "MEM_P", "(", "op", ")", "||", "MEM_VOLATILE_P", "(", "op", ")", ")", "return", "0", ";", "if", "(", "(", "reload_completed", "||", "reload_in_progress", ")", "?", "!", "offsettable_memref_p", "(", "op", ")", ":", "!", "offsettable_nonstrict_memref_p", "(", "op", ")", ")", "return", "0", ";", "return", "s390_check_qrst_address", "(", "str", "[", "1", "]", ",", "XEXP", "(", "op", ",", "0", ")", ",", "true", ")", ";", "case", "'B'", ":", "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "0", ";", "return", "s390_check_qrst_address", "(", "str", "[", "1", "]", ",", "XEXP", "(", "op", ",", "0", ")", ",", "false", ")", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'S'", ":", "case", "'T'", ":", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "return", "s390_check_qrst_address", "(", "c", ",", "XEXP", "(", "op", ",", "0", ")", ",", "true", ")", ";", "case", "'Y'", ":", "if", "(", "!", "s390_decompose_addrstyle_without_index", "(", "op", ",", "NULL", ",", "NULL", ")", ")", "return", "0", ";", "break", ";", "case", "'Z'", ":", "return", "s390_check_qrst_address", "(", "str", "[", "1", "]", ",", "op", ",", "true", ")", ";", "default", ":", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Evaluates", "constraint", "strings", "described", "by", "the", "regular", "expression", "(", "[", "A|B|Z", "]", "(", "Q|R|S|T", ")", ")", "|U|W|Y", "and", "returns", "1", "if", "OP", "is", "a", "valid", "operand", "for", "the", "constraint", "given", "in", "STR", ",", "or", "0", "else", "." ]

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

[]

[ "<s>", "bool", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "override", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "errs", "(", ")", "<<", "\"ConstraintID: \"", "<<", "ConstraintID", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_es", ":", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "case", "InlineAsm", "::", "Constraint_Z", ":", "case", "InlineAsm", "::", "Constraint_Zy", ":", "const", "TargetRegisterInfo", "*", "TRI", "=", "PPCSubTarget", "->", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "TRI", "->", "getPointerRegClass", "(", "*", "MF", ",", "1", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "NewOp", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Op", ",", "RC", ")", ",", "0", ")", ";", "OutOps", ".", "push_back", "(", "NewOp", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "\"ConstraintID: \"", "\"\\n\"", "\"Unexpected asm memory constraint\"", "PPC", "1", "MVT::i32", "0" ]

[]

[ "<s>", "static", "enum", "dispatch_group", "get_insn_group", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "dispatch_group", "group", "=", "get_mem_group", "(", "insn", ")", ";", "if", "(", "group", ")", "return", "group", ";", "if", "(", "is_branch", "(", "insn", ")", ")", "return", "disp_branch", ";", "if", "(", "is_cmp", "(", "insn", ")", ")", "return", "disp_cmp", ";", "if", "(", "has_immediate", "(", "insn", ")", ")", "return", "disp_imm", ";", "if", "(", "is_prefetch", "(", "insn", ")", ")", "return", "disp_prefetch", ";", "return", "disp_no_group", ";", "}", "</s>" ]

[ "Return", "insn", "dispatch", "group", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isCallerPreservedPhysReg", "(", "unsigned", "PhysReg", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "PhysReg", ")", ")", ";", "if", "(", "TM", ".", "isELFv2ABI", "(", ")", "&&", "PhysReg", "==", "PPC", "::", "X2", ")", "{", "return", "(", "getReservedRegs", "(", "MF", ")", ".", "test", "(", "PPC", "::", "X2", ")", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}", "</s>" ]

[ "Physical", "registers", "that", "may", "be", "modified", "within", "a", "function", "but", "are", "guaranteed", "to", "be", "restored", "before", "any", "uses", "." ]

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

[]

[ "<s>", "void", "R600InstrInfo", "::", "reserveIndirectRegisters", "(", "BitVector", "&", "Reserved", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AMDGPUFrameLowering", "*", "TFL", "=", "static_cast", "<", "const", "AMDGPUFrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "unsigned", "StackWidth", "=", "TFL", "->", "getStackWidth", "(", "MF", ")", ";", "int", "End", "=", "getIndirectIndexEnd", "(", "MF", ")", ";", "if", "(", "End", "==", "-", "1", ")", "return", ";", "for", "(", "int", "Index", "=", "getIndirectIndexBegin", "(", "MF", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "{", "unsigned", "SuperReg", "=", "AMDGPU", "::", "R600_Reg128RegClass", ".", "getRegister", "(", "Index", ")", ";", "Reserved", ".", "set", "(", "SuperReg", ")", ";", "for", "(", "unsigned", "Chan", "=", "0", ";", "Chan", "<", "StackWidth", ";", "++", "Chan", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "R600_TReg32RegClass", ".", "getRegister", "(", "(", "4", "*", "Index", ")", "+", "Chan", ")", ";", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "}", "}", "</s>" ]

[ "Reserve", "the", "registers", "that", "may", "be", "accessed", "using", "indirect", "addressing", "." ]

[ "R600", "1", "0", "4" ]

[]

[ "<s>", "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MipsISD", "::", "JmpLink", ":", "return", "\"MipsISD::JmpLink\"", ";", "case", "MipsISD", "::", "Hi", ":", "return", "\"MipsISD::Hi\"", ";", "case", "MipsISD", "::", "Lo", ":", "return", "\"MipsISD::Lo\"", ";", "case", "MipsISD", "::", "GPRel", ":", "return", "\"MipsISD::GPRel\"", ";", "case", "MipsISD", "::", "ThreadPointer", ":", "return", "\"MipsISD::ThreadPointer\"", ";", "case", "MipsISD", "::", "Ret", ":", "return", "\"MipsISD::Ret\"", ";", "case", "MipsISD", "::", "FPBrcond", ":", "return", "\"MipsISD::FPBrcond\"", ";", "case", "MipsISD", "::", "FPCmp", ":", "return", "\"MipsISD::FPCmp\"", ";", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "\"MipsISD::CMovFP_T\"", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "return", "\"MipsISD::CMovFP_F\"", ";", "case", "MipsISD", "::", "FPRound", ":", "return", "\"MipsISD::FPRound\"", ";", "case", "MipsISD", "::", "MAdd", ":", "return", "\"MipsISD::MAdd\"", ";", "case", "MipsISD", "::", "MAddu", ":", "return", "\"MipsISD::MAddu\"", ";", "case", "MipsISD", "::", "MSub", ":", "return", "\"MipsISD::MSub\"", ";", "case", "MipsISD", "::", "MSubu", ":", "return", "\"MipsISD::MSubu\"", ";", "case", "MipsISD", "::", "DivRem", ":", "return", "\"MipsISD::DivRem\"", ";", "case", "MipsISD", "::", "DivRemU", ":", "return", "\"MipsISD::DivRemU\"", ";", "case", "MipsISD", "::", "BuildPairF64", ":", "return", "\"MipsISD::BuildPairF64\"", ";", "case", "MipsISD", "::", "ExtractElementF64", ":", "return", "\"MipsISD::ExtractElementF64\"", ";", "case", "MipsISD", "::", "Wrapper", ":", "return", "\"MipsISD::Wrapper\"", ";", "case", "MipsISD", "::", "DynAlloc", ":", "return", "\"MipsISD::DynAlloc\"", ";", "case", "MipsISD", "::", "Sync", ":", "return", "\"MipsISD::Sync\"", ";", "case", "MipsISD", "::", "Ext", ":", "return", "\"MipsISD::Ext\"", ";", "case", "MipsISD", "::", "Ins", ":", "return", "\"MipsISD::Ins\"", ";", "case", "MipsISD", "::", "LWL", ":", "return", "\"MipsISD::LWL\"", ";", "case", "MipsISD", "::", "LWR", ":", "return", "\"MipsISD::LWR\"", ";", "case", "MipsISD", "::", "SWL", ":", "return", "\"MipsISD::SWL\"", ";", "case", "MipsISD", "::", "SWR", ":", "return", "\"MipsISD::SWR\"", ";", "case", "MipsISD", "::", "LDL", ":", "return", "\"MipsISD::LDL\"", ";", "case", "MipsISD", "::", "LDR", ":", "return", "\"MipsISD::LDR\"", ";", "case", "MipsISD", "::", "SDL", ":", "return", "\"MipsISD::SDL\"", ";", "case", "MipsISD", "::", "SDR", ":", "return", "\"MipsISD::SDR\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsISD::JmpLink", "\"MipsISD::JmpLink\"", "MipsISD::Hi", "\"MipsISD::Hi\"", "MipsISD::Lo", "\"MipsISD::Lo\"", "MipsISD::GPRel", "\"MipsISD::GPRel\"", "MipsISD::ThreadPointer", "\"MipsISD::ThreadPointer\"", "MipsISD::Ret", "\"MipsISD::Ret\"", "MipsISD::FPBrcond", "\"MipsISD::FPBrcond\"", "MipsISD::FPCmp", "\"MipsISD::FPCmp\"", "MipsISD::CMovFP_T", "\"MipsISD::CMovFP_T\"", "MipsISD::CMovFP_F", "\"MipsISD::CMovFP_F\"", "MipsISD::FPRound", "\"MipsISD::FPRound\"", "MipsISD::MAdd", "\"MipsISD::MAdd\"", "MipsISD::MAddu", "\"MipsISD::MAddu\"", "MipsISD::MSub", "\"MipsISD::MSub\"", "MipsISD::MSubu", "\"MipsISD::MSubu\"", "MipsISD::DivRem", "\"MipsISD::DivRem\"", "MipsISD::DivRemU", "\"MipsISD::DivRemU\"", "MipsISD::BuildPairF64", "\"MipsISD::BuildPairF64\"", "MipsISD::ExtractElementF64", "\"MipsISD::ExtractElementF64\"", "MipsISD::Wrapper", "\"MipsISD::Wrapper\"", "MipsISD::DynAlloc", "\"MipsISD::DynAlloc\"", "MipsISD::Sync", "\"MipsISD::Sync\"", "MipsISD::Ext", "\"MipsISD::Ext\"", "MipsISD::Ins", "\"MipsISD::Ins\"", "MipsISD::LWL", "\"MipsISD::LWL\"", "MipsISD::LWR", "\"MipsISD::LWR\"", "MipsISD::SWL", "\"MipsISD::SWL\"", "MipsISD::SWR", "\"MipsISD::SWR\"", "MipsISD::LDL", "\"MipsISD::LDL\"", "MipsISD::LDR", "\"MipsISD::LDR\"", "MipsISD::SDL", "\"MipsISD::SDL\"", "MipsISD::SDR", "\"MipsISD::SDR\"" ]

[]

[ "<s>", "static", "void", "alpha_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "pcum", ";", "FUNCTION_ARG_ADVANCE", "(", "cum", ",", "mode", ",", "type", ",", "1", ")", ";", "if", "(", "cum", ".", "num_reg_words", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_insn", "(", "gen_umk_mismatch_args", "(", "GEN_INT", "(", "cum", ".", "num_reg_words", ")", ")", ")", ";", "emit_insn", "(", "gen_arg_home_umk", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "0", ";", "}", "if", "(", "cum", ".", "num_args", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "1", ")", ",", "virtual_incoming_args_rtx", ")", ";", "emit_insn", "(", "gen_arg_home", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "7", "*", "UNITS_PER_WORD", ";", "}", "if", "(", "cum", ">=", "6", ")", "return", ";", "if", "(", "!", "no_rtl", ")", "{", "int", "count", ",", "set", "=", "get_varargs_alias_set", "(", ")", ";", "rtx", "tmp", ";", "count", "=", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "if", "(", "count", ">", "6", "-", "cum", ")", "count", "=", "6", "-", "cum", ";", "gcc_assert", "(", "(", "VA_LIST_MAX_FPR_SIZE", "&", "3", ")", "==", "3", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "1", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "(", "cum", "+", "6", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", ",", "tmp", ",", "count", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "2", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "cum", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", "+", "TARGET_FPREGS", "*", "32", ",", "tmp", ",", "count", ")", ";", "}", "}", "*", "pretend_size", "=", "12", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", "." ]

[ "alpha", "1", "6", "0", "6", "1", "7", "6", "6", "6", "3", "3", "1", "6", "1", "16", "2", "1", "16", "32", "12" ]

[]

[ "<s>", "const", "char", "*", "AArch64Relocator", "::", "getName", "(", "Relocator", "::", "Type", "pType", ")", "const", "{", "assert", "(", "ApplyFunctions", ".", "find", "(", "pType", ")", "!=", "ApplyFunctions", ".", "end", "(", ")", ")", ";", "return", "ApplyFunctions", "[", "pType", "]", ".", "name", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "gimple", "*", "fold", "(", "gimple_folder", "&", "f", ")", "const", "OVERRIDE", "{", "if", "(", "tree", "amount", "=", "uniform_integer_cst_p", "(", "gimple_call_arg", "(", "f", ".", "call", ",", "2", ")", ")", ")", "{", "if", "(", "wi", "::", "to_widest", "(", "amount", ")", ">=", "0", ")", "{", "function_instance", "instance", "(", "\"svlsl\"", ",", "functions", "::", "svlsl", ",", "shapes", "::", "binary_uint_opt_n", ",", "MODE_n", ",", "f", ".", "type_suffix_ids", ",", "f", ".", "pred", ")", ";", "gcall", "*", "call", "=", "as_a", "<", "gcall", "*", ">", "(", "f", ".", "redirect_call", "(", "instance", ")", ")", ";", "gimple_call_set_arg", "(", "call", ",", "2", ",", "amount", ")", ";", "return", "call", ";", "}", "int", "element_bits", "=", "f", ".", "type_suffix", "(", "0", ")", ".", "element_bits", ";", "if", "(", "wi", "::", "to_widest", "(", "amount", ")", ">=", "-", "element_bits", ")", "{", "amount", "=", "wide_int_to_tree", "(", "TREE_TYPE", "(", "amount", ")", ",", "-", "wi", "::", "to_wide", "(", "amount", ")", ")", ";", "function_instance", "instance", "(", "\"svrshr\"", ",", "functions", "::", "svrshr", ",", "shapes", "::", "shift_right_imm", ",", "MODE_n", ",", "f", ".", "type_suffix_ids", ",", "f", ".", "pred", ")", ";", "gcall", "*", "call", "=", "as_a", "<", "gcall", "*", ">", "(", "f", ".", "redirect_call", "(", "instance", ")", ")", ";", "gimple_call_set_arg", "(", "call", ",", "2", ",", "amount", ")", ";", "return", "call", ";", "}", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Try", "to", "fold", "the", "call", ".", "Return", "the", "new", "statement", "on", "success", "and", "null", "on", "failure", "." ]

[ "aarch64", "2", "0", "\"svlsl\"", "2", "0", "\"svrshr\"", "2" ]

[]

[ "<s>", "void", "TPCIndexMap", "::", "sort", "(", ")", "{", "LoopData", "loopTemp", "[", "5", "]", ";", "int", "size", "=", "0", ";", "for", "(", "unsigned", "long", "i", "=", "0", ";", "i", "<", "m_loopInfoVec", ".", "size", "(", ")", ";", "i", "++", ")", "{", "if", "(", "m_loopInfoVec", "[", "i", "]", ".", "is_Valid", "(", ")", ")", "{", "loopTemp", "[", "m_loopInfoVec", "[", "i", "]", ".", "get_DIM", "(", ")", "]", "=", "m_loopInfoVec", "[", "i", "]", ";", "size", "++", ";", "}", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "m_loopInfoVec", "[", "i", "]", "=", "loopTemp", "[", "i", "]", ";", "}", "</s>" ]

[ "Sort", "the", "list", "." ]

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

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "FPSCR", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "FramePtr", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "Reserved", ".", "set", "(", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{", "assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "16", ";", "++", "i", ")", "Reserved", ".", "set", "(", "ARM", "::", "D16", "+", "i", ")", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "for", "(", "MCSubRegIterator", "SI", "(", "*", "I", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "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", "." ]

[ "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "0", "16", "ARM::D16", "ARM::GPRPairRegClass" ]

[]

[ "<s>", "static", "bool", "isReverseMask", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "!=", "M", ".", "size", "(", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "if", "(", "M", "[", "i", "]", ">=", "0", "&&", "M", "[", "i", "]", "!=", "(", "int", ")", "(", "NumElts", "-", "1", "-", "i", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "shuffle", "mask", "swaps", "the", "order", "of", "elements", "from", "exactly", "one", "source", "vector", "." ]

[ "ARM", "0", "0", "1" ]

[]

[ "<s>", "TargetIRAnalysis", "AMDGPUTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "AMDGPUTTIImpl", "(", "this", ",", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "char", "*", "nvptx_replace_dot", "(", "const", "char", "*", "name", ")", "{", "if", "(", "strchr", "(", "name", ",", "'.'", ")", "==", "NULL", ")", "return", "NULL", ";", "char", "*", "p", "=", "xstrdup", "(", "name", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "strlen", "(", "p", ")", ";", "++", "i", ")", "if", "(", "p", "[", "i", "]", "==", "'.'", ")", "p", "[", "i", "]", "=", "'$'", ";", "return", "p", ";", "}", "</s>" ]

[ "Return", "NULL", "if", "NAME", "contains", "no", "dot", ".", "Otherwise", "return", "a", "copy", "of", "NAME", "with", "the", "dots", "replaced", "with", "dollar", "signs", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "EVT", "MipsTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsZeroVal", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "Subtarget", "->", "hasMips64", "(", ")", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "static", "rtx_insn", "*", "loongarch_call_tls_get_addr", "(", "rtx", "sym", ",", "enum", "loongarch_symbol_type", "type", ",", "rtx", "v0", ")", "{", "rtx", "loc", ",", "a0", ";", "rtx_insn", "*", "insn", ";", "a0", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "!", "loongarch_tls_symbol", ")", "loongarch_tls_symbol", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "loc", "=", "loongarch_unspec_address", "(", "sym", ",", "type", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "type", "==", "SYMBOL_TLSLDM", ")", "emit_insn", "(", "loongarch_got_load_tls_ld", "(", "a0", ",", "loc", ")", ")", ";", "else", "if", "(", "type", "==", "SYMBOL_TLSGD", ")", "emit_insn", "(", "loongarch_got_load_tls_gd", "(", "a0", ",", "loc", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_call_value_internal", "(", "v0", ",", "loongarch_tls_symbol", ",", "const0_rtx", ")", ")", ";", "RTL_CONST_CALL_P", "(", "insn", ")", "=", "1", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "a0", ")", ";", "insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Return", "an", "instruction", "sequence", "that", "calls", "__tls_get_addr", ".", "SYM", "is", "the", "TLS", "symbol", "we", "are", "referencing", "and", "TYPE", "is", "the", "symbol", "type", "to", "use", "(", "either", "global", "dynamic", "or", "local", "dynamic", ")", ".", "V0", "is", "an", "RTX", "for", "the", "return", "value", "location", "." ]

[ "loongarch", "\"__tls_get_addr\"", "1" ]

[]

[ "<s>", "static", "bool", "avr_allocate_stack_slots_for_args", "(", "void", ")", "{", "return", "!", "cfun", "->", "machine", "->", "is_naked", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS", "'" ]

[ "avr" ]

[]

[ "<s>", "static", "int", "mingw32_gt_pch_use_address", "(", "void", "*", "&", "addr", ",", "size_t", "size", ",", "int", "fd", ",", "size_t", "offset", ")", "{", "void", "*", "mmap_addr", ";", "HANDLE", "mmap_handle", ";", "char", "*", "object_name", "=", "NULL", ";", "OSVERSIONINFO", "version_info", ";", "int", "r", ";", "version_info", ".", "dwOSVersionInfoSize", "=", "sizeof", "(", "version_info", ")", ";", "if", "(", "size", "==", "0", ")", "return", "0", ";", "if", "(", "(", "offset", "&", "(", "va_granularity", "-", "1", ")", ")", "!=", "0", ")", "return", "-", "1", ";", "GetVersionEx", "(", "&", "version_info", ")", ";", "char", "local_object_name", "[", "sizeof", "(", "OBJECT_NAME_FMT", ")", "+", "sizeof", "(", "DWORD", ")", "*", "2", "]", ";", "if", "(", "version_info", ".", "dwMajorVersion", ">", "4", ")", "{", "snprintf", "(", "local_object_name", ",", "sizeof", "(", "local_object_name", ")", ",", "OBJECT_NAME_FMT", "\"%lx\"", ",", "GetCurrentProcessId", "(", ")", ")", ";", "object_name", "=", "local_object_name", ";", "}", "mmap_handle", "=", "CreateFileMappingA", "(", "(", "HANDLE", ")", "_get_osfhandle", "(", "fd", ")", ",", "NULL", ",", "PAGE_WRITECOPY", "|", "SEC_COMMIT", ",", "0", ",", "0", ",", "object_name", ")", ";", "if", "(", "mmap_handle", "==", "NULL", ")", "{", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"CreateFileMapping\"", ")", ";", "return", "-", "1", ";", "}", "for", "(", "r", "=", "0", ";", "r", "<", "5", ";", "r", "++", ")", "{", "mmap_addr", "=", "MapViewOfFileEx", "(", "mmap_handle", ",", "FILE_MAP_COPY", ",", "0", ",", "offset", ",", "size", ",", "addr", ")", ";", "if", "(", "mmap_addr", "==", "addr", ")", "break", ";", "if", "(", "r", "!=", "4", ")", "Sleep", "(", "500", ")", ";", "}", "if", "(", "mmap_addr", "!=", "addr", ")", "{", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"MapViewOfFileEx\"", ")", ";", "CloseHandle", "(", "mmap_handle", ")", ";", "return", "-", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "ADDR", "is", "an", "address", "returned", "by", "gt_pch_get_address", ".", "Attempt", "to", "allocate", "SIZE", "bytes", "at", "the", "same", "address", "and", "load", "it", "with", "the", "data", "from", "FD", "at", "OFFSET", ".", "Return", "-1", "if", "we", "could", "n't", "allocate", "memory", "at", "ADDR", ",", "return", "0", "if", "the", "memory", "is", "allocated", "but", "the", "data", "not", "loaded", ",", "return", "1", "if", "done", "." ]

[ "i386", "0", "0", "1", "0", "1", "2", "4", "\"%lx\"", "0", "0", "\"CreateFileMapping\"", "1", "0", "5", "0", "4", "500", "\"MapViewOfFileEx\"", "1", "1" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_xchg_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_add_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_sub_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_nand_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_max_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_min_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_umax_i32", ":", "case", "Intrinsic", "::", "riscv_masked_atomicrmw_umin_i32", ":", "case", "Intrinsic", "::", "riscv_masked_cmpxchg_i32", ":", "PointerType", "*", "PtrTy", "=", "cast", "<", "PointerType", ">", "(", "I", ".", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "PtrTy", "->", "getElementType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "4", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "Intrinsic::riscv_masked_atomicrmw_xchg_i32", "Intrinsic::riscv_masked_atomicrmw_add_i32", "Intrinsic::riscv_masked_atomicrmw_sub_i32", "Intrinsic::riscv_masked_atomicrmw_nand_i32", "Intrinsic::riscv_masked_atomicrmw_max_i32", "Intrinsic::riscv_masked_atomicrmw_min_i32", "Intrinsic::riscv_masked_atomicrmw_umax_i32", "Intrinsic::riscv_masked_atomicrmw_umin_i32", "Intrinsic::riscv_masked_cmpxchg_i32", "0", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "void", "Initialize", "(", "const", "MachineFunction", "&", "MF", ",", "bool", "isPIC", ")", "{", "IsPIC", "=", "isPIC", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "bool", "rs6000_save_toc_in_prologue_p", "(", "void", ")", "{", "return", "(", "cfun", "&&", "cfun", "->", "machine", "&&", "cfun", "->", "machine", "->", "save_toc_in_prologue", ")", ";", "}", "</s>" ]

[ "Return", "whether", "we", "need", "to", "always", "update", "the", "saved", "TOC", "pointer", "when", "we", "update", "the", "stack", "pointer", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "rs6000_emit_allocate_stack", "(", "HOST_WIDE_INT", "size", ",", "rtx", "copy_reg", ",", "int", "copy_off", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "stack_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "rtx", "todec", "=", "gen_int_mode", "(", "-", "size", ",", "Pmode", ")", ";", "rtx", "par", ",", "set", ",", "mem", ";", "if", "(", "INTVAL", "(", "todec", ")", "!=", "-", "size", ")", "{", "warning", "(", "0", ",", "\"stack frame too large\"", ")", ";", "emit_insn", "(", "gen_trap", "(", ")", ")", ";", "return", ";", "}", "if", "(", "crtl", "->", "limit_stack", ")", "{", "if", "(", "REG_P", "(", "stack_limit_rtx", ")", "&&", "REGNO", "(", "stack_limit_rtx", ")", ">", "1", "&&", "REGNO", "(", "stack_limit_rtx", ")", "<=", "31", ")", "{", "emit_insn", "(", "gen_add3_insn", "(", "tmp_reg", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "stack_limit_rtx", ")", "==", "SYMBOL_REF", "&&", "TARGET_32BIT", "&&", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "rtx", "toload", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_elf_high", "(", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_elf_low", "(", "tmp_reg", ",", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "warning", "(", "0", ",", "\"stack limit expression is not supported\"", ")", ";", "}", "if", "(", "copy_reg", ")", "{", "if", "(", "copy_off", "!=", "0", ")", "emit_insn", "(", "gen_add3_insn", "(", "copy_reg", ",", "stack_reg", ",", "GEN_INT", "(", "copy_off", ")", ")", ")", ";", "else", "emit_move_insn", "(", "copy_reg", ",", "stack_reg", ")", ";", "}", "if", "(", "size", ">", "32767", ")", "{", "if", "(", "get_last_insn", "(", ")", "==", "NULL_RTX", ")", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "insn", "=", "emit_move_insn", "(", "tmp_reg", ",", "todec", ")", ";", "try_split", "(", "PATTERN", "(", "insn", ")", ",", "insn", ",", "0", ")", ";", "todec", "=", "tmp_reg", ";", "}", "insn", "=", "emit_insn", "(", "TARGET_32BIT", "?", "gen_movsi_update_stack", "(", "stack_reg", ",", "stack_reg", ",", "todec", ",", "stack_reg", ")", ":", "gen_movdi_di_update_stack", "(", "stack_reg", ",", "stack_reg", ",", "todec", ",", "stack_reg", ")", ")", ";", "par", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "par", ")", "==", "PARALLEL", ")", ";", "set", "=", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "mem", "=", "SET_DEST", "(", "set", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_frame_alias_set", "(", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_reg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_reg", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "correct", "code", "for", "allocating", "stack", "space", ",", "as", "insns", ".", "If", "COPY_R12", ",", "make", "sure", "a", "copy", "of", "the", "old", "frame", "is", "left", "in", "r12", ".", "The", "generated", "code", "may", "use", "hard", "register", "0", "as", "a", "temporary", "." ]

[ "rs6000", "0", "0", "\"stack frame too large\"", "1", "31", "0", "\"stack limit expression is not supported\"", "0", "32767", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "SDValue", "KudeyarTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "DebugLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "Kudeyar_INTR", ":", "report_fatal_error", "(", "\"ISRs cannot be called directly\"", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "Kudeyar", "Kudeyar", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "\"Unsupported calling convention\"", "Kudeyar", "\"ISRs cannot be called directly\"" ]

[]

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

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

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

[]

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

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

[ "CJG", "\"CJG DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "void", "LC2200AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "TmpInst", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "if", "(", "LowerLC2200MachineOperandToMCOperand", "(", "MO", ",", "MCOp", ",", "*", "this", ")", ")", "TmpInst", ".", "addOperand", "(", "MCOp", ")", ";", "}", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "LC2200" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetWin64", "(", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86", "X86::GR64_TCW64RegClass", "X86", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

[ "<s>", "const", "MCExpr", "*", "X86_64MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "(", "Encoding", "&", "DW_EH_PE_indirect", ")", "&&", "(", "Encoding", "&", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOTPCREL", ",", "getContext", "(", ")", ")", ";", "const", "MCExpr", "*", "Four", "=", "MCConstantExpr", "::", "Create", "(", "4", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "CreateAdd", "(", "Res", ",", "Four", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

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

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "analyzeLoop", "(", "MachineLoop", "&", "L", ",", "MachineInstr", "*", "&", "IndVarInst", ",", "MachineInstr", "*", "&", "CmpInst", ")", "const", "{", "MachineBasicBlock", "*", "LoopEnd", "=", "L", ".", "getBottomBlock", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "LoopEnd", "->", "getFirstTerminator", "(", ")", ";", "if", "(", "I", "!=", "LoopEnd", "->", "end", "(", ")", "&&", "isEndLoopN", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "IndVarInst", "=", "nullptr", ";", "CmpInst", "=", "&", "*", "I", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Analyze", "the", "loop", "code", ",", "return", "true", "if", "it", "can", "not", "be", "understood", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr128", ":", "SPU", "::", "STQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr16", ":", "SPU", "::", "STQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr8", ":", "SPU", "::", "STQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "STQDv16i8", ":", "SPU", "::", "STQXv16i8", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown regclass!\"", ")", ";", "}", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::STQDr128", "SPU::STQXr128", "SPU::R64CRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R64FPRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R32CRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R32FPRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R16CRegisterClass", "SPU::STQDr16", "SPU::STQXr16", "SPU::R8CRegisterClass", "SPU::STQDr8", "SPU::STQXr8", "SPU::VECREGRegisterClass", "SPU::STQDv16i8", "SPU::STQXv16i8", "\"Unknown regclass!\"" ]

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "ADJDYNALLOC", ":", "return", "\"HexagonISD::ADJDYNALLOC\"", ";", "case", "HexagonISD", "::", "CMPICC", ":", "return", "\"HexagonISD::CMPICC\"", ";", "case", "HexagonISD", "::", "CMPFCC", ":", "return", "\"HexagonISD::CMPFCC\"", ";", "case", "HexagonISD", "::", "BRICC", ":", "return", "\"HexagonISD::BRICC\"", ";", "case", "HexagonISD", "::", "BRFCC", ":", "return", "\"HexagonISD::BRFCC\"", ";", "case", "HexagonISD", "::", "SELECT_ICC", ":", "return", "\"HexagonISD::SELECT_ICC\"", ";", "case", "HexagonISD", "::", "SELECT_FCC", ":", "return", "\"HexagonISD::SELECT_FCC\"", ";", "case", "HexagonISD", "::", "Hi", ":", "return", "\"HexagonISD::Hi\"", ";", "case", "HexagonISD", "::", "Lo", ":", "return", "\"HexagonISD::Lo\"", ";", "case", "HexagonISD", "::", "FTOI", ":", "return", "\"HexagonISD::FTOI\"", ";", "case", "HexagonISD", "::", "ITOF", ":", "return", "\"HexagonISD::ITOF\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "BR_JT", ":", "return", "\"HexagonISD::BR_JT\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::ADJDYNALLOC", "\"HexagonISD::ADJDYNALLOC\"", "HexagonISD::CMPICC", "\"HexagonISD::CMPICC\"", "HexagonISD::CMPFCC", "\"HexagonISD::CMPFCC\"", "HexagonISD::BRICC", "\"HexagonISD::BRICC\"", "HexagonISD::BRFCC", "\"HexagonISD::BRFCC\"", "HexagonISD::SELECT_ICC", "\"HexagonISD::SELECT_ICC\"", "HexagonISD::SELECT_FCC", "\"HexagonISD::SELECT_FCC\"", "HexagonISD::Hi", "\"HexagonISD::Hi\"", "HexagonISD::Lo", "\"HexagonISD::Lo\"", "HexagonISD::FTOI", "\"HexagonISD::FTOI\"", "HexagonISD::ITOF", "\"HexagonISD::ITOF\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::BR_JT", "\"HexagonISD::BR_JT\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"" ]

[]