Datasets:

---

docz1105

/

ComBack

like 9

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

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

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TII", "=", "MF", ".", "getSubtarget", "<", "TGSISubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "OrderedBlks", ".", "clear", "(", ")", ";", "Visited", ".", "clear", "(", ")", ";", "FuncRep", "=", "&", "MF", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"LoopInfo:\\n\"", ";", "PrintLoopinfo", "(", "*", "MLI", ")", ";", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "DEBUG", "(", "MDT", "->", "print", "(", "dbgs", "(", ")", ",", "(", "const", "llvm", "::", "Module", "*", ")", "nullptr", ")", ";", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "DEBUG", "(", "PDT", "->", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "prepare", "(", ")", ";", "run", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "\"LoopInfo:\\n\"" ]

[]

[ "<s>", "static", "int", "ix86_mode_exit", "(", "int", "entity", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "X86_DIRFLAG_ANY", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_exit", "(", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "I387_CW_ANY", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "mode", "that", "ENTITY", "is", "assumed", "to", "be", "switched", "to", "at", "function", "exit", "." ]

[ "i386" ]

[]

[ "<s>", "static", "int", "aarch64_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "elements", ";", "const", "cpu_vector_cost", "*", "costs", "=", "aarch64_tune_params", ".", "vec_costs", ";", "bool", "fp", "=", "false", ";", "if", "(", "vectype", "!=", "NULL", ")", "fp", "=", "FLOAT_TYPE_P", "(", "vectype", ")", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "fp", "?", "costs", "->", "scalar_fp_stmt_cost", ":", "costs", "->", "scalar_int_stmt_cost", ";", "case", "scalar_load", ":", "return", "costs", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "costs", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "fp", "?", "costs", "->", "vec_fp_stmt_cost", ":", "costs", "->", "vec_int_stmt_cost", ";", "case", "vector_load", ":", "return", "costs", "->", "vec_align_load_cost", ";", "case", "vector_store", ":", "return", "costs", "->", "vec_store_cost", ";", "case", "vec_to_scalar", ":", "return", "costs", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "costs", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "case", "vector_gather_load", ":", "return", "costs", "->", "vec_unalign_load_cost", ";", "case", "unaligned_store", ":", "case", "vector_scatter_store", ":", "return", "costs", "->", "vec_unalign_store_cost", ";", "case", "cond_branch_taken", ":", "return", "costs", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "costs", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "return", "costs", "->", "vec_permute_cost", ";", "case", "vec_promote_demote", ":", "return", "fp", "?", "costs", "->", "vec_fp_stmt_cost", ":", "costs", "->", "vec_int_stmt_cost", ";", "case", "vec_construct", ":", "elements", "=", "estimated_poly_value", "(", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ")", ";", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_vectorization_cost", "." ]

[ "aarch64", "2", "1" ]

[]

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

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

[ "mips", "0" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPostFastRegAllocRewrite", "(", ")", "{", "addPass", "(", "createX86FastTileConfigPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "addPostFastRegAllocRewrite", "-", "Add", "passes", "to", "the", "optimized", "register", "allocation", "pipeline", "after", "fast", "register", "allocation", "is", "complete", "." ]

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

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasV8_1aOps", "(", "false", ")", ",", "HasV8_2aOps", "(", "false", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasPerfMon", "(", "false", ")", ",", "HasFullFP16", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "StrictAlign", "(", "false", ")", ",", "ReserveX18", "(", "TT", ".", "isOSDarwin", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<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", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "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", "=", "getStackSizeWithRVVPadding", "(", "MF", ")", ";", "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", "=", "getStackSizeWithRVVPadding", "(", "MF", ")", "-", "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", "AArch64LoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "Subtarget", "=", "&", "static_cast", "<", "const", "AArch64Subtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "ModifiedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "UsedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "bool", "enableNarrowLdOpt", "=", "Subtarget", "->", "mergeNarrowLoads", "(", ")", "&&", "!", "Subtarget", "->", "requiresStrictAlign", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ",", "enableNarrowLdOpt", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DstReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "ADDI", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Opc", ";", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_S", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_D", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::ADDI", "0", "RISCV::FPR32RegClass", "RISCV::FSGNJ_S", "RISCV::FPR64RegClass", "RISCV::FSGNJ_D", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isBranch", "(", ")", "&&", "isPredicated", "(", "MI", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "PPC", "::", "AddrMode", "PPCTargetLowering", "::", "SelectForceXFormMode", "(", "SDValue", "N", ",", "SDValue", "&", "Disp", ",", "SDValue", "&", "Base", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "PPC", "::", "AddrMode", "Mode", "=", "PPC", "::", "AM_XForm", ";", "int16_t", "ForceXFormImm", "=", "0", ";", "if", "(", "provablyDisjointOr", "(", "DAG", ",", "N", ")", "&&", "!", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "ForceXFormImm", ")", ")", "{", "Disp", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Base", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "Mode", ";", "}", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "(", "!", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "ForceXFormImm", ")", "||", "!", "N", ".", "getOperand", "(", "1", ")", ".", "hasOneUse", "(", ")", "||", "!", "N", ".", "getOperand", "(", "0", ")", ".", "hasOneUse", "(", ")", ")", ")", "{", "Disp", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Base", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "Mode", ";", "}", "Disp", "=", "DAG", ".", "getRegister", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "ZERO8", ":", "PPC", "::", "ZERO", ",", "N", ".", "getValueType", "(", ")", ")", ";", "Base", "=", "N", ";", "return", "Mode", ";", "}", "</s>" ]

[ "SelectForceXFormMode", "-", "Given", "the", "specified", "address", ",", "force", "it", "to", "be", "represented", "as", "an", "indexed", "[", "r+r", "]", "operation", "(", "an", "XForm", "instruction", ")", "." ]

[ "PowerPC", "PPC::AddrMode", "PPC", "PPC::AddrMode", "PPC::AM_XForm", "0", "1", "0", "1", "ISD::ADD", "1", "1", "0", "0", "1", "PPC", "PPC::ZERO8", "PPC::ZERO" ]

[]

[ "<s>", "static", "const", "char", "*", "generate_target_offloadend_file", "(", "const", "char", "*", "target_compiler", ")", "{", "const", "char", "*", "src_filename", "=", "make_temp_file", "(", "\"_target_offloadend.c\"", ")", ";", "const", "char", "*", "obj_filename", "=", "make_temp_file", "(", "\"_target_offloadend.o\"", ")", ";", "temp_files", "[", "num_temps", "++", "]", "=", "src_filename", ";", "temp_files", "[", "num_temps", "++", "]", "=", "obj_filename", ";", "FILE", "*", "src_file", "=", "fopen", "(", "src_filename", ",", "\"w\"", ")", ";", "if", "(", "!", "src_file", ")", "fatal_error", "(", "input_location", ",", "\"cannot open '%s'\"", ",", "src_filename", ")", ";", "fprintf", "(", "src_file", ",", "\"void *__offload_funcs_end[0]\\n\"", "\"__attribute__ ((__used__, visibility (\\\"hidden\\\"),\\n\"", "\"section (\\\".gnu.offload_funcs\\\"))) = { };\\n\\n\"", "\"void *__offload_vars_end[0]\\n\"", "\"__attribute__ ((__used__, visibility (\\\"hidden\\\"),\\n\"", "\"section (\\\".gnu.offload_vars\\\"))) = { };\\n\"", ")", ";", "fclose", "(", "src_file", ")", ";", "struct", "obstack", "argv_obstack", ";", "obstack_init", "(", "&", "argv_obstack", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "target_compiler", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-c\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-shared\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-fPIC\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "src_filename", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-o\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "obj_filename", ")", ";", "compile_for_target", "(", "&", "argv_obstack", ")", ";", "return", "obj_filename", ";", "}", "</s>" ]

[ "Generates", "object", "file", "with", "__offload_", "*", "_end", "symbols", "for", "the", "target", "library", "." ]

[ "i386", "\"_target_offloadend.c\"", "\"_target_offloadend.o\"", "\"w\"", "\"cannot open '%s'\"", "\"void *__offload_funcs_end[0]\\n\"", "\"__attribute__ ((__used__, visibility (\\\"hidden\\\"),\\n\"", "\"section (\\\".gnu.offload_funcs\\\"))) = { };\\n\\n\"", "\"void *__offload_vars_end[0]\\n\"", "\"__attribute__ ((__used__, visibility (\\\"hidden\\\"),\\n\"", "\"section (\\\".gnu.offload_vars\\\"))) = { };\\n\"", "\"-c\"", "\"-shared\"", "\"-fPIC\"", "\"-o\"" ]

[]

[ "<s>", "bool", "storeOfVectorConstantIsCheap", "(", "EVT", "MemVT", ",", "unsigned", "NumElem", ",", "unsigned", "AddrSpace", ")", "const", "override", "{", "return", "NumElem", ">", "2", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "expected", "to", "be", "cheaper", "to", "do", "a", "store", "of", "vector", "constant", "with", "the", "given", "size", "and", "type", "for", "the", "address", "space", "than", "to", "store", "the", "individual", "scalar", "element", "constants", "." ]

[ "X86", "2" ]

[]

[ "<s>", "void", "c4x_override_options", "(", ")", "{", "if", "(", "c4x_rpts_cycles_string", ")", "c4x_rpts_cycles", "=", "atoi", "(", "c4x_rpts_cycles_string", ")", ";", "else", "c4x_rpts_cycles", "=", "0", ";", "if", "(", "TARGET_C30", ")", "c4x_cpu_version", "=", "30", ";", "else", "if", "(", "TARGET_C31", ")", "c4x_cpu_version", "=", "31", ";", "else", "if", "(", "TARGET_C32", ")", "c4x_cpu_version", "=", "32", ";", "else", "if", "(", "TARGET_C33", ")", "c4x_cpu_version", "=", "33", ";", "else", "if", "(", "TARGET_C40", ")", "c4x_cpu_version", "=", "40", ";", "else", "if", "(", "TARGET_C44", ")", "c4x_cpu_version", "=", "44", ";", "else", "c4x_cpu_version", "=", "40", ";", "if", "(", "c4x_cpu_version_string", ")", "{", "const", "char", "*", "p", "=", "c4x_cpu_version_string", ";", "if", "(", "*", "p", "==", "'c'", "||", "*", "p", "==", "'C'", ")", "p", "++", ";", "c4x_cpu_version", "=", "atoi", "(", "p", ")", ";", "}", "target_flags", "&=", "~", "(", "C30_FLAG", "|", "C31_FLAG", "|", "C32_FLAG", "|", "C33_FLAG", "|", "C40_FLAG", "|", "C44_FLAG", ")", ";", "switch", "(", "c4x_cpu_version", ")", "{", "case", "30", ":", "target_flags", "|=", "C30_FLAG", ";", "break", ";", "case", "31", ":", "target_flags", "|=", "C31_FLAG", ";", "break", ";", "case", "32", ":", "target_flags", "|=", "C32_FLAG", ";", "break", ";", "case", "33", ":", "target_flags", "|=", "C33_FLAG", ";", "break", ";", "case", "40", ":", "target_flags", "|=", "C40_FLAG", ";", "break", ";", "case", "44", ":", "target_flags", "|=", "C44_FLAG", ";", "break", ";", "default", ":", "warning", "(", "\"unknown CPU version %d, using 40.\\n\"", ",", "c4x_cpu_version", ")", ";", "c4x_cpu_version", "=", "40", ";", "target_flags", "|=", "C40_FLAG", ";", "}", "if", "(", "TARGET_C30", "||", "TARGET_C31", "||", "TARGET_C32", "||", "TARGET_C33", ")", "target_flags", "|=", "C3X_FLAG", ";", "else", "target_flags", "&=", "~", "C3X_FLAG", ";", "set_fast_math_flags", "(", ")", ";", "if", "(", "!", "TARGET_ALIASES", "&&", "!", "flag_argument_noalias", ")", "flag_argument_noalias", "=", "1", ";", "c4x_add_gc_roots", "(", ")", ";", "}", "</s>" ]

[ "Override", "command", "line", "options", ".", "Called", "once", "after", "all", "options", "have", "been", "parsed", ".", "Mostly", "we", "process", "the", "processor", "type", "and", "sometimes", "adjust", "other", "TARGET_", "options", "." ]

[ "c4x", "0", "30", "31", "32", "33", "40", "44", "40", "30", "31", "32", "33", "40", "44", "\"unknown CPU version %d, using 40.\\n\"", "40", "1" ]

[]

[ "<s>", "static", "rtx", "m32r_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "return", "(", "PASS_IN_REG_P", "(", "*", "cum", ",", "mode", ",", "type", ")", "?", "gen_rtx_REG", "(", "mode", ",", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "mode", ",", "type", ")", ")", ":", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "On", "the", "M32R", "the", "first", "M32R_MAX_PARM_REGS", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "." ]

[ "m32r" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "createPPCMachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "int", "csky_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "code", "==", "REG", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "if", "(", "code", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "COSTS_N_INSNS", "(", "3", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ADDRESS_COST", "to", "estimate", "cost", "of", "the", "memory", "address", "X", ".", "For", "C-SKY", ",", "(", "register", ")", "and", "(", "register", "+", "offset", ")", "have", "the", "same", "cost", ".", "Other", "situations", "cost", "more", "." ]

[ "csky", "1", "0", "1", "1", "3" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "TargetRegisterInfo", "&", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ")", "return", "0", ";", "static", "const", "uint16_t", "CallerSavedRegs32Bit", "[", "]", "=", "{", "X86", "::", "EAX", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "0", "}", ";", "static", "const", "uint16_t", "CallerSavedRegs64Bit", "[", "]", "=", "{", "X86", "::", "RAX", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "RSI", ",", "X86", "::", "RDI", ",", "X86", "::", "R8", ",", "X86", "::", "R9", ",", "X86", "::", "R10", ",", "X86", "::", "R11", ",", "0", "}", ";", "unsigned", "Opc", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETI", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "&", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "const", "uint16_t", "*", "CS", "=", "Is64Bit", "?", "CallerSavedRegs64Bit", ":", "CallerSavedRegs32Bit", ";", "for", "(", ";", "*", "CS", ";", "++", "CS", ")", "if", "(", "!", "Uses", ".", "count", "(", "*", "CS", ")", ")", "return", "*", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "0", "X86::EAX", "X86::EDX", "X86::ECX", "0", "X86::RAX", "X86::RDX", "X86::RCX", "X86::RSI", "X86::RDI", "X86::R8", "X86::R9", "X86::R10", "X86::R11", "0", "0", "X86::RET", "X86::RETI", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "0" ]

[]

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

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", ".", "Determine", "if", "it", "'s", "legal", "to", "put", "X", "into", "the", "constant", "pool", ".", "This", "is", "not", "possible", "for", "the", "address", "of", "thread-local", "symbols", ",", "which", "is", "checked", "above", "." ]

[ "csky" ]

[]

[ "<s>", "static", "rtx", "nds32_expand_unop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ",", "bool", "return_p", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "nds32_read_argument", "(", "exp", ",", "0", ")", ";", "int", "op0_num", "=", "return_p", "?", "1", ":", "0", ";", "if", "(", "return_p", ")", "target", "=", "nds32_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "nds32_legitimize_argument", "(", "icode", ",", "op0_num", ",", "op0", ")", ";", "if", "(", "return_p", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "one", "operand", "." ]

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

[]

[ "<s>", "static", "void", "sparc64_initialize_trampoline", "(", "rtx", "m_tramp", ",", "rtx", "fnaddr", ",", "rtx", "cxt", ")", "{", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "0", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x83414000", ",", "SImode", ")", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "4", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0xca586018", ",", "SImode", ")", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "8", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x81c14000", ",", "SImode", ")", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "12", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0xca586010", ",", "SImode", ")", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "16", ")", ",", "cxt", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "24", ")", ",", "fnaddr", ")", ";", "emit_insn", "(", "gen_flushdi", "(", "validize_mem", "(", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "0", ")", ")", ")", ")", ";", "if", "(", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC", "&&", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC3", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA2", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA3", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA4", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA7", ")", "emit_insn", "(", "gen_flushdi", "(", "validize_mem", "(", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "8", ")", ")", ")", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "The", "64", "bit", "version", "is", "simpler", "because", "it", "makes", "more", "sense", "to", "load", "the", "values", "as", "``", "immediate", "''", "data", "out", "of", "the", "trampoline", ".", "It", "'s", "also", "easier", "since", "we", "can", "read", "the", "PC", "without", "clobbering", "a", "register", "." ]

[ "sparc", "0", "0x83414000", "4", "0xca586018", "8", "0x81c14000", "12", "0xca586010", "16", "24", "0", "8", "\"__enable_execute_stack\"", "1", "0" ]

[]

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

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

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

[]

[ "<s>", "SparcSubtarget", "&", "SparcSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "IsV9", "=", "false", ";", "V8DeprecatedInsts", "=", "false", ";", "IsVIS", "=", "false", ";", "HasHardQuad", "=", "false", ";", "UsePopc", "=", "false", ";", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "(", "Is64Bit", ")", "?", "\"v9\"", ":", "\"v8\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "!", "IsV9", ")", "UsePopc", "=", "false", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "\"v9\"", "\"v8\"" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MII", ".", "get", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "ThumbArithFlagSetting", ")", "{", "assert", "(", "MCID", ".", "hasOptionalDef", "(", ")", "&&", "\"optionally flag setting instruction missing optional def operand\"", ")", ";", "assert", "(", "MCID", ".", "NumOperands", "==", "Inst", ".", "getNumOperands", "(", ")", "&&", "\"operand count mismatch!\"", ")", ";", "unsigned", "OpNo", ";", "for", "(", "OpNo", "=", "0", ";", "!", "MCID", ".", "OpInfo", "[", "OpNo", "]", ".", "isOptionalDef", "(", ")", "&&", "OpNo", "<", "MCID", ".", "NumOperands", ";", "++", "OpNo", ")", ";", "if", "(", "isThumbOne", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "Match_RequiresFlagSetting", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", "&&", "!", "inITBlock", "(", ")", ")", "return", "Match_RequiresITBlock", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "inITBlock", "(", ")", ")", "return", "Match_RequiresNotITBlock", ";", "}", "else", "if", "(", "isThumbOne", "(", ")", ")", "{", "if", "(", "Opc", "==", "ARM", "::", "tADDhirr", "&&", "!", "hasV6MOps", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresThumb2", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "tMOVr", "&&", "!", "hasV6Ops", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresV6", ";", "}", "if", "(", "Opc", "==", "ARM", "::", "t2MOVr", "&&", "!", "hasV8Ops", "(", ")", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", "&&", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "return", "Match_RequiresV8", ";", "if", "(", "Inst", ".", "getOperand", "(", "4", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", "||", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", ")", "return", "Match_RequiresV8", ";", "}", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "MCID", ".", "NumOperands", ";", "++", "I", ")", "if", "(", "MCID", ".", "OpInfo", "[", "I", "]", ".", "RegClass", "==", "ARM", "::", "rGPRRegClassID", ")", "{", "if", "(", "(", "Inst", ".", "getOperand", "(", "I", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "&&", "!", "hasV8Ops", "(", ")", ")", "return", "Match_RequiresV8", ";", "else", "if", "(", "Inst", ".", "getOperand", "(", "I", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "PC", ")", "return", "Match_InvalidOperand", ";", "}", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "ARM", "ARM", "ARMII::ThumbArithFlagSetting", "\"optionally flag setting instruction missing optional def operand\"", "\"operand count mismatch!\"", "0", "ARM::CPSR", "ARM::CPSR", "ARM::CPSR", "ARM::tADDhirr", "ARM", "1", "ARM", "2", "ARM::tMOVr", "ARM", "0", "ARM", "1", "ARM::t2MOVr", "0", "ARM::SP", "1", "ARM::SP", "4", "ARM::CPSR", "0", "ARM::SP", "1", "ARM::SP", "0", "ARM::rGPRRegClassID", "ARM::SP", "ARM::PC" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AMDGPURegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "&", "CalleeSavedReg", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilderBase", "&", "IRB", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSContiki", "(", ")", ")", "return", "getDefaultSafeStackPointerLocation", "(", "IRB", ",", "false", ")", ";", "if", "(", "Subtarget", ".", "isTargetAndroid", "(", ")", ")", "{", "int", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "?", "0x48", ":", "0x24", ";", "return", "SegmentOffset", "(", "IRB", ",", "Offset", ",", "getAddressSpace", "(", ")", ")", ";", "}", "if", "(", "Subtarget", ".", "isTargetFuchsia", "(", ")", ")", "{", "return", "SegmentOffset", "(", "IRB", ",", "0x18", ",", "getAddressSpace", "(", ")", ")", ";", "}", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "X86", "X86", "0x48", "0x24", "0x18" ]

[]

[ "<s>", "bool", "X86InstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "const", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCopy", "(", "I", ",", "TII", ",", "MRI", ",", "TRI", ",", "RBI", ")", ";", "return", "true", ";", "}", "assert", "(", "I", ".", "getNumOperands", "(", ")", "==", "I", ".", "getNumExplicitOperands", "(", ")", "&&", "\"Generic instruction has unexpected implicit operands\\n\"", ")", ";", "return", "selectImpl", "(", "I", ")", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "X86", "X86", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "\"Generic instruction has unexpected implicit operands\\n\"" ]

[]

[ "<s>", "const", "PatmosInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "InstrInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "int", "arc_attr_type", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", ":", "JUMP_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", ")", ":", "!", "CALL_P", "(", "insn", ")", ")", "return", "-", "1", ";", "return", "get_attr_type", "(", "insn", ")", ";", "}", "</s>" ]

[ "Return", "the", "integer", "value", "of", "the", "``", "type", "''", "attribute", "for", "INSN", ",", "or", "-1", "if", "INSN", "ca", "n't", "have", "attributes", "." ]

[ "arc", "1" ]

[]

[ "<s>", "bool", "AMDGPULowerIntrinsics", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", ")", "continue", ";", "switch", "(", "F", ".", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "memcpy", ":", "case", "Intrinsic", "::", "memmove", ":", "case", "Intrinsic", "::", "memset", ":", "if", "(", "expandMemIntrinsicUses", "(", "F", ")", ")", "Changed", "=", "true", ";", "break", ";", "case", "Intrinsic", "::", "r600_read_tidig_x", ":", "case", "Intrinsic", "::", "r600_read_tidig_y", ":", "case", "Intrinsic", "::", "r600_read_tidig_z", ":", "case", "Intrinsic", "::", "r600_read_local_size_x", ":", "case", "Intrinsic", "::", "r600_read_local_size_y", ":", "case", "Intrinsic", "::", "r600_read_local_size_z", ":", "Changed", "|=", "makeLIDRangeMetadata", "(", "F", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "Intrinsic::memcpy", "Intrinsic::memmove", "Intrinsic::memset", "Intrinsic::r600_read_tidig_x", "Intrinsic::r600_read_tidig_y", "Intrinsic::r600_read_tidig_z", "Intrinsic::r600_read_local_size_x", "Intrinsic::r600_read_local_size_y", "Intrinsic::r600_read_local_size_z" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0x60000000", ")", ";", "switch", "(", "Count", "%", "4", ")", "{", "default", ":", "break", ";", "case", "1", ":", "OW", "->", "Write8", "(", "0", ")", ";", "break", ";", "case", "2", ":", "OW", "->", "Write16", "(", "0", ")", ";", "break", ";", "case", "3", ":", "OW", "->", "Write16", "(", "0", ")", ";", "OW", "->", "Write8", "(", "0", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "4", "0", "0x60000000", "4", "1", "0", "2", "0", "3", "0", "0" ]

[]

[ "<s>", "bool", "PPCLoopDataPrefetch", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolution", ">", "(", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "AC", "=", "&", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "TTI", "=", "&", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "LoopInfo", "::", "iterator", "I", "=", "LI", "->", "begin", "(", ")", ",", "E", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Loop", "*", "L", "=", "*", "I", ";", "MadeChange", "|=", "runOnLoop", "(", "L", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "PTXAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "std", "::", "string", "str", ";", "str", ".", "reserve", "(", "64", ")", ";", "raw_string_ostream", "OS", "(", "str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OS", "<<", "';'", ";", "OS", ".", "flush", "(", ")", ";", "size_t", "pos", ";", "if", "(", "(", "pos", "=", "str", ".", "find", "(", "\"%type\"", ")", ")", "!=", "std", "::", "string", "::", "npos", ")", "str", ".", "replace", "(", "pos", ",", "5", ",", "getInstructionTypeName", "(", "MI", ")", ")", ";", "StringRef", "strref", "=", "StringRef", "(", "str", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "strref", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "64", "\"%type\"", "5" ]

[]

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

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

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

[]

[ "<s>", "void", "XNCMAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "XNCMMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "Mang", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "TPCPipeliner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "EnablePipelining", ")", "{", "return", "false", ";", "}", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "LMF", "=", "&", "MF", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "L", ":", "*", "MLI", ")", "{", "Changed", "|=", "findInnermostLoop", "(", "L", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "bpf_small_register_classes_for_mode_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_XBPF", ")", "return", "1", ";", "else", "return", "(", "mode", "!=", "FUNCTION_MODE", ")", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "small_register_classes_for_mode_p", "." ]

[ "bpf", "1" ]

[]

[ "<s>", "bool", "HexagonOptAddrMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetOperandInfo", "TOI", "(", "*", "HII", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "*", "HII", ",", "TRI", ",", "*", "MDT", ",", "MDF", ",", "TOI", ")", ";", "G", ".", "build", "(", "BuildOptions", "::", "KeepDeadPhis", ")", ";", "DFG", "=", "&", "G", ";", "Liveness", "L", "(", "MRI", ",", "*", "DFG", ")", ";", "L", ".", "computePhiInfo", "(", ")", ";", "LV", "=", "&", "L", ";", "Deleted", ".", "clear", "(", ")", ";", "NodeAddr", "<", "FuncNode", "*", ">", "FA", "=", "DFG", "->", "getFunc", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"==== [RefMap#]=====:\\n \"", "<<", "Print", "<", "NodeAddr", "<", "FuncNode", "*", ">>", "(", "FA", ",", "*", "DFG", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "FA", ".", "Addr", "->", "members", "(", "*", "DFG", ")", ")", "Changed", "|=", "processBlock", "(", "BA", ")", ";", "for", "(", "auto", "MI", ":", "Deleted", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "Changed", ")", "{", "G", ".", "build", "(", ")", ";", "L", ".", "computeLiveIns", "(", ")", ";", "L", ".", "resetLiveIns", "(", ")", ";", "L", ".", "resetKills", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"==== [RefMap#]=====:\\n \"", "\"\\n\"" ]

[]

[ "<s>", "void", "lm32_expand_scc", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "target", "=", "operands", "[", "0", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "2", "]", ";", "rtx", "op1", "=", "operands", "[", "3", "]", ";", "gen_int_relational", "(", "code", ",", "target", ",", "op0", ",", "op1", ",", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "Try", "performing", "the", "comparison", "in", "OPERANDS", "[", "1", "]", ",", "whose", "arms", "are", "OPERANDS", "[", "2", "]", "and", "OPERAND", "[", "3", "]", ".", "Store", "the", "result", "in", "OPERANDS", "[", "0", "]", "." ]

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

[]

[ "<s>", "static", "void", "sparc_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "regno", ",", "padding", ";", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "false", ",", "&", "regno", ",", "&", "padding", ")", ";", "cum", "->", "words", "+=", "padding", ";", "if", "(", "TARGET_ARCH32", ")", "cum", "->", "words", "+=", "CEIL_NWORDS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "else", "{", "if", "(", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "VECTOR_FLOAT_TYPE_P", "(", "type", ")", ")", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", "<=", "0", ")", "cum", "->", "words", "++", ";", "else", "cum", "->", "words", "+=", "CEIL_NWORDS", "(", "size", ")", ";", "}", "else", "cum", "->", "words", "+=", "CEIL_NWORDS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "}", "</s>" ]

[ "Handle", "the", "TARGET_FUNCTION_ARG_ADVANCE", "hook", ".", "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "static", "bool", "any_sibcall_could_use_r3", "(", "void", ")", "{", "edge_iterator", "ei", ";", "edge", "e", ";", "if", "(", "!", "crtl", "->", "tail_call_emit", ")", "return", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "if", "(", "e", "->", "flags", "&", "EDGE_SIBCALL", ")", "{", "rtx_insn", "*", "call", "=", "BB_END", "(", "e", "->", "src", ")", ";", "if", "(", "!", "CALL_P", "(", "call", ")", ")", "call", "=", "prev_nonnote_nondebug_insn", "(", "call", ")", ";", "gcc_assert", "(", "CALL_P", "(", "call", ")", "&&", "SIBLING_CALL_P", "(", "call", ")", ")", ";", "if", "(", "find_regno_fusage", "(", "call", ",", "USE", ",", "3", ")", "||", "is_indirect_tailcall_p", "(", "call", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "r3", "is", "used", "by", "any", "of", "the", "tail", "call", "insns", "in", "the", "current", "function", "." ]

[ "arm", "3" ]

[]

[ "<s>", "static", "tree", "bfin_handle_l1_data_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "ARG_UNUSED", "(", "args", ")", ",", "int", "ARG_UNUSED", "(", "flags", ")", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "decl", "=", "*", "node", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "{", "error", "(", "\"%qE attribute only applies to variables\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "current_function_decl", "!=", "NULL_TREE", "&&", "!", "TREE_STATIC", "(", "decl", ")", ")", "{", "error", "(", "\"%qE attribute cannot be specified for local variables\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "{", "const", "char", "*", "section_name", ";", "if", "(", "strcmp", "(", "IDENTIFIER_POINTER", "(", "name", ")", ",", "\"l1_data\"", ")", "==", "0", ")", "section_name", "=", "\".l1.data\"", ";", "else", "if", "(", "strcmp", "(", "IDENTIFIER_POINTER", "(", "name", ")", ",", "\"l1_data_A\"", ")", "==", "0", ")", "section_name", "=", "\".l1.data.A\"", ";", "else", "if", "(", "strcmp", "(", "IDENTIFIER_POINTER", "(", "name", ")", ",", "\"l1_data_B\"", ")", "==", "0", ")", "section_name", "=", "\".l1.data.B\"", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "NULL", "&&", "strcmp", "(", "DECL_SECTION_NAME", "(", "decl", ")", ",", "section_name", ")", "!=", "0", ")", "{", "error", "(", "\"section of %q+D conflicts with previous declaration\"", ",", "decl", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "set_decl_section_name", "(", "decl", ",", "section_name", ")", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "l1_data", "''", ",", "``", "l1_data_A", "''", "or", "``", "l1_data_B", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "bfin", "\"%qE attribute only applies to variables\"", "\"%qE attribute cannot be specified for local variables\"", "\"l1_data\"", "0", "\".l1.data\"", "\"l1_data_A\"", "0", "\".l1.data.A\"", "\"l1_data_B\"", "0", "\".l1.data.B\"", "0", "\"section of %q+D conflicts with previous declaration\"" ]

[]

[ "<s>", "unsigned", "TL45InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "TL45", "::", "JMPI", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "4", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "unsigned", "JmpOpc", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "JmpOpc", "==", "TL45", "::", "CMP_JMP", "||", "JmpOpc", "==", "TL45", "::", "CMPI_JMP", ")", "{", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "JmpOpc", ")", ")", ".", "add", "(", "Cond", ".", "slice", "(", "1", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "Count", "++", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ")", ",", "TL45", "::", "r0", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "add", "(", "Cond", "[", "3", "]", ")", ";", "Count", "++", ";", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "Count", "++", ";", "}", "if", "(", "FBB", ")", "{", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "TL45", "::", "JMPI", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "Count", "++", ";", "}", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "(", "int", ")", "Count", "*", "4", ";", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "TL45", "TL45", "0", "\"Unconditional branch with multiple successors!\"", "TL45::JMPI", "4", "1", "0", "0", "TL45::CMP_JMP", "TL45::CMPI_JMP", "1", "1", "TL45::r0", "2", "3", "0", "TL45::JMPI", "4" ]

[]

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

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

[ "riscv" ]

[]

[ "<s>", "DFAPacketizer", "*", "R600InstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getInstrItineraryData", "(", ")", ";", "return", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "}", "</s>" ]

[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]

[ "R600" ]

[]

[ "<s>", "unsigned", "X86FrameLowering", "::", "getWinEHFuncletFrameSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CSSize", "=", "X86FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "auto", "&", "WinEHXMMSlotInfo", "=", "X86FI", "->", "getWinEHXMMSlotInfo", "(", ")", ";", "unsigned", "XMMSize", "=", "WinEHXMMSlotInfo", ".", "size", "(", ")", "*", "TRI", "->", "getSpillSize", "(", "X86", "::", "VR128RegClass", ")", ";", "unsigned", "UsedSize", ";", "EHPersonality", "Personality", "=", "classifyEHPersonality", "(", "MF", ".", "getFunction", "(", ")", ".", "getPersonalityFn", "(", ")", ")", ";", "if", "(", "Personality", "==", "EHPersonality", "::", "CoreCLR", ")", "{", "UsedSize", "=", "getPSPSlotOffsetFromSP", "(", "MF", ")", "+", "SlotSize", ";", "}", "else", "{", "UsedSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getMaxCallFrameSize", "(", ")", ";", "}", "unsigned", "FrameSizeMinusRBP", "=", "alignTo", "(", "CSSize", "+", "UsedSize", ",", "getStackAlign", "(", ")", ")", ";", "return", "FrameSizeMinusRBP", "+", "XMMSize", "-", "CSSize", ";", "}", "</s>" ]

[ "Funclets", "only", "need", "to", "account", "for", "space", "for", "the", "callee", "saved", "registers", ",", "as", "the", "locals", "are", "accounted", "for", "in", "the", "parent", "'s", "stack", "frame", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86::VR128RegClass" ]

[]

[ "<s>", "void", "XCoreAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "O", "(", "Str", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "XCore", "::", "DBG_VALUE", ":", "llvm_unreachable", "(", "\"Should be handled target independently\"", ")", ";", "case", "XCore", "::", "ADD_2rus", ":", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "O", "<<", "\"\\tmov \"", "<<", "XCoreInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "<<", "\", \"", "<<", "XCoreInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "O", ".", "str", "(", ")", ")", ";", "return", ";", "}", "break", ";", "case", "XCore", "::", "BR_JT", ":", "case", "XCore", "::", "BR_JT32", ":", "O", "<<", "\"\\tbru \"", "<<", "XCoreInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "<<", "'\\n'", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "BR_JT", ")", "printInlineJT", "(", "MI", ",", "0", ",", "O", ")", ";", "else", "printInlineJT32", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "'\\n'", ";", "OutStreamer", ".", "EmitRawText", "(", "O", ".", "str", "(", ")", ")", ";", "return", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "128", "XCore::DBG_VALUE", "\"Should be handled target independently\"", "XCore::ADD_2rus", "2", "0", "\"\\tmov \"", "XCore", "0", "\", \"", "XCore", "1", "XCore::BR_JT", "XCore::BR_JT32", "\"\\tbru \"", "XCore", "1", "XCore::BR_JT", "0", "0" ]

[]

[ "<s>", "void", "LC3InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "LC3", "LC3" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "union", "{", "int32_t", "I", ";", "float", "F", ";", "}", "Imm", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "Imm", ".", "I", "=", "MO", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "Imm", ".", "F", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ".", "convertToFloat", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "return", "(", "Imm", ".", "I", ">=", "-", "16", "&&", "Imm", ".", "I", "<=", "64", ")", "||", "Imm", ".", "F", "==", "0.0f", "||", "Imm", ".", "F", "==", "0.5f", "||", "Imm", ".", "F", "==", "-", "0.5f", "||", "Imm", ".", "F", "==", "1.0f", "||", "Imm", ".", "F", "==", "-", "1.0f", "||", "Imm", ".", "F", "==", "2.0f", "||", "Imm", ".", "F", "==", "-", "2.0f", "||", "Imm", ".", "F", "==", "4.0f", "||", "Imm", ".", "F", "==", "-", "4.0f", ";", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "R600", "SI", "16", "64", "0.0f", "0.5f", "0.5f", "1.0f", "1.0f", "2.0f", "2.0f", "4.0f", "4.0f" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ARM64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARM64FunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "2", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "arc_allocate_stack_slots_for_args", "(", "void", ")", "{", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "return", "!", "ARC_NAKED_P", "(", "fn_type", ")", ";", "}", "</s>" ]

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

[ "arc" ]

[]

[ "<s>", "int", "first_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "13", ";", "first_reg", "<=", "31", ";", "first_reg", "++", ")", "if", "(", "save_reg_p", "(", "first_reg", ")", ")", "break", ";", "if", "(", "flag_pic", "&&", "crtl", "->", "uses_pic_offset_table", "&&", "first_reg", ">", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", "return", "RS6000_PIC_OFFSET_TABLE_REGNUM", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Return", "the", "first", "register", "that", "is", "required", "to", "be", "saved", ".", "16", "if", "none", "." ]

[ "rs6000", "13", "31" ]

[]

[ "<s>", "static", "void", "nds32_group_insns", "(", "rtx_insn", "*", "sethi", ")", "{", "df_ref", "def_record", ",", "use_record", ";", "df_link", "*", "link", ";", "rtx_insn", "*", "use_insn", "=", "NULL", ";", "rtx", "group_id", ";", "bool", "valid", ";", "def_record", "=", "DF_INSN_DEFS", "(", "sethi", ")", ";", "for", "(", "link", "=", "DF_REF_CHAIN", "(", "def_record", ")", ";", "link", ";", "link", "=", "link", "->", "next", ")", "{", "if", "(", "!", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "continue", ";", "use_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "dominated_by_p", "(", "CDI_DOMINATORS", ",", "BLOCK_FOR_INSN", "(", "use_insn", ")", ",", "BLOCK_FOR_INSN", "(", "sethi", ")", ")", ")", "return", ";", "use_record", "=", "DF_INSN_USES", "(", "use_insn", ")", ";", "if", "(", "DF_REF_CHAIN", "(", "use_record", ")", "&&", "DF_REF_CHAIN", "(", "use_record", ")", "->", "next", ")", "return", ";", "if", "(", "!", "active_insn_p", "(", "use_insn", ")", ")", "return", ";", "if", "(", "!", "(", "recog_memoized", "(", "use_insn", ")", "==", "CODE_FOR_lo_sum", "||", "nds32_symbol_load_store_p", "(", "use_insn", ")", "||", "(", "nds32_reg_base_load_store_p", "(", "use_insn", ")", "&&", "!", "nds32_sp_base_or_plus_load_store_p", "(", "use_insn", ")", ")", ")", ")", "return", ";", "}", "group_id", "=", "GEN_INT", "(", "nds32_alloc_relax_group_id", "(", ")", ")", ";", "emit_insn_before", "(", "gen_relax_group", "(", "group_id", ")", ",", "sethi", ")", ";", "for", "(", "link", "=", "DF_REF_CHAIN", "(", "def_record", ")", ";", "link", ";", "link", "=", "link", "->", "next", ")", "{", "if", "(", "!", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "continue", ";", "use_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "active_insn_p", "(", "use_insn", ")", ")", "emit_insn_before", "(", "gen_relax_group", "(", "group_id", ")", ",", "use_insn", ")", ";", "if", "(", "use_insn", "!=", "NULL", "&&", "recog_memoized", "(", "use_insn", ")", "==", "CODE_FOR_lo_sum", "&&", "!", "nds32_const_unspec_p", "(", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "use_insn", ")", ")", ",", "1", ")", ")", ")", "{", "int", "sym_type", "=", "nds32_pic_tls_symbol_type", "(", "use_insn", ")", ";", "valid", "=", "nds32_pic_tls_group", "(", "use_insn", ",", "RELAX_ORI", ",", "sym_type", ")", ";", "while", "(", "!", "nds32_group_infos", ".", "is_empty", "(", ")", ")", "{", "use_insn", "=", "nds32_group_infos", ".", "pop", "(", ")", ";", "if", "(", "valid", ")", "emit_insn_before", "(", "gen_relax_group", "(", "group_id", ")", ",", "use_insn", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Group", "the", "relax", "candidates", "with", "group", "id", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "void", "pa_asm_output_aligned_bss", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "switch_to_section", "(", "bss_section", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.align %u\\n\"", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "stream", ",", "name", ",", "\"object\"", ")", ";", "ASM_OUTPUT_SIZE_DIRECTIVE", "(", "stream", ",", "name", ",", "size", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.align %u\\n\"", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "ASM_OUTPUT_LABEL", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.block \"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\"\\n\"", ",", "size", ")", ";", "}", "</s>" ]

[ "This", "function", "places", "uninitialized", "global", "data", "in", "the", "bss", "section", ".", "The", "ASM_OUTPUT_ALIGNED_BSS", "macro", "needs", "to", "be", "defined", "to", "call", "this", "function", "on", "the", "SOM", "port", "to", "prevent", "uninitialized", "global", "data", "from", "being", "placed", "in", "the", "data", "section", "." ]

[ "pa", "\"\\t.align %u\\n\"", "\"object\"", "\"\\t.align %u\\n\"", "\"\\t.block \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ")", "!=", "Inst", ".", "getOpcode", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "output_addr_const", "(", "file", ",", "x", ")", ";", "if", "(", "small_data_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"@%s(%s)\"", ",", "SMALL_DATA_RELOC", ",", "reg_names", "[", "SMALL_DATA_REG", "]", ")", ";", "else", "gcc_assert", "(", "!", "TARGET_TOC", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "if", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "0", ")", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"(%s)\"", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "fprintf", "(", "file", ",", "\"lo16(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\")(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "toc_relative_expr_p", "(", "x", ",", "false", ")", ")", "{", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_base", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XVECEXP", "(", "tocrel_base", ",", "0", ",", "1", ")", ")", "]", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "powerpcspe", "\"0(%s)\"", "\"@%s(%s)\"", "0", "1", "0", "0", "\"%s,%s\"", "1", "0", "\"%s,%s\"", "0", "1", "0", "1", "\"(%s)\"", "1", "0", "0", "1", "\"lo16(\"", "1", "\")(%s)\"", "0", "0", "1", "1", "\"@l(%s)\"", "0", "\"@l(%s)\"", "0", "\"(%s)\"", "0", "1" ]

[]

[ "<s>", "const", "GCNSubtarget", "*", "GCNTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "StringRef", "GPU", "=", "getGPUName", "(", "F", ")", ";", "StringRef", "FS", "=", "getFeatureString", "(", "F", ")", ";", "SmallString", "<", "128", ">", "SubtargetKey", "(", "GPU", ")", ";", "SubtargetKey", ".", "append", "(", "FS", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "SubtargetKey", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "GCNSubtarget", ">", "(", "TargetTriple", ",", "GPU", ",", "FS", ",", "*", "this", ")", ";", "}", "I", "->", "setScalarizeGlobalBehavior", "(", "ScalarizeGlobal", ")", ";", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "AMDGPU", "128" ]

[]

[ "<s>", "static", "void", "mt_emit_save_fp", "(", "enum", "save_direction", "direction", ",", "struct", "mt_frame_info", "info", ")", "{", "rtx", "base_reg", ";", "int", "reg_mask", "=", "info", ".", "reg_mask", "&", "~", "(", "FP_MASK", "|", "LINK_MASK", ")", ";", "int", "offset", "=", "info", ".", "total_size", ";", "int", "stack_offset", "=", "info", ".", "total_size", ";", "if", "(", "!", "info", ".", "save_fp", "&&", "!", "info", ".", "save_lr", "&&", "!", "reg_mask", ")", "return", ";", "if", "(", "CONST_OK_FOR_LETTER_P", "(", "offset", ",", "'O'", ")", ")", "base_reg", "=", "stack_pointer_rtx", ";", "else", "{", "base_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "GPR_R9", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "info", ".", "save_fp", ")", "{", "offset", "-=", "UNITS_PER_WORD", ";", "stack_offset", "-=", "UNITS_PER_WORD", ";", "mt_emit_save_restore", "(", "direction", ",", "gen_rtx_REG", "(", "SImode", ",", "GPR_FP", ")", ",", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_PLUS", "(", "SImode", ",", "base_reg", ",", "GEN_INT", "(", "offset", ")", ")", ")", ",", "stack_offset", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "the", "frame", "pointer", "in", "the", "prologue", "and", "restore", "frame", "pointer", "in", "epilogue", "." ]

[ "mt", "0" ]

[]

[ "<s>", "int", "store_multiple_operation", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "int", "count", ";", "int", "mask", ";", "int", "i", ";", "unsigned", "int", "last", ";", "rtx", "elt", ";", "count", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "if", "(", "count", "<", "2", ")", "return", "0", ";", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_DEST", "(", "elt", ")", ")", "!=", "REG", "||", "REGNO", "(", "SET_DEST", "(", "elt", ")", ")", "!=", "STACK_POINTER_REGNUM", "||", "GET_CODE", "(", "SET_SRC", "(", "elt", ")", ")", "!=", "PLUS", ")", "return", "0", ";", "elt", "=", "SET_SRC", "(", "elt", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "!=", "REG", "||", "REGNO", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "!=", "STACK_POINTER_REGNUM", "||", "GET_CODE", "(", "XEXP", "(", "elt", ",", "1", ")", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "XEXP", "(", "elt", ",", "1", ")", ")", "!=", "-", "(", "count", "-", "1", ")", "*", "4", ")", "return", "0", ";", "last", "=", "LAST_EXTENDED_REGNUM", "+", "1", ";", "mask", "=", "0", ";", "for", "(", "i", "=", "1", ";", "i", "<", "count", ";", "i", "++", ")", "{", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_DEST", "(", "elt", ")", ")", "!=", "MEM", "||", "GET_CODE", "(", "SET_SRC", "(", "elt", ")", ")", "!=", "REG", "||", "REGNO", "(", "SET_SRC", "(", "elt", ")", ")", ">=", "last", ")", "return", "0", ";", "last", "=", "REGNO", "(", "SET_SRC", "(", "elt", ")", ")", ";", "mask", "|=", "(", "1", "<<", "last", ")", ";", "elt", "=", "XEXP", "(", "SET_DEST", "(", "elt", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "PLUS", "||", "GET_CODE", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "!=", "REG", "||", "REGNO", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "!=", "STACK_POINTER_REGNUM", "||", "GET_CODE", "(", "XEXP", "(", "elt", ",", "1", ")", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "XEXP", "(", "elt", ",", "1", ")", ")", "!=", "-", "i", "*", "4", ")", "return", "0", ";", "}", "if", "(", "(", "mask", "&", "0x3c000", ")", "!=", "0", "&&", "(", "mask", "&", "0x3c000", ")", "!=", "0x3c000", ")", "return", "0", ";", "return", "mask", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "store", "multiple", "operation", ".", "It", "is", "known", "to", "be", "a", "PARALLEL", "and", "the", "first", "section", "will", "be", "tested", ".", "OP", "is", "the", "current", "operation", ".", "MODE", "is", "the", "current", "operation", "mode", "." ]

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

[]

[ "<s>", "static", "int", "ix86_mode_exit", "(", "int", "entity", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "X86_DIRFLAG_ANY", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_exit", "(", ")", ";", "case", "I387_ROUNDEVEN", ":", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "I387_CW_ANY", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "mode", "that", "ENTITY", "is", "assumed", "to", "be", "switched", "to", "at", "function", "exit", "." ]

[ "i386" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">>", "AMDGPUInstrInfo", "::", "getSerializableTargetIndices", "(", ")", "const", "{", "static", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">", "TargetIndices", "[", "]", "=", "{", "{", "AMDGPU", "::", "TI_CONSTDATA_START", ",", "\"amdgpu-constdata-start\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD0", ",", "\"amdgpu-scratch-rsrc-dword0\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD1", ",", "\"amdgpu-scratch-rsrc-dword1\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD2", ",", "\"amdgpu-scratch-rsrc-dword2\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD3", ",", "\"amdgpu-scratch-rsrc-dword3\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetIndices", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "ids", "of", "the", "target", "indices", "(", "used", "for", "the", "TargetIndex", "machine", "operand", ")", "and", "their", "names", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::TI_CONSTDATA_START", "\"amdgpu-constdata-start\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD0", "\"amdgpu-scratch-rsrc-dword0\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD1", "\"amdgpu-scratch-rsrc-dword1\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD2", "\"amdgpu-scratch-rsrc-dword2\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD3", "\"amdgpu-scratch-rsrc-dword3\"" ]

[]

[ "<s>", "bool", "SIFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", "&&", "!", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "isEntryFunction", "(", ")", ")", "{", "return", "MFI", ".", "getStackSize", "(", ")", "!=", "0", ";", "}", "return", "frameTriviallyRequiresSP", "(", "MFI", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "needsStackRealignment", "(", "MF", ")", "||", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

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

[]

[ "<s>", "SDValue", "M68kTargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "getJumpTableEncoding", "(", ")", "==", "MachineJumpTableInfo", "::", "EK_Custom32", ")", "return", "DAG", ".", "getNode", "(", "M68kISD", "::", "GLOBAL_BASE_REG", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "return", "Table", ";", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "M68k", "M68k", "M68kISD::GLOBAL_BASE_REG" ]

[]

[ "<s>", "SDValue", "rvexTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "return", "Chain", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "ISD::InputArg" ]

[]

[ "<s>", "const", "uint16_t", "*", "PatmosRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getFrameLowering", "(", ")", ";", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "Patmos", "::", "S0", ",", "Patmos", "::", "SRB", ",", "Patmos", "::", "SRO", ",", "Patmos", "::", "R21", ",", "Patmos", "::", "R22", ",", "Patmos", "::", "R23", ",", "Patmos", "::", "R24", ",", "Patmos", "::", "R25", ",", "Patmos", "::", "R26", ",", "Patmos", "::", "R27", ",", "Patmos", "::", "R28", ",", "Patmos", "::", "P1", ",", "Patmos", "::", "P2", ",", "Patmos", "::", "P3", ",", "Patmos", "::", "P4", ",", "Patmos", "::", "P5", ",", "Patmos", "::", "P6", ",", "Patmos", "::", "P7", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsFP", "[", "]", "=", "{", "Patmos", "::", "S0", ",", "Patmos", "::", "SRB", ",", "Patmos", "::", "SRO", ",", "Patmos", "::", "R21", ",", "Patmos", "::", "R22", ",", "Patmos", "::", "R23", ",", "Patmos", "::", "R24", ",", "Patmos", "::", "R25", ",", "Patmos", "::", "R26", ",", "Patmos", "::", "R27", ",", "Patmos", "::", "R28", ",", "Patmos", "::", "RFP", ",", "Patmos", "::", "P1", ",", "Patmos", "::", "P2", ",", "Patmos", "::", "P3", ",", "Patmos", "::", "P4", ",", "Patmos", "::", "P5", ",", "Patmos", "::", "P6", ",", "Patmos", "::", "P7", ",", "0", "}", ";", "return", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "?", "CalleeSavedRegsFP", ":", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::S0", "Patmos::SRB", "Patmos::SRO", "Patmos::R21", "Patmos::R22", "Patmos::R23", "Patmos::R24", "Patmos::R25", "Patmos::R26", "Patmos::R27", "Patmos::R28", "Patmos::P1", "Patmos::P2", "Patmos::P3", "Patmos::P4", "Patmos::P5", "Patmos::P6", "Patmos::P7", "0", "Patmos::S0", "Patmos::SRB", "Patmos::SRO", "Patmos::R21", "Patmos::R22", "Patmos::R23", "Patmos::R24", "Patmos::R25", "Patmos::R26", "Patmos::R27", "Patmos::R28", "Patmos::RFP", "Patmos::P1", "Patmos::P2", "Patmos::P3", "Patmos::P4", "Patmos::P5", "Patmos::P6", "Patmos::P7", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TII", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "OrderedBlks", ".", "clear", "(", ")", ";", "Visited", ".", "clear", "(", ")", ";", "FuncRep", "=", "&", "MF", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"LoopInfo:\\n\"", ";", "PrintLoopinfo", "(", "*", "MLI", ")", ";", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "DEBUG", "(", "MDT", "->", "print", "(", "dbgs", "(", ")", ",", "(", "const", "Module", "*", ")", "nullptr", ")", ";", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "DEBUG", "(", "PDT", "->", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "prepare", "(", ")", ";", "run", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"LoopInfo:\\n\"" ]

[]

[ "<s>", "static", "void", "thumb_set_frame_pointer", "(", "arm_stack_offsets", "*", "offsets", ")", "{", "HOST_WIDE_INT", "amount", ";", "rtx", "insn", ",", "dwarf", ";", "amount", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "locals_base", ";", "if", "(", "amount", "<", "1024", ")", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "amount", ")", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_movsi", "(", "hard_frame_pointer_rtx", ",", "GEN_INT", "(", "amount", ")", ")", ")", ";", "if", "(", "TARGET_THUMB2", ")", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "}", "else", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "hard_frame_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "}", "dwarf", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "hard_frame_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "amount", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "dwarf", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Set", "the", "Thumb", "frame", "pointer", "from", "the", "stack", "pointer", "." ]

[ "arm", "1024", "1", "1" ]

[]

[ "<s>", "void", "i386_pe_seh_end_prologue", "(", "FILE", "*", "f", ")", "{", "if", "(", "!", "TARGET_SEH", ")", "return", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "cfun", "->", "machine", "->", "seh", "->", "after_prologue", "=", "true", ";", "fputs", "(", "\"\\t.seh_endprologue\\n\"", ",", "f", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "ChangeStatus", "updateImpl", "(", "Attributor", "&", "A", ")", "override", "{", "ChangeStatus", "Change", "=", "ChangeStatus", "::", "UNCHANGED", ";", "auto", "CheckCallSite", "=", "[", "&", "]", "(", "AbstractCallSite", "CS", ")", "{", "Function", "*", "Caller", "=", "CS", ".", "getInstruction", "(", ")", "->", "getFunction", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"[AAAMDFlatWorkGroupSize] Call \"", "<<", "Caller", "->", "getName", "(", ")", "<<", "\"->\"", "<<", "getAssociatedFunction", "(", ")", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "auto", "&", "CallerInfo", "=", "A", ".", "getAAFor", "<", "AAAMDFlatWorkGroupSize", ">", "(", "*", "this", ",", "IRPosition", "::", "function", "(", "*", "Caller", ")", ",", "DepClassTy", "::", "REQUIRED", ")", ";", "Change", "|=", "clampStateAndIndicateChange", "(", "this", "->", "getState", "(", ")", ",", "CallerInfo", ".", "getState", "(", ")", ")", ";", "return", "true", ";", "}", ";", "bool", "AllCallSitesKnown", "=", "true", ";", "if", "(", "!", "A", ".", "checkForAllCallSites", "(", "CheckCallSite", ",", "*", "this", ",", "true", ",", "AllCallSitesKnown", ")", ")", "return", "indicatePessimisticFixpoint", "(", ")", ";", "return", "Change", ";", "}", "</s>" ]

[ "The", "actual", "update/transfer", "function", "which", "has", "to", "be", "implemented", "by", "the", "derived", "classes", "." ]

[ "AMDGPU", "\"[AAAMDFlatWorkGroupSize] Call \"", "\"->\"" ]

[]

[ "<s>", "static", "reg_class_t", "ix86_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "regclass", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "regclass", "==", "NO_REGS", ")", "return", "NO_REGS", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "regclass", ";", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "(", "MAYBE_MMX_CLASS_P", "(", "regclass", ")", "||", "MAYBE_SSE_CLASS_P", "(", "regclass", ")", "||", "MAYBE_MASK_CLASS_P", "(", "regclass", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "CONST_DOUBLE_P", "(", "x", ")", ")", "{", "if", "(", "INTEGER_CLASS_P", "(", "regclass", ")", ")", "return", "regclass", ";", "if", "(", "IS_STACK_MODE", "(", "mode", ")", "&&", "standard_80387_constant_p", "(", "x", ")", ">", "0", ")", "{", "if", "(", "FLOAT_CLASS_P", "(", "regclass", ")", ")", "return", "FLOAT_REGS", ";", "else", "if", "(", "regclass", "==", "FP_TOP_SSE_REGS", ")", "return", "FP_TOP_REG", ";", "else", "if", "(", "regclass", "==", "FP_SECOND_SSE_REGS", ")", "return", "FP_SECOND_REG", ";", "}", "return", "NO_REGS", ";", "}", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_SSE_MATH", ")", "return", "SSE_CLASS_P", "(", "regclass", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "INTEGER_CLASS_P", "(", "regclass", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", "&&", "!", "CONSTANT_P", "(", "x", ")", ")", "{", "if", "(", "Q_CLASS_P", "(", "regclass", ")", ")", "return", "regclass", ";", "else", "if", "(", "reg_class_subset_p", "(", "Q_REGS", ",", "regclass", ")", ")", "return", "Q_REGS", ";", "else", "return", "NO_REGS", ";", "}", "return", "regclass", ";", "}", "</s>" ]

[ "Put", "float", "CONST_DOUBLE", "in", "the", "constant", "pool", "instead", "of", "fp", "regs", ".", "QImode", "must", "go", "into", "class", "Q_REGS", ".", "Narrow", "ALL_REGS", "to", "GENERAL_REGS", ".", "This", "supports", "allowing", "movsf", "and", "movdf", "to", "do", "mem-to-mem", "moves", "through", "integer", "regs", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "if", "(", "AMDGPU", "::", "isEntryFunctionCC", "(", "CallConv", ")", ")", "return", "true", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCAssignFnForReturn", "(", "CallConv", ",", "IsVarArg", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "ISD::OutputArg", "AMDGPU::isEntryFunctionCC", "16" ]

[]

[ "<s>", "bool", "MBlazeAsmParser", "::", "ParseInstruction", "(", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "size_t", "dotLoc", "=", "Name", ".", "find", "(", "'.'", ")", ";", "Operands", ".", "push_back", "(", "MBlazeOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "0", ",", "dotLoc", ")", ",", "NameLoc", ")", ")", ";", "if", "(", "dotLoc", "<", "Name", ".", "size", "(", ")", ")", "Operands", ".", "push_back", "(", "MBlazeOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "dotLoc", ")", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "!", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "!", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "if", "(", "Name", ".", "startswith", "(", "\"lw\"", ")", "||", "Name", ".", "startswith", "(", "\"sw\"", ")", "||", "Name", ".", "startswith", "(", "\"lh\"", ")", "||", "Name", ".", "startswith", "(", "\"sh\"", ")", "||", "Name", ".", "startswith", "(", "\"lb\"", ")", "||", "Name", ".", "startswith", "(", "\"sb\"", ")", ")", "return", "(", "ParseMemory", "(", "Operands", ")", "==", "NULL", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze", "\"lw\"", "\"sw\"", "\"lh\"", "\"sh\"", "\"lb\"", "\"sb\"" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "bool", "MayNeedScavengingEmergencySlot", "=", "MFI", ".", "hasStackObjects", "(", ")", ";", "assert", "(", "(", "RS", "||", "!", "MayNeedScavengingEmergencySlot", ")", "&&", "\"RegScavenger required if spilling\"", ")", ";", "if", "(", "MayNeedScavengingEmergencySlot", ")", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getSize", "(", ")", ",", "AMDGPU", "::", "SGPR_32RegClass", ".", "getAlignment", "(", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "static", "void", "sparc_asm_function_epilogue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "insn", ",", "last_real_insn", ";", "insn", "=", "get_last_insn", "(", ")", ";", "last_real_insn", "=", "prev_real_insn", "(", "insn", ")", ";", "if", "(", "last_real_insn", "&&", "NONJUMP_INSN_P", "(", "last_real_insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "last_real_insn", ")", ")", "==", "SEQUENCE", ")", "last_real_insn", "=", "XVECEXP", "(", "PATTERN", "(", "last_real_insn", ")", ",", "0", ",", "0", ")", ";", "if", "(", "last_real_insn", "&&", "CALL_P", "(", "last_real_insn", ")", "&&", "!", "SIBLING_CALL_P", "(", "last_real_insn", ")", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "file", ")", ";", "sparc_output_deferred_case_vectors", "(", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "exit", "." ]

[ "sparc", "0", "0", "\"\\tnop\\n\"" ]

[]

[ "<s>", "static", "int", "arm_needs_doubleword_align", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "type", ")", "return", "GET_MODE_ALIGNMENT", "(", "mode", ")", ">", "PARM_BOUNDARY", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "TYPE_ALIGN", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ">", "PARM_BOUNDARY", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "type", ")", ")", ">", "PARM_BOUNDARY", ";", "int", "ret", "=", "0", ";", "int", "ret2", "=", "0", ";", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "if", "(", "DECL_ALIGN", "(", "field", ")", ">", "PARM_BOUNDARY", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "return", "1", ";", "else", "ret", "=", "-", "1", ";", "}", "else", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", "&&", "DECL_BIT_FIELD_TYPE", "(", "field", ")", "&&", "TYPE_ALIGN", "(", "DECL_BIT_FIELD_TYPE", "(", "field", ")", ")", ">", "PARM_BOUNDARY", ")", "ret2", "=", "1", ";", "if", "(", "ret2", ")", "return", "2", ";", "return", "ret", ";", "}", "</s>" ]

[ "Return", "1", "if", "double", "word", "alignment", "is", "required", "for", "argument", "passing", ".", "Return", "-1", "if", "double", "word", "alignment", "used", "to", "be", "required", "for", "argument", "passing", "before", "PR77728", "ABI", "fix", ",", "but", "is", "not", "required", "anymore", ".", "Return", "0", "if", "double", "word", "alignment", "is", "not", "required", "and", "was", "n't", "requried", "before", "either", "." ]

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

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "RecedeCycle", "(", ")", "{", "llvm_unreachable", "(", "\"hazard recognizer does not support bottom-up scheduling.\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"hazard recognizer does not support bottom-up scheduling.\"" ]

[]

[ "<s>", "bool", "mips_cannot_change_mode_class", "(", "enum", "machine_mode", "from", ",", "enum", "machine_mode", "to", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "MIN", "(", "GET_MODE_SIZE", "(", "from", ")", ",", "GET_MODE_SIZE", "(", "to", ")", ")", "<=", "UNITS_PER_WORD", "&&", "MAX", "(", "GET_MODE_SIZE", "(", "from", ")", ",", "GET_MODE_SIZE", "(", "to", ")", ")", ">", "UNITS_PER_WORD", ")", "{", "if", "(", "TARGET_BIG_ENDIAN", ")", "{", "if", "(", "FP_INC", ">", "1", "&&", "reg_classes_intersect_p", "(", "FP_REGS", ",", "class", ")", ")", "return", "true", ";", "}", "else", "{", "if", "(", "reg_classes_intersect_p", "(", "ACC_REGS", ",", "class", ")", ")", "return", "true", ";", "}", "}", "if", "(", "TARGET_FLOAT64", "&&", "from", "==", "SImode", "&&", "GET_MODE_SIZE", "(", "to", ")", ">=", "UNITS_PER_WORD", "&&", "reg_classes_intersect_p", "(", "FP_REGS", ",", "class", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "CANNOT_CHANGE_MODE_CLASS", "." ]

[ "mips", "1" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "void", "BPFDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIV", ":", "{", "DebugLoc", "Empty", ";", "const", "DebugLoc", "&", "DL", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "if", "(", "DL", "!=", "Empty", ")", "errs", "(", ")", "<<", "\"Error at line \"", "<<", "DL", ".", "getLine", "(", ")", "<<", "\": \"", ";", "else", "errs", "(", ")", "<<", "\"Error: \"", ";", "errs", "(", ")", "<<", "\"Unsupport signed division for DAG: \"", ";", "Node", "->", "print", "(", "errs", "(", ")", ",", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"Please convert to unsigned div/mod.\\n\"", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "bpf_load_byte", ":", "case", "Intrinsic", "::", "bpf_load_half", ":", "case", "Intrinsic", "::", "bpf_load_word", ":", "{", "SDLoc", "DL", "(", "Node", ")", ";", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Skb", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "SDValue", "N3", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "R6Reg", "=", "CurDAG", "->", "getRegister", "(", "BPF", "::", "R6", ",", "MVT", "::", "i64", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "DL", ",", "R6Reg", ",", "Skb", ",", "SDValue", "(", ")", ")", ";", "Node", "=", "CurDAG", "->", "UpdateNodeOperands", "(", "Node", ",", "Chain", ",", "N1", ",", "R6Reg", ",", "N3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "BPF", "::", "MOV_rr", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VT", ",", "TFI", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "\"Selecting: \"", "\"== \"", "ISD::SDIV", "\"Error at line \"", "\": \"", "\"Error: \"", "\"Unsupport signed division for DAG: \"", "\"Please convert to unsigned div/mod.\\n\"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::bpf_load_byte", "Intrinsic::bpf_load_half", "Intrinsic::bpf_load_word", "0", "1", "2", "3", "BPF::R6", "MVT::i64", "ISD::FrameIndex", "0", "BPF::MOV_rr" ]

[]

[ "<s>", "void", "emit_shift", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "shift", "=", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op1", ",", "op2", ")", ";", "rtx", "pat", "=", "(", "(", "shift4_operator", "(", "shift", ",", "SImode", ")", "?", "gen_shift_si3", ":", "gen_shift_si3_loop", ")", "(", "op0", ",", "op1", ",", "op2", ",", "shift", ")", ")", ";", "emit_insn", "(", "pat", ")", ";", "}", "</s>" ]

[ "Emit", "a", "shift", "insn", "to", "set", "OP0", "to", "OP1", "shifted", "by", "OP2", ";", "CODE", "specifies", "what", "kind", "of", "shift", "." ]

[ "arc" ]

[]

[ "<s>", "void", "alpha_emit_xfloating_arith", "(", "enum", "rtx_code", "code", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "func", ";", "int", "mode", ";", "rtx", "out_operands", "[", "3", "]", ";", "func", "=", "alpha_lookup_xfloating_lib_func", "(", "code", ")", ";", "mode", "=", "alpha_compute_xfloating_mode_arg", "(", "code", ",", "alpha_fprm", ")", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "1", "]", ";", "out_operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "out_operands", "[", "2", "]", "=", "GEN_INT", "(", "mode", ")", ";", "alpha_emit_xfloating_libcall", "(", "func", ",", "operands", "[", "0", "]", ",", "out_operands", ",", "3", ",", "gen_rtx_fmt_ee", "(", "code", ",", "TFmode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "X_floating", "library", "function", "call", "for", "arithmetic", "(", "+", ",", "-", ",", "*", ",", "/", ")", "." ]

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

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "std", "::", "vector", "<", "SDNode", "*", ">", "*", "Created", ")", "const", "{", "AttributeList", "Attr", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "if", "(", "isIntDivCheap", "(", "N", "->", "getValueType", "(", "0", ")", ",", "Attr", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "1ULL", "<<", "Lg2", ")", "-", "1", ",", "DL", ",", "VT", ")", ";", "SDValue", "CCVal", ";", "SDValue", "Cmp", "=", "getAArch64Cmp", "(", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ",", "CCVal", ",", "DAG", ",", "DL", ")", ";", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "CSel", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "CSEL", ",", "DL", ",", "VT", ",", "Add", ",", "N0", ",", "CCVal", ",", "Cmp", ")", ";", "if", "(", "Created", ")", "{", "Created", "->", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";", "Created", "->", "push_back", "(", "Add", ".", "getNode", "(", ")", ")", ";", "Created", "->", "push_back", "(", "CSel", ".", "getNode", "(", ")", ")", ";", "}", "SDValue", "SRA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "CSel", ",", "DAG", ".", "getConstant", "(", "Lg2", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "if", "(", "Divisor", ".", "isNonNegative", "(", ")", ")", "return", "SRA", ";", "if", "(", "Created", ")", "Created", "->", "push_back", "(", "SRA", ".", "getNode", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ",", "SRA", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "AArch64", "AArch64", "0", "0", "0", "MVT::i32", "MVT::i64", "0", "0", "1ULL", "1", "AArch64", "ISD::SETLT", "ISD::ADD", "AArch64ISD::CSEL", "ISD::SRA", "MVT::i64", "ISD::SUB", "0" ]

[]

[ "<s>", "void", "MipsTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MIPS_GPREL", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MIPS_GPREL", ")", ";", "this", "->", "TM", "=", "&", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\".sdata\"", "\".sbss\"", "Mips" ]

[]

[ "<s>", "static", "bool", "aarch64_sve_cmp_operand_p", "(", "rtx_code", "op_code", ",", "rtx", "x", ")", "{", "if", "(", "register_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "true", ";", "switch", "(", "op_code", ")", "{", "case", "LTU", ":", "case", "LEU", ":", "case", "GEU", ":", "case", "GTU", ":", "return", "aarch64_sve_cmp_immediate_p", "(", "x", ",", "false", ")", ";", "case", "LT", ":", "case", "LE", ":", "case", "GE", ":", "case", "GT", ":", "case", "NE", ":", "case", "EQ", ":", "return", "aarch64_sve_cmp_immediate_p", "(", "x", ",", "true", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "second", "operand", "for", "the", "SVE", "instruction", "that", "implements", "integer", "comparison", "OP_CODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "int", "get_arc_condition_code", "(", "rtx", "comparison", ")", "{", "switch", "(", "GET_MODE", "(", "XEXP", "(", "comparison", ",", "0", ")", ")", ")", "{", "case", "CCmode", ":", "case", "SImode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "case", "GT", ":", "return", "ARC_CC_GT", ";", "case", "LE", ":", "return", "ARC_CC_LE", ";", "case", "GE", ":", "return", "ARC_CC_GE", ";", "case", "LT", ":", "return", "ARC_CC_LT", ";", "case", "GTU", ":", "return", "ARC_CC_HI", ";", "case", "LEU", ":", "return", "ARC_CC_LS", ";", "case", "LTU", ":", "return", "ARC_CC_LO", ";", "case", "GEU", ":", "return", "ARC_CC_HS", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_ZNmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "case", "GE", ":", "return", "ARC_CC_P", ";", "case", "LT", ":", "return", "ARC_CC_N", ";", "case", "GT", ":", "return", "ARC_CC_PNZ", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_Zmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_Cmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "LTU", ":", "return", "ARC_CC_C", ";", "case", "GEU", ":", "return", "ARC_CC_NC", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_GTmode", ":", "if", "(", "TARGET_ARGONAUT_SET", "&&", "TARGET_SPFP", ")", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GT", ":", "return", "ARC_CC_N", ";", "case", "UNLE", ":", "return", "ARC_CC_P", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "else", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GT", ":", "return", "ARC_CC_HI", ";", "case", "UNLE", ":", "return", "ARC_CC_LS", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_GEmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GE", ":", "return", "ARC_CC_HS", ";", "case", "UNLT", ":", "return", "ARC_CC_LO", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_UNEQmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "UNEQ", ":", "return", "ARC_CC_EQ", ";", "case", "LTGT", ":", "return", "ARC_CC_NE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_ORDmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "UNORDERED", ":", "return", "ARC_CC_C", ";", "case", "ORDERED", ":", "return", "ARC_CC_NC", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FPXmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "case", "UNORDERED", ":", "return", "ARC_CC_C", ";", "case", "ORDERED", ":", "return", "ARC_CC_NC", ";", "case", "LTGT", ":", "return", "ARC_CC_HI", ";", "case", "UNEQ", ":", "return", "ARC_CC_LS", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "42", ")", ";", "}", "</s>" ]

[ "Returns", "the", "index", "of", "the", "ARC", "condition", "code", "string", "in", "`", "arc_condition_codes", "'", ".", "COMPARISON", "should", "be", "an", "rtx", "like", "`", "(", "eq", "(", "...", ")", "(", "...", ")", ")", "'", "." ]

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

[]

[ "<s>", "static", "bool", "sparc_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "if", "(", "!", "TARGET_VIS2", ")", "return", "false", ";", "if", "(", "!", "target", ")", "return", "true", ";", "if", "(", "vmode", "!=", "V8QImode", ")", "return", "false", ";", "rtx", "nop0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "if", "(", "op0", "==", "op1", ")", "op1", "=", "nop0", ";", "op0", "=", "nop0", ";", "op1", "=", "force_reg", "(", "vmode", ",", "op1", ")", ";", "unsigned", "int", "i", ",", "mask", ";", "for", "(", "i", "=", "mask", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "mask", "|=", "(", "sel", "[", "i", "]", "&", "0xf", ")", "<<", "(", "28", "-", "i", "*", "4", ")", ";", "rtx", "mask_rtx", "=", "force_reg", "(", "SImode", ",", "gen_int_mode", "(", "mask", ",", "SImode", ")", ")", ";", "emit_insn", "(", "gen_bmasksi_vis", "(", "gen_reg_rtx", "(", "SImode", ")", ",", "mask_rtx", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_bshufflev8qi_vis", "(", "target", ",", "op0", ",", "op1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_VEC_PERM_CONST", "." ]

[ "sparc", "0", "8", "0xf", "28", "4" ]

[]

[ "<s>", "int", "M680x0RegisterInfo", "::", "getSpillRegisterOrder", "(", "unsigned", "Reg", ")", "const", "{", "int", "Result", "=", "getRegisterOrder", "(", "Reg", ",", "*", "getRegClass", "(", "M680x0", "::", "SPILLRegClassID", ")", ")", ";", "if", "(", "Result", "<", "0", ")", "{", "llvm_unreachable", "(", "\"Cannot determine spill order\"", ")", ";", "}", "return", "Result", ";", "}", "</s>" ]

[ "Return", "spill", "order", "index", "of", "a", "register", ",", "if", "there", "is", "none", "then", "trap", "." ]

[ "M680x0", "M680x0", "M680x0::SPILLRegClassID", "0", "\"Cannot determine spill order\"" ]

[]

[ "<s>", "int", "frv_expand_block_clear", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "orig_dest", "=", "operands", "[", "0", "]", ";", "rtx", "bytes_rtx", "=", "operands", "[", "1", "]", ";", "rtx", "align_rtx", "=", "operands", "[", "3", "]", ";", "int", "constp", "=", "(", "GET_CODE", "(", "bytes_rtx", ")", "==", "CONST_INT", ")", ";", "int", "align", ";", "int", "bytes", ";", "int", "offset", ";", "int", "num_reg", ";", "rtx", "dest_reg", ";", "rtx", "dest_addr", ";", "rtx", "dest_mem", ";", "int", "clear_bytes", ";", "enum", "machine_mode", "mode", ";", "if", "(", "!", "constp", ")", "return", "FALSE", ";", "gcc_assert", "(", "GET_CODE", "(", "align_rtx", ")", "==", "CONST_INT", ")", ";", "align", "=", "INTVAL", "(", "align_rtx", ")", ";", "bytes", "=", "INTVAL", "(", "bytes_rtx", ")", ";", "if", "(", "bytes", "<=", "0", ")", "return", "TRUE", ";", "if", "(", "bytes", ">", "TOTAL_MOVE_REG", "*", "align", ")", "return", "FALSE", ";", "dest_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "orig_dest", ",", "0", ")", ")", ";", "num_reg", "=", "offset", "=", "0", ";", "for", "(", ";", "bytes", ">", "0", ";", "(", "bytes", "-=", "clear_bytes", ")", ",", "(", "offset", "+=", "clear_bytes", ")", ")", "{", "dest_addr", "=", "(", "(", "offset", "==", "0", ")", "?", "dest_reg", ":", "plus_constant", "(", "dest_reg", ",", "offset", ")", ")", ";", "if", "(", "bytes", ">=", "4", "&&", "align", ">=", "4", ")", "mode", "=", "SImode", ";", "else", "if", "(", "bytes", ">=", "2", "&&", "align", ">=", "2", ")", "mode", "=", "HImode", ";", "else", "mode", "=", "QImode", ";", "clear_bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "dest_mem", "=", "change_address", "(", "orig_dest", ",", "mode", ",", "dest_addr", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest_mem", ",", "const0_rtx", ")", ")", ";", "}", "return", "TRUE", ";", "}", "</s>" ]

[ "Expand", "a", "block", "clear", "operation", ",", "and", "return", "1", "if", "successful", ".", "Return", "0", "if", "we", "should", "let", "the", "compiler", "generate", "normal", "code", ".", "operands", "[", "0", "]", "is", "the", "destination", "operands", "[", "1", "]", "is", "the", "length", "operands", "[", "3", "]", "is", "the", "alignment" ]

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

[]

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

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

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

[]

[ "<s>", "static", "int", "rs6000_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "int", "ret", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "GENERAL_REGS", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "(", "0", ",", "mode", ")", ";", "else", "if", "(", "(", "reg_classes_intersect_p", "(", "rclass", ",", "FLOAT_REGS", ")", "||", "reg_classes_intersect_p", "(", "rclass", ",", "VSX_REGS", ")", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "(", "32", ",", "mode", ")", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "ALTIVEC_REGS", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "(", "FIRST_ALTIVEC_REGNO", ",", "mode", ")", ";", "else", "ret", "=", "4", "+", "rs6000_register_move_cost", "(", "mode", ",", "rclass", ",", "GENERAL_REGS", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_memory_move_cost: ret=%d, mode=%s, rclass=%s, in=%d\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "rclass", "]", ",", "in", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expressions", "returning", "the", "cost", "of", "moving", "data", "of", "MODE", "from", "a", "register", "to", "or", "from", "memory", "." ]

[ "rs6000", "4", "0", "4", "32", "4", "4", "1", "\"rs6000_memory_move_cost: ret=%d, mode=%s, rclass=%s, in=%d\\n\"" ]

[]

[ "<s>", "SDValue", "X86SelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "if", "(", "DstPtrInfo", ".", "getAddrSpace", "(", ")", ">=", "256", "||", "SrcPtrInfo", ".", "getAddrSpace", "(", ")", ">=", "256", ")", "return", "SDValue", "(", ")", ";", "const", "MCPhysReg", "ClobberSet", "[", "]", "=", "{", "X86", "::", "RCX", ",", "X86", "::", "RSI", ",", "X86", "::", "RDI", ",", "X86", "::", "ECX", ",", "X86", "::", "ESI", ",", "X86", "::", "EDI", "}", ";", "if", "(", "isBaseRegConflictPossible", "(", "DAG", ",", "ClobberSet", ")", ")", "return", "SDValue", "(", ")", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "UseFSRMForMemcpy", "&&", "Subtarget", ".", "hasFSRM", "(", ")", ")", "return", "emitRepmovs", "(", "Subtarget", ",", "DAG", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "MVT", "::", "i8", ")", ";", "if", "(", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "return", "emitConstantSizeRepmov", "(", "DAG", ",", "Subtarget", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "ConstantSize", "->", "getZExtValue", "(", ")", ",", "Size", ".", "getValueType", "(", ")", ",", "Alignment", ".", "value", "(", ")", ",", "isVolatile", ",", "AlwaysInline", ",", "DstPtrInfo", ",", "SrcPtrInfo", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "X86", "X86", "256", "256", "X86::RCX", "X86::RSI", "X86::RDI", "X86::ECX", "X86::ESI", "X86::EDI", "X86", "X86", "MVT::i8" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "Align", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addInstSelector", "(", ")", "{", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonOptimizeSZextends", "(", ")", ")", ";", "addPass", "(", "createHexagonISelDag", "(", "TM", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableGenPred", ")", "addPass", "(", "createHexagonGenPredicate", "(", ")", ",", "false", ")", ";", "if", "(", "EnableLoopResched", ")", "addPass", "(", "createHexagonLoopRescheduling", "(", ")", ",", "false", ")", ";", "if", "(", "!", "DisableHSDR", ")", "addPass", "(", "createHexagonSplitDoubleRegs", "(", ")", ")", ";", "if", "(", "EnableBitSimplify", ")", "addPass", "(", "createHexagonBitSimplify", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "printAndVerify", "(", "\"After hexagon peephole pass\"", ")", ";", "if", "(", "EnableGenInsert", ")", "addPass", "(", "createHexagonGenInsert", "(", ")", ",", "false", ")", ";", "if", "(", "EnableEarlyIf", ")", "addPass", "(", "createHexagonEarlyIfConversion", "(", ")", ",", "false", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"After hexagon peephole pass\"", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "PPCSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "DisableVSXFMAMutate", ")", "return", "Changed", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "XCoreFunctionInfo", "*", "XFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "!", "isVarArg", ")", "CCInfo", ".", "AllocateStack", "(", "XFI", "->", "getReturnStackOffset", "(", ")", ",", "Align", "(", "4", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"Can't return value from vararg function in memory\"", ")", ";", "}", "int", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "ObjSize", ",", "Offset", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "OutVals", "[", "i", "]", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "XCoreISD", "::", "RETSP", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::OutputArg", "XCore", "XCore", "16", "4", "XCore", "4", "1", "0", "MVT::i32", "4", "0", "\"Can't return value from vararg function in memory\"", "8", "MVT::i32", "ISD::TokenFactor", "MVT::Other", "0", "1", "0", "XCoreISD::RETSP", "MVT::Other" ]

[]

[ "<s>", "pop", "(", "unsigned", "i", ")", ":", "i", "(", "i", ")", "{", "}", "</s>" ]

[ "Pop", "the", "previous", "solver", "state", "." ]

[ "TVM" ]

[]

[ "<s>", "std", "::", "string", "LineReader", "::", "readLine", "(", "unsigned", "lineNum", ")", "{", "if", "(", "lineNum", "<", "theCurLine", ")", "{", "theCurLine", "=", "0", ";", "fstr", ".", "seekg", "(", "0", ",", "std", "::", "ios", "::", "beg", ")", ";", "}", "while", "(", "theCurLine", "<", "lineNum", ")", "{", "fstr", ".", "getline", "(", "buff", ",", "500", ")", ";", "theCurLine", "++", ";", "}", "return", "buff", ";", "}", "</s>" ]

[ "Reads", "a", "line", "." ]

[ "NVPTX", "0", "0", "500" ]

[]