Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "_RM", ",", "MipsTargetMachine", "*", "_TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "RM", "(", "_RM", ")", ",", "OverrideMode", "(", "NoOverride", ")", ",", "TM", "(", "_TM", ")", ",", "TargetTriple", "(", "TT", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "CPUName", "=", "selectMipsCPU", "(", "TT", ",", "CPUName", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "TM", "->", "Options", ".", "UseSoftFloat", ")", "{", "TM", "->", "Options", ".", "UseSoftFloat", "=", "true", ";", "TM", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "InMips16HardFloat", "=", "true", ";", "}", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips2", ")", "report_fatal_error", "(", "\"Code generation for MIPS-II is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips3", ")", "report_fatal_error", "(", "\"Code generation for MIPS-III is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "MipsABI", "!=", "UnknownABI", ")", ";", "assert", "(", "(", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureO32", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureEABI", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN32", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN64", ")", "!=", "0", ")", ")", "==", "1", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "if", "(", "inMips16Mode", "(", ")", ")", "HasBitCount", "=", "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", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-II is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-III is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "Mips", "Mips::FeatureO32", "0", "Mips::FeatureEABI", "0", "Mips::FeatureN32", "0", "Mips::FeatureN64", "0", "1", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"linux\"", "Mips" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Patmos Single-Path Reducer\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Single-Path Reducer\"" ]

[]

[ "<s>", "bool", "SNESTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "int64_t", "Offs", "=", "AM", ".", "BaseOffs", ";", "if", "(", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "isa", "<", "PointerType", ">", "(", "Ty", ")", "&&", "AS", "==", "SNES", "::", "ProgramMemory", ")", "{", "return", "false", ";", "}", "if", "(", "Offs", "<", "0", ")", "Offs", "=", "-", "Offs", ";", "if", "(", "AM", ".", "BaseGV", "==", "0", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "isUInt", "<", "6", ">", "(", "Offs", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "SNES", "SNES", "0", "0", "SNES::ProgramMemory", "0", "0", "0", "6" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_incoming_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "NULL_RTX", ";", "if", "(", "!", "named", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "GEN_INT", "(", "1", "+", "cum", "->", "count", ")", ")", ",", "UNSPEC_ARG_REG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_INCOMING_ARG", "." ]

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

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "CR2Spilled", "=", "false", ";", "bool", "CR3Spilled", "=", "false", ";", "bool", "CR4Spilled", "=", "false", ";", "unsigned", "CSIIndex", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ",", "BeforeI", "=", "I", ";", "bool", "AtStart", "=", "I", "==", "MBB", ".", "begin", "(", ")", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", "&&", "!", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "continue", ";", "if", "(", "Reg", "==", "PPC", "::", "CR2", ")", "{", "CR2Spilled", "=", "true", ";", "CSIIndex", "=", "i", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR3", ")", "{", "CR3Spilled", "=", "true", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR4", ")", "{", "CR4Spilled", "=", "true", ";", "continue", ";", "}", "else", "{", "if", "(", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "&&", "!", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "CR2Spilled", "=", "CR3Spilled", "=", "CR4Spilled", "=", "false", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "0", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR3", "PPC::CR4", "PPC::CR2", "PPC::CR4", "PPC", "\"loadRegFromStackSlot didn't insert any code!\"", "PPC" ]

[]

[ "<s>", "void", "GBZ80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "N", ")", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "int", "HexagonMCInstrInfo", "::", "getMaxValue", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "const", "uint64_t", "F", "=", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "MCI", ")", ".", "TSFlags", ";", "bool", "S", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isExtendable", "(", "MCII", ",", "MCI", ")", "||", "HexagonMCInstrInfo", "::", "isExtended", "(", "MCII", ",", "MCI", ")", ")", ";", "if", "(", "S", ")", "return", "(", "1", "<<", "(", "HexagonMCInstrInfo", "::", "getExtentBits", "(", "MCII", ",", "MCI", ")", "-", "1", ")", ")", "-", "1", ";", "return", "(", "1", "<<", "HexagonMCInstrInfo", "::", "getExtentBits", "(", "MCII", ",", "MCI", ")", ")", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "maximal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "Hexagon", "Hexagon", "1", "Hexagon", "1", "1", "1", "Hexagon", "1" ]

[]

[ "<s>", "void", "rs6000_split_compare_and_swap", "(", "rtx", "retval", ",", "rtx", "mem", ",", "rtx", "oldval", ",", "rtx", "newval", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label1", ",", "label2", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label1", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "gen_label_rtx", "(", ")", ")", ";", "label2", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label1", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "retval", ",", "oldval", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cond", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label2", ")", ";", "emit_move_insn", "(", "scratch", ",", "newval", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label1", ")", ";", "emit_insn", "(", "gen_isync", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "compare", "and", "swap", "operation", ".", "MEM", "is", "the", "memory", "on", "which", "to", "operate", ".", "OLDVAL", "is", "the", "old", "value", "to", "be", "compared", ".", "NEWVAL", "is", "the", "new", "value", "to", "be", "stored", ".", "SCRATCH", "is", "a", "scratch", "GPR", "." ]

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

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARM", "ARMCC::CondCodes", "4", "ARM::LDRcp", "0" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createMipsOptimizePICCallPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "MCI", ";", "HexagonLowerToMC", "(", "MI", ",", "MCI", ",", "*", "this", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCI", ")", ";", "return", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "mmix_shiftable_wyde_value", "(", "unsigned", "HOST_WIDEST_INT", "value", ")", "{", "int", "i", ";", "int", "has_candidate", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "if", "(", "value", "&", "65535", ")", "{", "if", "(", "has_candidate", ")", "return", "0", ";", "else", "has_candidate", "=", "1", ";", "}", "value", ">>=", "16", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "value", "is", "0", "..", "65535", "*", "2", "*", "*", "(", "16", "*", "N", ")", "for", "N=0", "..", "3.", "else", "return", "0", "." ]

[ "mmix", "0", "0", "4", "65535", "0", "1", "16", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Lower i1 Copies\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Lower i1 Copies\"" ]

[]

[ "<s>", "void", "s390_expand_atomic", "(", "enum", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "target", ",", "rtx", "mem", ",", "rtx", "val", ",", "bool", "after", ")", "{", "struct", "alignment_context", "ac", ";", "rtx", "cmp", ";", "rtx", "new", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "orig", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "csloop", "=", "gen_label_rtx", "(", ")", ";", "gcc_assert", "(", "!", "target", "||", "register_operand", "(", "target", ",", "VOIDmode", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "init_alignment_context", "(", "&", "ac", ",", "mem", ",", "mode", ")", ";", "if", "(", "!", "(", "ac", ".", "aligned", "&&", "code", "==", "SET", "&&", "MEM_P", "(", "val", ")", ")", ")", "val", "=", "s390_expand_mask_and_shift", "(", "val", ",", "mode", ",", "ac", ".", "shift", ")", ";", "if", "(", "code", "==", "PLUS", "||", "code", "==", "MINUS", ")", "emit_move_insn", "(", "orig", ",", "val", ")", ";", "else", "if", "(", "code", "==", "MULT", "||", "code", "==", "AND", ")", "val", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "val", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "cmp", "=", "force_reg", "(", "SImode", ",", "ac", ".", "memsi", ")", ";", "emit_label", "(", "csloop", ")", ";", "emit_move_insn", "(", "new", ",", "cmp", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "val", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new", ",", "orig", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "val", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "case", "SET", ":", "if", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "val", ")", ")", "store_bit_field", "(", "new", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "SImode", ",", "val", ")", ";", "else", "{", "new", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "new", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "break", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "new", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "MULT", ":", "new", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "new", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_sync_compare_and_swap_ccsi", "(", "cmp", ",", "ac", ".", "memsi", ",", "cmp", ",", "new", ")", ")", ";", "s390_emit_jump", "(", "csloop", ",", "gen_rtx_fmt_ee", "(", "NE", ",", "CCZ1mode", ",", "gen_rtx_REG", "(", "CCZ1mode", ",", "CC_REGNUM", ")", ",", "const0_rtx", ")", ")", ";", "if", "(", "target", ")", "convert_move", "(", "target", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "after", "?", "new", ":", "cmp", ",", "ac", ".", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ",", "1", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "operation", "CODE", "of", "mode", "MODE", ".", "MEM", "is", "the", "memory", "location", "and", "VAL", "the", "value", "to", "play", "with", ".", "If", "AFTER", "is", "true", "then", "store", "the", "the", "value", "MEM", "holds", "after", "the", "operation", ",", "if", "AFTER", "is", "false", "then", "store", "the", "value", "MEM", "holds", "before", "the", "operation", ".", "If", "TARGET", "is", "zero", "then", "discard", "that", "value", ",", "else", "store", "it", "to", "TARGET", "." ]

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

[]

[ "<s>", "SICSubtarget", "&", "SICSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "if", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "sic", ")", "{", "if", "(", "CPU", ".", "empty", "(", ")", "||", "CPU", "==", "\"generic\"", ")", "{", "CPU", "=", "\"sicxe\"", ";", "}", "else", "if", "(", "CPU", "==", "\"help\"", ")", "{", "CPU", "=", "\"\"", ";", "return", "*", "this", ";", "}", "else", "if", "(", "CPU", "!=", "\"sicse\"", "&&", "CPU", "!=", "\"sicxe\"", ")", "{", "CPU", "=", "\"sicxe\"", ";", "}", "}", "else", "{", "errs", "(", ")", "<<", "\"!!!Error, TargetTriple.getArch() = \"", "<<", "TargetTriple", ".", "getArch", "(", ")", "<<", "\"CPU = \"", "<<", "CPU", "<<", "\"\\n\"", ";", "exit", "(", "0", ")", ";", "}", "if", "(", "CPU", "==", "\"sicse\"", ")", "SICArchVersion", "=", "SICSE", ";", "else", "if", "(", "CPU", "==", "\"sicxe\"", ")", "SICArchVersion", "=", "SICXE", ";", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPU", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC", "\"generic\"", "\"sicxe\"", "\"help\"", "\"\"", "\"sicse\"", "\"sicxe\"", "\"sicxe\"", "\"!!!Error, TargetTriple.getArch() = \"", "\"CPU = \"", "\"\\n\"", "0", "\"sicse\"", "SIC", "SIC", "\"sicxe\"", "SIC", "SIC" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "hasLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineMemOperand", "*", "&", "MMO", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specified", "machine", "instruction", "has", "a", "load", "from", "a", "stack", "slot", ",", "return", "true", "along", "with", "the", "FrameIndices", "of", "the", "loaded", "stack", "slot", "and", "the", "machine", "mem", "operands", "containing", "the", "reference", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getCFLType", "(", ")", "!=", "PatmosSubtarget", "::", "CFL_DELAYED", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n[DelaySlotKiller] \"", "<<", "F", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "killDelaySlots", "(", "*", "FI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"\\n[DelaySlotKiller] \"", "\"\\n\"" ]

[]

[ "<s>", "static", "inline", "ChildIteratorType", "child_begin", "(", "NodeType", "*", "N", ")", "{", "return", "N", "->", "getChildren", "(", ")", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "nodes_iterator/begin/end", "-", "Allow", "iteration", "over", "all", "nodes", "in", "the", "graph" ]

[ "Patmos" ]

[]

[ "<s>", "void", "sparc_emit_membar_for_model", "(", "enum", "memmodel", "model", ",", "int", "load_store", ",", "int", "before_after", ")", "{", "const", "int", "LoadLoad", "=", "1", ";", "const", "int", "StoreLoad", "=", "2", ";", "const", "int", "LoadStore", "=", "4", ";", "const", "int", "StoreStore", "=", "8", ";", "int", "mm", "=", "0", ",", "implied", "=", "0", ";", "switch", "(", "sparc_memory_model", ")", "{", "case", "SMM_SC", ":", "implied", "=", "LoadLoad", "|", "StoreLoad", "|", "LoadStore", "|", "StoreStore", ";", "break", ";", "case", "SMM_TSO", ":", "implied", "|=", "StoreStore", ";", "if", "(", "load_store", "==", "3", "&&", "before_after", "==", "1", ")", "implied", "|=", "StoreLoad", ";", "case", "SMM_PSO", ":", "implied", "|=", "LoadLoad", "|", "LoadStore", ";", "if", "(", "load_store", "==", "3", "&&", "before_after", "==", "2", ")", "implied", "|=", "StoreLoad", "|", "StoreStore", ";", "case", "SMM_RMO", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "before_after", "&", "1", ")", "{", "if", "(", "is_mm_release", "(", "model", ")", "||", "is_mm_acq_rel", "(", "model", ")", "||", "is_mm_seq_cst", "(", "model", ")", ")", "{", "if", "(", "load_store", "&", "1", ")", "mm", "|=", "LoadLoad", "|", "StoreLoad", ";", "if", "(", "load_store", "&", "2", ")", "mm", "|=", "LoadStore", "|", "StoreStore", ";", "}", "}", "if", "(", "before_after", "&", "2", ")", "{", "if", "(", "is_mm_acquire", "(", "model", ")", "||", "is_mm_acq_rel", "(", "model", ")", "||", "is_mm_seq_cst", "(", "model", ")", ")", "{", "if", "(", "load_store", "&", "1", ")", "mm", "|=", "LoadLoad", "|", "LoadStore", ";", "if", "(", "load_store", "&", "2", ")", "mm", "|=", "StoreLoad", "|", "StoreStore", ";", "}", "}", "mm", "&=", "~", "implied", ";", "if", "(", "mm", "||", "before_after", "==", "3", ")", "emit_insn", "(", "gen_membar", "(", "GEN_INT", "(", "mm", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "membar", "instruction", "for", "various", "use", "cases", ".", "Both", "the", "LOAD_STORE", "and", "BEFORE_AFTER", "arguments", "of", "the", "form", "X_Y", ".", "They", "are", "two-bit", "masks", "where", "bit", "0", "indicates", "that", "X", "is", "true", ",", "and", "bit", "1", "indicates", "Y", "is", "true", "." ]

[ "sparc", "1", "2", "4", "8", "0", "0", "3", "1", "3", "2", "1", "1", "2", "2", "1", "2", "3" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "\"\\t.frame\\t$\"", "+", "Twine", "(", "LowercaseString", "(", "MipsInstPrinter", "::", "getRegisterName", "(", "stackReg", ")", ")", ")", "+", "\",\"", "+", "Twine", "(", "stackSize", ")", "+", "\",$\"", "+", "Twine", "(", "LowercaseString", "(", "MipsInstPrinter", "::", "getRegisterName", "(", "returnReg", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "Mips", "Mips", "\"\\t.frame\\t$\"", "Mips", "\",\"", "\",$\"", "Mips" ]

[]

[ "<s>", "void", "TMS320C64XFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "DebugLoc", "DL", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "llvm_unreachable", "(", "\"Can't currently support varsize stack frame\"", ")", ";", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "!=", "TMS320C64X", "::", "ret", ")", "llvm_unreachable", "(", "\"Can't insert epilogue before non-ret insn\"", ")", ";", "const", "TMS320C64XInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "TMS320C64XSubtarget", ">", "(", ")", ".", "enablePostRAScheduler", "(", ")", ")", "{", "TMS320C64XInstrInfo", "::", "addFormOp", "(", "TMS320C64XInstrInfo", "::", "addDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TMS320C64X", "::", "word_load_1", ")", ")", ".", "addReg", "(", "TMS320C64X", "::", "B3", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "TMS320C64X", "::", "A15", ")", ".", "addImm", "(", "-", "1", ")", ")", ",", "TMS320C64XII", "::", "unit_d", ",", "true", ")", ";", "MBBI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "TMS320C64X", "::", "B3", ",", "false", ",", "true", ")", ")", ";", "TMS320C64XInstrInfo", "::", "addDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TMS320C64X", "::", "mv", ")", ")", ".", "addReg", "(", "TMS320C64X", "::", "B15", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "TMS320C64X", "::", "A15", ")", ")", ";", "TMS320C64XInstrInfo", "::", "addFormOp", "(", "TMS320C64XInstrInfo", "::", "addDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TMS320C64X", "::", "word_load_1", ")", ")", ".", "addReg", "(", "TMS320C64X", "::", "A15", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "TMS320C64X", "::", "A15", ")", ".", "addImm", "(", "0", ")", ")", ",", "TMS320C64XII", "::", "unit_d", ",", "false", ")", ";", "}", "else", "{", "TMS320C64XInstrInfo", "::", "addDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TMS320C64X", "::", "epilog", ")", ")", ")", ";", "}", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "\"Can't currently support varsize stack frame\"", "TMS320C64X::ret", "\"Can't insert epilogue before non-ret insn\"", "TMS320C64X", "TMS320C64X", "TMS320C64X", "TMS320C64X", "TMS320C64X::word_load_1", "TMS320C64X::B3", "TMS320C64X::A15", "1", "TMS320C64XII::unit_d", "TMS320C64X::B3", "TMS320C64X", "TMS320C64X::mv", "TMS320C64X::B15", "TMS320C64X::A15", "TMS320C64X", "TMS320C64X", "TMS320C64X::word_load_1", "TMS320C64X::A15", "TMS320C64X::A15", "0", "TMS320C64XII::unit_d", "TMS320C64X", "TMS320C64X::epilog" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "DLX" ]

[]

[ "<s>", "rtx", "rs6000_gen_lvx", "(", "enum", "machine_mode", "mode", ",", "rtx", "dest_exp", ",", "rtx", "src_exp", ")", "{", "rtx", "lvx", ";", "if", "(", "mode", "==", "V16QImode", ")", "lvx", "=", "gen_altivec_lvx_v16qi", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "if", "(", "mode", "==", "V8HImode", ")", "lvx", "=", "gen_altivec_lvx_v8hi", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "if", "(", "mode", "==", "V8HFmode", ")", "lvx", "=", "gen_altivec_lvx_v8hf", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "if", "(", "mode", "==", "V4SImode", ")", "lvx", "=", "gen_altivec_lvx_v4si", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "if", "(", "mode", "==", "V4SFmode", ")", "lvx", "=", "gen_altivec_lvx_v4sf", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "if", "(", "mode", "==", "V2DImode", ")", "lvx", "=", "gen_altivec_lvx_v2di", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "if", "(", "mode", "==", "V2DFmode", ")", "lvx", "=", "gen_altivec_lvx_v2df", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "if", "(", "mode", "==", "V1TImode", ")", "lvx", "=", "gen_altivec_lvx_v1ti", "(", "dest_exp", ",", "src_exp", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "rtx", "new_mem_exp", "=", "SET_SRC", "(", "PATTERN", "(", "lvx", ")", ")", ";", "mimic_memory_attributes_and_flags", "(", "new_mem_exp", ",", "src_exp", ")", ";", "return", "lvx", ";", "}", "</s>" ]

[ "Generate", "an", "rtx", "expression", "to", "represent", "use", "of", "the", "lvx", "insn", "to", "load", "from", "memory", "SRC_EXP", "into", "register", "DEST_EXP", "with", "vector", "mode", "MODE", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "getMaxInlineSizeThreshold", "(", ")", "const", "{", "return", "MaxInlineSizeThreshold", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "memset", "/", "memcpy", "size", "that", "still", "makes", "it", "profitable", "to", "inline", "the", "call", "." ]

[ "X86" ]

[]

[ "<s>", "const", "BPFTargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "BPFTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "int", "m32c_trampoline_size", "(", "void", ")", "{", "return", "TARGET_A16", "?", "8", ":", "10", ";", "}", "</s>" ]

[ "Implements", "TRAMPOLINE_SIZE", "." ]

[ "m32c", "8", "10" ]

[]

[ "<s>", "rtx", "ix86_split_stack_guard", "(", "void", ")", "{", "int", "offset", ";", "addr_space_t", "as", "=", "DEFAULT_TLS_SEG_REG", ";", "rtx", "r", ";", "gcc_assert", "(", "flag_split_stack", ")", ";", "offset", "=", "TARGET_THREAD_SPLIT_STACK_OFFSET", ";", "gcc_unreachable", "(", ")", ";", "r", "=", "GEN_INT", "(", "offset", ")", ";", "r", "=", "gen_const_mem", "(", "Pmode", ",", "r", ")", ";", "set_mem_addr_space", "(", "r", ",", "as", ")", ";", "return", "r", ";", "}", "</s>" ]

[ "Return", "location", "of", "the", "stack", "guard", "value", "in", "the", "TLS", "block", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "write_return_type", "(", "std", "::", "stringstream", "&", "s", ",", "bool", "for_proto", ",", "tree", "type", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "false", ";", "bool", "return_in_mem", "=", "pass_in_memory", "(", "mode", ",", "type", ",", "true", ")", ";", "if", "(", "return_in_mem", ")", "{", "if", "(", "for_proto", ")", "return", "return_in_mem", ";", "mode", "=", "(", "machine_mode", ")", "cfun", "->", "machine", "->", "return_mode", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "return_in_mem", ";", "cfun", "->", "machine", "->", "return_mode", "=", "VOIDmode", ";", "}", "else", "mode", "=", "promote_return", "(", "mode", ")", ";", "write_return_mode", "(", "s", ",", "for_proto", ",", "mode", ")", ";", "return", "return_in_mem", ";", "}", "</s>" ]

[ "Process", "a", "function", "return", "TYPE", "to", "emit", "a", "PTX", "return", "as", "a", "prototype", "or", "function", "prologue", "declaration", ".", "Returns", "true", "if", "return", "is", "via", "an", "additional", "pointer", "parameter", ".", "The", "promotion", "behavior", "here", "must", "match", "the", "regular", "GCC", "function", "return", "mashalling", "." ]

[ "nvptx" ]

[]

[ "<s>", "unsigned", "KudeyarRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Kudeyar", "::", "FP", ":", "Kudeyar", "::", "SP", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "Kudeyar::FP", "Kudeyar::SP" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "*", "STM", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "STM", "->", "getRegisterInfo", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "STM", "->", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "assert", "(", "!", "MRI", "->", "isSSA", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "\"Running SILoadStoreOptimizer\\n\"" ]

[]

[ "<s>", "int", "nios2_can_use_return_insn", "(", "void", ")", "{", "int", "total_frame_size", ";", "if", "(", "!", "reload_completed", "||", "crtl", "->", "profile", ")", "return", "0", ";", "total_frame_size", "=", "nios2_compute_frame_layout", "(", ")", ";", "if", "(", "TARGET_HAS_CDX", "&&", "!", "frame_pointer_needed", "&&", "cfun", "->", "machine", "->", "save_regs_offset", "<=", "60", "&&", "(", "cfun", "->", "machine", "->", "save_mask", "&", "0x80000000", ")", "!=", "0", "&&", "(", "cfun", "->", "machine", "->", "save_mask", "&", "0xffff", ")", "==", "0", "&&", "crtl", "->", "args", ".", "pretend_args_size", "==", "0", ")", "return", "true", ";", "return", "total_frame_size", "==", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "nios2", "0", "60", "0x80000000", "0", "0xffff", "0", "0", "0" ]

[]

[ "<s>", "void", "Z80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "MVT", "XLenVT", "=", "MVT", "::", "i16", ";", "SDLoc", "DL", "(", "Node", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "{", "auto", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "int64_t", "Imm", "=", "ConstNode", "->", "getSExtValue", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "ReplaceNode", "(", "Node", ",", "selectImm", "(", "CurDAG", ",", "SDLoc", "(", "Node", ")", ",", "Imm", ",", "VT", ")", ")", ";", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i16", "&&", "\"VT should be a pointer type size\"", ")", ";", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "Z80", "::", "LD16ri", ",", "DL", ",", "VT", ",", "TFI", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "1", "MVT::i16", "0", "ISD::Constant", "MVT::i16", "MVT::i8", "ISD::FrameIndex", "MVT::i16", "\"VT should be a pointer type size\"", "Z80::LD16ri" ]

[]

[ "<s>", "static", "void", "arm_asm_emit_except_personality", "(", "rtx", "personality", ")", "{", "fputs", "(", "\"\\t.personality\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "personality", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_EMIT_EXCEPT_PERSONALITY", "." ]

[ "arm", "\"\\t.personality\\t\"" ]

[]

[ "<s>", "void", "setError", "(", "unsigned", "Err", ")", "{", "Error", "=", "Err", ";", "}", "</s>" ]

[ "Set", "error", "and", "error", "message", "." ]

[ "Hexagon" ]

[]

[ "<s>", "int", "AMDGPUTTIImpl", "::", "getMinMaxReductionCost", "(", "Type", "*", "Ty", ",", "Type", "*", "CondTy", ",", "bool", "IsPairwise", ",", "bool", "IsUnsigned", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "IsPairwise", "||", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsPairwise", ",", "IsUnsigned", ")", ";", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getHalfRateInstrCost", "(", ")", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

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

[]

[ "<s>", "StringRef", "X86TargetLowering", "::", "getStackProbeSymbolName", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"probe-stack\"", ")", ")", "return", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "\"probe-stack\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isOSWindows", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", ")", "return", "\"\"", ";", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"___chkstk_ms\"", ":", "\"__chkstk\"", ";", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"_alloca\"", ":", "\"_chkstk\"", ";", "}", "</s>" ]

[ "Returns", "the", "name", "of", "the", "symbol", "used", "to", "emit", "stack", "probes", "or", "the", "empty", "string", "if", "not", "applicable", "." ]

[ "X86", "X86", "\"probe-stack\"", "\"probe-stack\"", "\"\"", "\"___chkstk_ms\"", "\"__chkstk\"", "\"_alloca\"", "\"_chkstk\"" ]

[]

[ "<s>", "EVT", "SITargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "Size", ">=", "16", "&&", "DstAlign", ">=", "4", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Size", ">=", "8", "&&", "DstAlign", ">=", "4", ")", "return", "MVT", "::", "v2i32", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "16", "4", "MVT::v4i32", "8", "4", "MVT::v2i32", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "aarch64_optab_supported_p", "(", "int", "op", ",", "machine_mode", ",", "machine_mode", ",", "optimization_type", "opt_type", ")", "{", "switch", "(", "op", ")", "{", "case", "rsqrt_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", "&&", "use_rsqrt_p", "(", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_OPTAB_SUPPORTED_P", "hook", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "R600TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "AMDGPUTargetLowering", "::", "ReplaceNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "lowerFP_TO_UINT", "(", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "lowerFP_TO_SINT", "(", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "SDValue", "Result", ";", "if", "(", "expandFP_TO_SINT", "(", "N", ",", "Result", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "case", "ISD", "::", "SDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "1", ")", ";", "SDValue", "RES", "=", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "RES", ")", ";", "Results", ".", "push_back", "(", "RES", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "UDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "0", ")", ";", "LowerUDIVREM64", "(", "Op", ",", "DAG", ",", "Results", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "AMDGPU", "R600", "AMDGPU", "ISD::FP_TO_UINT", "0", "MVT::i1", "0", "ISD::FP_TO_SINT", "0", "MVT::i1", "SI", "0", "SI", "ISD::SDIVREM", "1", "1", "ISD::UDIVREM", "0" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "SparcTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Xchg", "&&", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "32", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "Sparc", "Sparc", "32" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "errs", "(", ")", "<<", "\"DCPU16ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "0", ")", "{", "errs", "(", ")", "<<", "\"Base.Reg \"", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "}", "errs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "\"GV \"", ";", "GV", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "CP", ")", "{", "errs", "(", ")", "<<", "\" CP \"", ";", "CP", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "else", "if", "(", "ES", ")", "{", "errs", "(", ")", "<<", "\"ES \"", ";", "errs", "(", ")", "<<", "ES", "<<", "'\\n'", ";", "}", "else", "if", "(", "JT", "!=", "-", "1", ")", "errs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "Dcpu16", "\"DCPU16ISelAddressMode \"", "0", "\"Base.Reg \"", "\" Base.FrameIndex \"", "\" Disp \"", "\"GV \"", "\" CP \"", "\" Align\"", "\"ES \"", "1", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "BB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "break", ";", "}", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "HeadMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "TailMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "IfFalseMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "IfFalseMBB", ")", ";", "F", "->", "insert", "(", "I", ",", "TailMBB", ")", ";", "TailMBB", "->", "splice", "(", "TailMBB", "->", "begin", "(", ")", ",", "HeadMBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "HeadMBB", "->", "end", "(", ")", ")", ";", "TailMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "HeadMBB", ")", ";", "HeadMBB", "->", "addSuccessor", "(", "IfFalseMBB", ")", ";", "HeadMBB", "->", "addSuccessor", "(", "TailMBB", ")", ";", "unsigned", "LHS", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "RHS", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "auto", "CC", "=", "static_cast", "<", "ISD", "::", "CondCode", ">", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", ";", "unsigned", "Opcode", "=", "getBranchOpcodeForIntCondCode", "(", "CC", ")", ";", "BuildMI", "(", "HeadMBB", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "TailMBB", ")", ";", "IfFalseMBB", "->", "addSuccessor", "(", "TailMBB", ")", ";", "BuildMI", "(", "*", "TailMBB", ",", "TailMBB", "->", "begin", "(", ")", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PHI", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "4", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "HeadMBB", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "IfFalseMBB", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "TailMBB", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Unexpected instr type to insert\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "1", "2", "ISD::CondCode", "3", "RISCV::PHI", "0", "4", "5" ]

[]

[ "<s>", "void", "insert", "(", "unsigned", "BBNum", ",", "BasicBlockInfo", "BBI", ")", "{", "BBInfo", ".", "insert", "(", "BBInfo", ".", "begin", "(", ")", "+", "BBNum", ",", "BBI", ")", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "ARM" ]

[]

[ "<s>", "rtx", "ix86_expand_adjust_ufix_to_sfix_si", "(", "rtx", "val", ",", "rtx", "*", "xorp", ")", "{", "REAL_VALUE_TYPE", "TWO31r", ";", "rtx", "two31r", ",", "tmp", "[", "4", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "val", ")", ";", "machine_mode", "scalarmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "machine_mode", "intmode", "=", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", "?", "V8SImode", ":", "V4SImode", ";", "rtx", "(", "*", "cmp", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "tmp", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "real_ldexp", "(", "&", "TWO31r", ",", "&", "dconst1", ",", "31", ")", ";", "two31r", "=", "const_double_from_real_value", "(", "TWO31r", ",", "scalarmode", ")", ";", "two31r", "=", "ix86_build_const_vector", "(", "mode", ",", "1", ",", "two31r", ")", ";", "two31r", "=", "force_reg", "(", "mode", ",", "two31r", ")", ";", "switch", "(", "mode", ")", "{", "case", "V8SFmode", ":", "cmp", "=", "gen_avx_maskcmpv8sf3", ";", "break", ";", "case", "V4SFmode", ":", "cmp", "=", "gen_sse_maskcmpv4sf3", ";", "break", ";", "case", "V4DFmode", ":", "cmp", "=", "gen_avx_maskcmpv4df3", ";", "break", ";", "case", "V2DFmode", ":", "cmp", "=", "gen_sse2_maskcmpv2df3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "[", "3", "]", "=", "gen_rtx_LE", "(", "mode", ",", "two31r", ",", "val", ")", ";", "emit_insn", "(", "cmp", "(", "tmp", "[", "0", "]", ",", "two31r", ",", "val", ",", "tmp", "[", "3", "]", ")", ")", ";", "tmp", "[", "1", "]", "=", "expand_simple_binop", "(", "mode", ",", "AND", ",", "tmp", "[", "0", "]", ",", "two31r", ",", "tmp", "[", "1", "]", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "intmode", "==", "V4SImode", "||", "TARGET_AVX2", ")", "*", "xorp", "=", "expand_simple_binop", "(", "intmode", ",", "ASHIFT", ",", "gen_lowpart", "(", "intmode", ",", "tmp", "[", "0", "]", ")", ",", "GEN_INT", "(", "31", ")", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "else", "{", "rtx", "two31", "=", "GEN_INT", "(", "HOST_WIDE_INT_1U", "<<", "31", ")", ";", "two31", "=", "ix86_build_const_vector", "(", "intmode", ",", "1", ",", "two31", ")", ";", "*", "xorp", "=", "expand_simple_binop", "(", "intmode", ",", "AND", ",", "gen_lowpart", "(", "intmode", ",", "tmp", "[", "0", "]", ")", ",", "two31", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "}", "return", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "val", ",", "tmp", "[", "1", "]", ",", "tmp", "[", "2", "]", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "}", "</s>" ]

[ "Adjust", "a", "V", "*", "SFmode/V", "*", "DFmode", "value", "VAL", "so", "that", "*", "sfix_trunc", "*", "resp", ".", "fix_trunc", "*", "pattern", "can", "be", "used", "on", "it", "instead", "of", "fixuns_trunc", "*", ".", "This", "is", "done", "by", "doing", "just", "signed", "conversion", "if", "<", "0x1p31", ",", "and", "otherwise", "by", "subtracting", "0x1p31", "first", "and", "xoring", "in", "0x80000000", "from", "*", "XORP", "afterwards", "." ]

[ "i386", "4", "32", "0", "3", "31", "1", "3", "0", "3", "1", "0", "1", "0", "0", "31", "0", "31", "1", "0", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "void", "compute_regstack_size", "(", ")", "{", "int", "i", ";", "rtx", "insn", ";", "a29k_makes_calls", "=", "0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next_insn", "(", "insn", ")", ")", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", "||", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", "&&", "GET_CODE", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", "==", "CALL_INSN", ")", ")", "{", "a29k_makes_calls", "=", "1", ";", "break", ";", "}", "for", "(", "i", "=", "R_LR", "(", "127", ")", ";", "i", ">=", "R_LR", "(", "0", ")", ";", "i", "--", ")", "if", "(", "regs_ever_live", "[", "i", "]", ")", "break", ";", "a29k_regstack_size", "=", "i", "-", "(", "R_LR", "(", "0", ")", "-", "1", ")", ";", "if", "(", "a29k_makes_calls", "&&", "a29k_regstack_size", "<", "2", ")", "a29k_regstack_size", "=", "2", ";", "a29k_regstack_size", "+=", "frame_pointer_needed", ";", "if", "(", "a29k_regstack_size", "&", "1", ")", "a29k_regstack_size", "++", ";", "}", "</s>" ]

[ "Compute", "the", "size", "of", "the", "register", "stack", ",", "and", "determine", "if", "there", "are", "any", "call", "instructions", "." ]

[ "a29k", "0", "0", "0", "1", "127", "0", "0", "1", "2", "2", "1" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIOptimizeExecMaskingPreRAID", ")", ";", "insertPass", "(", "&", "SIOptimizeExecMaskingPreRAID", ",", "&", "SIFormMemoryClausesID", ")", ";", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "SILowerControlFlowID", ",", "&", "SIFixWWMLivenessID", ",", "false", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", "RegAllocPass", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "RISCVCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallLoweringInfo", "&", "Info", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "RI5CY", "RISCV" ]

[]

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

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

[ "AGC" ]

[]

[ "<s>", "int", "get_dest_uid", "(", "rtx", "label", ",", "int", "max_uid", ")", "{", "rtx_insn", "*", "dest", "=", "next_real_insn", "(", "label", ")", ";", "int", "dest_uid", ";", "if", "(", "!", "dest", ")", "return", "0", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "while", "(", "dest_uid", ">=", "max_uid", ")", "{", "dest", "=", "NEXT_INSN", "(", "dest", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "}", "if", "(", "JUMP_P", "(", "dest", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "dest", ")", ")", "==", "RETURN", ")", "return", "0", ";", "return", "dest_uid", ";", "}", "</s>" ]

[ "Return", "the", "UID", "of", "the", "insn", "that", "follows", "the", "specified", "label", "." ]

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

[]

[ "<s>", "bool", "TPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "const", "{", "unsigned", "NumOperands", "=", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "if", "(", "NumOperands", "<", "3", ")", "return", "false", ";", "const", "MachineOperand", "&", "PredMO", "=", "MI", ".", "getOperand", "(", "NumOperands", "-", "2", ")", ";", "if", "(", "!", "PredMO", ".", "isReg", "(", ")", ")", "return", "false", ";", "return", "PredMO", ".", "getReg", "(", ")", "==", "TPC", "::", "SP0", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "3", "2", "TPC::SP0" ]

[]

[ "<s>", "virtual", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "VideoCore4" ]

[]

[ "<s>", "static", "void", "sparc_asm_function_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "!", "TARGET_FLAT", ")", "gcc_assert", "(", "sparc_leaf_function_p", "==", "crtl", "->", "uses_only_leaf_regs", ")", ";", "sparc_output_scratch_registers", "(", "file", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "entry", ",", "which", "boils", "down", "to", "emitting", "the", "necessary", ".register", "directives", "." ]

[ "sparc" ]

[]

[ "<s>", "unsigned", "HexagonAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "HexagonOperand", "*", "Op", "=", "static_cast", "<", "HexagonOperand", "*", ">", "(", "&", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_0", ":", "{", "int64_t", "Value", ";", "return", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "Imm", ".", "Val", "->", "evaluateAsAbsolute", "(", "Value", ")", "&&", "Value", "==", "0", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "}", "case", "MCK_1", ":", "{", "int64_t", "Value", ";", "return", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "Imm", ".", "Val", "->", "evaluateAsAbsolute", "(", "Value", ")", "&&", "Value", "==", "1", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "}", "case", "MCK__MINUS_1", ":", "{", "int64_t", "Value", ";", "return", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "Imm", ".", "Val", "->", "evaluateAsAbsolute", "(", "Value", ")", "&&", "Value", "==", "-", "1", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "}", "}", "if", "(", "Op", "->", "Kind", "==", "HexagonOperand", "::", "Token", "&&", "Kind", "!=", "InvalidMatchClass", ")", "{", "StringRef", "myStringRef", "=", "StringRef", "(", "Op", "->", "Tok", ".", "Data", ",", "Op", "->", "Tok", ".", "Length", ")", ";", "if", "(", "matchTokenString", "(", "myStringRef", ".", "lower", "(", ")", ")", "==", "(", "MatchClassKind", ")", "Kind", ")", "return", "Match_Success", ";", "if", "(", "matchTokenString", "(", "myStringRef", ".", "upper", "(", ")", ")", "==", "(", "MatchClassKind", ")", "Kind", ")", "return", "Match_Success", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unmatched Operand:\"", ")", ";", "DEBUG", "(", "Op", "->", "dump", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "1", "1", "Hexagon", "\"Unmatched Operand:\"", "\"\\n\"" ]

[]

[ "<s>", "static", "inline", "bool", "offset_12bit_unsigned_scaled_p", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "return", "(", "offset", ">=", "0", "&&", "offset", "<", "4096", "*", "GET_MODE_SIZE", "(", "mode", ")", "&&", "offset", "%", "GET_MODE_SIZE", "(", "mode", ")", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "an", "unsigned", "12-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

[ "aarch64", "0", "4096", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "X86", "::", "CCRRegClass", ")", "{", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "else", "return", "&", "X86", "::", "GR32RegClass", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]

[ "X86", "X86", "X86::CCRRegClass", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "static", "void", "dump_target_flag_bits", "(", "const", "int", "flags", ")", "{", "if", "(", "flags", "&", "MASK_64BIT", ")", "fprintf", "(", "stderr", ",", "\"64BIT \"", ")", ";", "if", "(", "flags", "&", "MASK_APP_REGS", ")", "fprintf", "(", "stderr", ",", "\"APP_REGS \"", ")", ";", "if", "(", "flags", "&", "MASK_FASTER_STRUCTS", ")", "fprintf", "(", "stderr", ",", "\"FASTER_STRUCTS \"", ")", ";", "if", "(", "flags", "&", "MASK_FLAT", ")", "fprintf", "(", "stderr", ",", "\"FLAT \"", ")", ";", "if", "(", "flags", "&", "MASK_FMAF", ")", "fprintf", "(", "stderr", ",", "\"FMAF \"", ")", ";", "if", "(", "flags", "&", "MASK_FSMULD", ")", "fprintf", "(", "stderr", ",", "\"FSMULD \"", ")", ";", "if", "(", "flags", "&", "MASK_FPU", ")", "fprintf", "(", "stderr", ",", "\"FPU \"", ")", ";", "if", "(", "flags", "&", "MASK_HARD_QUAD", ")", "fprintf", "(", "stderr", ",", "\"HARD_QUAD \"", ")", ";", "if", "(", "flags", "&", "MASK_POPC", ")", "fprintf", "(", "stderr", ",", "\"POPC \"", ")", ";", "if", "(", "flags", "&", "MASK_PTR64", ")", "fprintf", "(", "stderr", ",", "\"PTR64 \"", ")", ";", "if", "(", "flags", "&", "MASK_STACK_BIAS", ")", "fprintf", "(", "stderr", ",", "\"STACK_BIAS \"", ")", ";", "if", "(", "flags", "&", "MASK_UNALIGNED_DOUBLES", ")", "fprintf", "(", "stderr", ",", "\"UNALIGNED_DOUBLES \"", ")", ";", "if", "(", "flags", "&", "MASK_V8PLUS", ")", "fprintf", "(", "stderr", ",", "\"V8PLUS \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS", ")", "fprintf", "(", "stderr", ",", "\"VIS \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS2", ")", "fprintf", "(", "stderr", ",", "\"VIS2 \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS3", ")", "fprintf", "(", "stderr", ",", "\"VIS3 \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS4", ")", "fprintf", "(", "stderr", ",", "\"VIS4 \"", ")", ";", "if", "(", "flags", "&", "MASK_VIS4B", ")", "fprintf", "(", "stderr", ",", "\"VIS4B \"", ")", ";", "if", "(", "flags", "&", "MASK_CBCOND", ")", "fprintf", "(", "stderr", ",", "\"CBCOND \"", ")", ";", "if", "(", "flags", "&", "MASK_DEPRECATED_V8_INSNS", ")", "fprintf", "(", "stderr", ",", "\"DEPRECATED_V8_INSNS \"", ")", ";", "if", "(", "flags", "&", "MASK_LEON", ")", "fprintf", "(", "stderr", ",", "\"LEON \"", ")", ";", "if", "(", "flags", "&", "MASK_LEON3", ")", "fprintf", "(", "stderr", ",", "\"LEON3 \"", ")", ";", "if", "(", "flags", "&", "MASK_SPARCLET", ")", "fprintf", "(", "stderr", ",", "\"SPARCLET \"", ")", ";", "if", "(", "flags", "&", "MASK_SPARCLITE", ")", "fprintf", "(", "stderr", ",", "\"SPARCLITE \"", ")", ";", "if", "(", "flags", "&", "MASK_V8", ")", "fprintf", "(", "stderr", ",", "\"V8 \"", ")", ";", "if", "(", "flags", "&", "MASK_V9", ")", "fprintf", "(", "stderr", ",", "\"V9 \"", ")", ";", "}", "</s>" ]

[ "Helpers", "for", "TARGET_DEBUG_OPTIONS", "." ]

[ "sparc", "\"64BIT \"", "\"APP_REGS \"", "\"FASTER_STRUCTS \"", "\"FLAT \"", "\"FMAF \"", "\"FSMULD \"", "\"FPU \"", "\"HARD_QUAD \"", "\"POPC \"", "\"PTR64 \"", "\"STACK_BIAS \"", "\"UNALIGNED_DOUBLES \"", "\"V8PLUS \"", "\"VIS \"", "\"VIS2 \"", "\"VIS3 \"", "\"VIS4 \"", "\"VIS4B \"", "\"CBCOND \"", "\"DEPRECATED_V8_INSNS \"", "\"LEON \"", "\"LEON3 \"", "\"SPARCLET \"", "\"SPARCLITE \"", "\"V8 \"", "\"V9 \"" ]

[]

[ "<s>", "static", "bool", "nios2_valid_addr_expr_p", "(", "rtx", "base", ",", "rtx", "offset", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "GET_CODE", "(", "base", ")", "==", "SUBREG", ")", "base", "=", "SUBREG_REG", "(", "base", ")", ";", "return", "(", "REG_P", "(", "base", ")", "&&", "nios2_regno_ok_for_base_p", "(", "REGNO", "(", "base", ")", ",", "strict_p", ")", "&&", "(", "offset", "==", "NULL_RTX", "||", "nios2_valid_addr_offset_p", "(", "offset", ")", "||", "(", "nios2_large_constant_allowed", "(", ")", "&&", "nios2_symbolic_constant_p", "(", "offset", ")", ")", "||", "nios2_unspec_reloc_p", "(", "offset", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "address", "expression", "formed", "by", "BASE", "+", "OFFSET", "is", "valid", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "int", "visium_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "enum", "attr_type", "attr_type", ";", "if", "(", "dep_type", "==", "REG_DEP_TRUE", ")", "{", "if", "(", "!", "reload_completed", "&&", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_CMP", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "IF_THEN_ELSE", "&&", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", "==", "const0_rtx", "&&", "recog_memoized", "(", "dep_insn", ")", ">=", "0", ")", "{", "enum", "attr_type", "dep_attr_type", "=", "get_attr_type", "(", "dep_insn", ")", ";", "if", "(", "dep_attr_type", "==", "TYPE_LOGIC", "||", "(", "dep_attr_type", "==", "TYPE_ARITH", "&&", "visium_nz_comparison_operator", "(", "XEXP", "(", "src", ",", "0", ")", ",", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", ")", ")", "return", "0", ";", "}", "}", "return", "cost", ";", "}", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "0", ";", "attr_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "dep_type", "==", "REG_DEP_ANTI", ")", "{", "if", "(", "attr_type", "==", "TYPE_REG_FP", "&&", "visium_cpu", "==", "PROCESSOR_GR5", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "dep_pat", "=", "PATTERN", "(", "dep_insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "GET_CODE", "(", "dep_pat", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "reg_mentioned_p", "(", "SET_DEST", "(", "pat", ")", ",", "SET_SRC", "(", "dep_pat", ")", ")", ")", "{", "if", "(", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "0", ";", "switch", "(", "get_attr_type", "(", "dep_insn", ")", ")", "{", "case", "TYPE_FDIV", ":", "case", "TYPE_FSQRT", ":", "case", "TYPE_FTOI", ":", "case", "TYPE_ITOF", ":", "case", "TYPE_FP", ":", "case", "TYPE_FMOVE", ":", "return", "insn_default_latency", "(", "dep_insn", ")", ";", "default", ":", "return", "0", ";", "}", "}", "}", "else", "if", "(", "attr_type", "==", "TYPE_RET", "&&", "visium_cpu", "==", "PROCESSOR_GR6", ")", "{", "rtx", "dep_pat", "=", "PATTERN", "(", "dep_insn", ")", ";", "if", "(", "GET_CODE", "(", "dep_pat", ")", "==", "SET", "&&", "REG_P", "(", "SET_DEST", "(", "dep_pat", ")", ")", "&&", "REGNO", "(", "SET_DEST", "(", "dep_pat", ")", ")", "==", "LINK_REGNUM", ")", "return", "8", ";", "}", "return", "0", ";", "}", "else", "if", "(", "dep_type", "==", "REG_DEP_OUTPUT", ")", "{", "if", "(", "attr_type", "==", "TYPE_REG_FP", "&&", "visium_cpu", "==", "PROCESSOR_GR5", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "dep_pat", "=", "PATTERN", "(", "dep_insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "GET_CODE", "(", "dep_pat", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "reg_mentioned_p", "(", "SET_DEST", "(", "pat", ")", ",", "SET_DEST", "(", "dep_pat", ")", ")", ")", "{", "if", "(", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "0", ";", "switch", "(", "get_attr_type", "(", "dep_insn", ")", ")", "{", "case", "TYPE_FDIV", ":", "case", "TYPE_FSQRT", ":", "case", "TYPE_FTOI", ":", "case", "TYPE_ITOF", ":", "case", "TYPE_FP", ":", "case", "TYPE_FMOVE", ":", "return", "insn_default_latency", "(", "dep_insn", ")", ";", "default", ":", "return", "0", ";", "}", "}", "}", "return", "0", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "of", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "." ]

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

[]

[ "<s>", "unsigned", "OutgoingValueHandler", "::", "extendRegister", "(", "unsigned", "ValReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "LLT", "LocTy", "{", "VA", ".", "getLocVT", "(", ")", "}", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "SExt", ":", "{", "unsigned", "ExtReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LocTy", ")", ";", "MIRBuilder", ".", "buildSExt", "(", "ExtReg", ",", "ValReg", ")", ";", "return", "ExtReg", ";", "}", "case", "CCValAssign", "::", "ZExt", ":", "{", "unsigned", "ExtReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LocTy", ")", ";", "MIRBuilder", ".", "buildZExt", "(", "ExtReg", ",", "ValReg", ")", ";", "return", "ExtReg", ";", "}", "case", "CCValAssign", "::", "AExt", ":", "{", "unsigned", "ExtReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LocTy", ")", ";", "MIRBuilder", ".", "buildAnyExt", "(", "ExtReg", ",", "ValReg", ")", ";", "return", "ExtReg", ";", "}", "case", "CCValAssign", "::", "Full", ":", "return", "ValReg", ";", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"unable to extend register\"", ")", ";", "}", "</s>" ]

[ "Extend", "a", "register", "to", "the", "location", "type", "given", "in", "VA", ",", "capped", "at", "extending", "to", "at", "most", "MaxSize", "bits", "." ]

[ "Mips", "\"unable to extend register\"" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "isRegBase", "(", ")", "&&", "\"Invalid base register access!\"", ")", ";", "return", "Base", ".", "Reg", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "WebAssembly", "\"Invalid base register access!\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AS", ",", "unsigned", "Align", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "false", ";", "return", "Subtarget", ".", "isHVXVectorType", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFPRCopy", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ")", "||", "AArch64", "::", "FPR128RegClass", ".", "contains", "(", "DstReg", ")", ")", ";", "}", "case", "AArch64", "::", "ORRv16i8", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"invalid ORRv16i8 operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "rename", "an", "FPR", "without", "modifying", "bits", "?" ]

[ "AArch64", "AArch64", "0", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::ORRv16i8", "1", "2", "3", "0", "\"invalid ORRv16i8 operands\"" ]

[]

[ "<s>", "void", "nds32_spilt_doubleword", "(", "rtx", "*", "operands", ",", "bool", "load_p", ")", "{", "int", "reg", "=", "load_p", "?", "0", ":", "1", ";", "int", "mem", "=", "load_p", "?", "1", ":", "0", ";", "rtx", "reg_rtx", "=", "load_p", "?", "operands", "[", "0", "]", ":", "operands", "[", "1", "]", ";", "rtx", "mem_rtx", "=", "load_p", "?", "operands", "[", "1", "]", ":", "operands", "[", "0", "]", ";", "rtx", "low_part", "[", "2", "]", ",", "high_part", "[", "2", "]", ";", "rtx", "sub_mem", "=", "XEXP", "(", "mem_rtx", ",", "0", ")", ";", "low_part", "[", "reg", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "reg_rtx", ",", "GET_MODE", "(", "reg_rtx", ")", ",", "0", ")", ";", "high_part", "[", "reg", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "reg_rtx", ",", "GET_MODE", "(", "reg_rtx", ")", ",", "4", ")", ";", "if", "(", "GET_CODE", "(", "sub_mem", ")", "==", "POST_DEC", ")", "{", "sub_mem", "=", "XEXP", "(", "sub_mem", ",", "0", ")", ";", "low_part", "[", "mem", "]", "=", "gen_frame_mem", "(", "SImode", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "sub_mem", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sub_mem", ",", "GEN_INT", "(", "4", ")", ")", ")", ")", ";", "high_part", "[", "mem", "]", "=", "gen_frame_mem", "(", "SImode", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "sub_mem", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sub_mem", ",", "GEN_INT", "(", "-", "12", ")", ")", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "sub_mem", ")", "==", "POST_MODIFY", ")", "{", "rtx", "post_mem", "=", "XEXP", "(", "sub_mem", ",", "0", ")", ";", "rtx", "plus_op", "=", "XEXP", "(", "sub_mem", ",", "1", ")", ";", "rtx", "post_val", "=", "XEXP", "(", "plus_op", ",", "1", ")", ";", "low_part", "[", "mem", "]", "=", "gen_frame_mem", "(", "SImode", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "post_mem", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "post_mem", ",", "post_val", ")", ")", ")", ";", "high_part", "[", "mem", "]", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "post_mem", ",", "4", ")", ")", ";", "}", "else", "{", "low_part", "[", "mem", "]", "=", "adjust_address", "(", "mem_rtx", ",", "SImode", ",", "0", ")", ";", "high_part", "[", "mem", "]", "=", "adjust_address", "(", "mem_rtx", ",", "SImode", ",", "4", ")", ";", "}", "if", "(", "(", "load_p", "&&", "reg_overlap_mentioned_p", "(", "low_part", "[", "0", "]", ",", "high_part", "[", "1", "]", ")", ")", "||", "GET_CODE", "(", "sub_mem", ")", "==", "POST_MODIFY", ")", "{", "operands", "[", "2", "]", "=", "high_part", "[", "0", "]", ";", "operands", "[", "3", "]", "=", "high_part", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "low_part", "[", "0", "]", ";", "operands", "[", "5", "]", "=", "low_part", "[", "1", "]", ";", "}", "else", "{", "operands", "[", "2", "]", "=", "low_part", "[", "0", "]", ";", "operands", "[", "3", "]", "=", "low_part", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "high_part", "[", "0", "]", ";", "operands", "[", "5", "]", "=", "high_part", "[", "1", "]", ";", "}", "}", "</s>" ]

[ "Spilt", "a", "doubleword", "instrucion", "to", "two", "single", "word", "instructions", "." ]

[ "nds32", "0", "1", "1", "0", "0", "1", "1", "0", "2", "2", "0", "0", "4", "0", "4", "12", "0", "1", "1", "4", "0", "4", "0", "1", "2", "0", "3", "1", "4", "0", "5", "1", "2", "0", "3", "1", "4", "0", "5", "1" ]

[]

[ "<s>", "void", "aarch64_expand_sve_vec_cmp_int", "(", "rtx", "target", ",", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "pred_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "data_mode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "!", "aarch64_sve_cmp_operand_p", "(", "code", ",", "op1", ")", ")", "op1", "=", "force_reg", "(", "data_mode", ",", "op1", ")", ";", "rtx", "ptrue", "=", "force_reg", "(", "pred_mode", ",", "CONSTM1_RTX", "(", "pred_mode", ")", ")", ";", "rtx", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "pred_mode", ",", "op0", ",", "op1", ")", ";", "aarch64_emit_sve_ptrue_op_cc", "(", "target", ",", "ptrue", ",", "cond", ")", ";", "}", "</s>" ]

[ "Expand", "an", "SVE", "integer", "comparison", ":", "TARGET", "=", "CODE", "(", "OP0", ",", "OP1", ")", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_file_end", "(", "void", ")", "{", "switch_to_section", "(", "text_section", ")", ";", "if", "(", "xcoff_tls_exec_model_detected", ")", "{", "fputs", "(", "\"\\t.extern __tls_get_addr\\n\\t.ref __tls_get_addr\\n\"", ",", "asm_out_file", ")", ";", "}", "fputs", "(", "\"_section_.text:\\n\"", ",", "asm_out_file", ")", ";", "switch_to_section", "(", "data_section", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\t.long _section_.text\\n\"", ":", "\"\\t.llong _section_.text\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "at", "end", "of", "assembler", "file", ".", "On", "the", "RS/6000", ",", "referencing", "data", "should", "automatically", "pull", "in", "text", "." ]

[ "rs6000", "\"\\t.extern __tls_get_addr\\n\\t.ref __tls_get_addr\\n\"", "\"_section_.text:\\n\"", "\"\\t.long _section_.text\\n\"", "\"\\t.llong _section_.text\\n\"" ]

[]

[ "<s>", "void", "RegisterAggr", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "OS", "<<", "'{'", ";", "for", "(", "auto", "I", ":", "Masks", ")", "OS", "<<", "' '", "<<", "PrintReg", "(", "I", ".", "first", ",", "&", "TRI", ")", "<<", "PrintLaneMaskOpt", "(", "I", ".", "second", ")", ";", "OS", "<<", "\" }\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\" }\"" ]

[]

[ "<s>", "static", "void", "count_unit_reqs", "(", "unit_req_table", "reqs", ",", "rtx_insn", "*", "head", ",", "rtx_insn", "*", "tail", ")", "{", "rtx_insn", "*", "insn", ";", "memset", "(", "reqs", ",", "0", ",", "sizeof", "(", "unit_req_table", ")", ")", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "NEXT_INSN", "(", "tail", ")", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "int", "side1", ",", "side2", ",", "req1", ",", "req2", ";", "switch", "(", "get_unit_reqs", "(", "insn", ",", "&", "req1", ",", "&", "side1", ",", "&", "req2", ",", "&", "side2", ")", ")", "{", "case", "2", ":", "reqs", "[", "side2", "]", "[", "req2", "]", "++", ";", "case", "1", ":", "reqs", "[", "side1", "]", "[", "req1", "]", "++", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Walk", "the", "insns", "between", "and", "including", "HEAD", "and", "TAIL", ",", "and", "mark", "the", "resource", "requirements", "in", "the", "unit_reqs", "table", "." ]

[ "c6x", "0", "2", "1" ]

[]

[ "<s>", "bool", "AMDGPUSymbolizer", "::", "tryAddingSymbolicOperand", "(", "MCInst", "&", "Inst", ",", "raw_ostream", "&", ",", "int64_t", "Value", ",", "uint64_t", ",", "bool", "IsBranch", ",", "uint64_t", ",", "uint64_t", ")", "{", "using", "SymbolInfoTy", "=", "std", "::", "tuple", "<", "uint64_t", ",", "StringRef", ",", "uint8_t", ">", ";", "using", "SectionSymbolsTy", "=", "std", "::", "vector", "<", "SymbolInfoTy", ">", ";", "if", "(", "!", "IsBranch", ")", "{", "return", "false", ";", "}", "auto", "*", "Symbols", "=", "static_cast", "<", "SectionSymbolsTy", "*", ">", "(", "DisInfo", ")", ";", "if", "(", "!", "Symbols", ")", "return", "false", ";", "auto", "Result", "=", "std", "::", "find_if", "(", "Symbols", "->", "begin", "(", ")", ",", "Symbols", "->", "end", "(", ")", ",", "[", "Value", "]", "(", "const", "SymbolInfoTy", "&", "Val", ")", "{", "return", "std", "::", "get", "<", "0", ">", "(", "Val", ")", "==", "static_cast", "<", "uint64_t", ">", "(", "Value", ")", "&&", "std", "::", "get", "<", "2", ">", "(", "Val", ")", "==", "ELF", "::", "STT_NOTYPE", ";", "}", ")", ";", "if", "(", "Result", "!=", "Symbols", "->", "end", "(", ")", ")", "{", "auto", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "std", "::", "get", "<", "1", ">", "(", "*", "Result", ")", ")", ";", "const", "auto", "*", "Add", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Add", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "AMDGPU", "AMDGPU", "0", "2", "1" ]

[]

[ "<s>", "static", "void", "s390_register_info_gprtofpr", "(", ")", "{", "int", "save_reg_slot", "=", "FPR0_REGNUM", ";", "int", "i", ",", "j", ";", "if", "(", "!", "TARGET_Z10", "||", "!", "TARGET_HARD_FLOAT", "||", "!", "crtl", "->", "is_leaf", ")", "return", ";", "for", "(", "i", "=", "15", ";", "i", ">=", "6", ";", "i", "--", ")", "{", "if", "(", "cfun_gpr_save_slot", "(", "i", ")", "==", "0", ")", "continue", ";", "while", "(", "(", "!", "call_really_used_regs", "[", "save_reg_slot", "]", "||", "df_regs_ever_live_p", "(", "save_reg_slot", ")", "||", "cfun_fpr_save_p", "(", "save_reg_slot", ")", ")", "&&", "FP_REGNO_P", "(", "save_reg_slot", ")", ")", "save_reg_slot", "++", ";", "if", "(", "!", "FP_REGNO_P", "(", "save_reg_slot", ")", ")", "{", "for", "(", "j", "=", "6", ";", "j", "<=", "15", ";", "j", "++", ")", "if", "(", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "j", ")", ")", ")", "cfun_gpr_save_slot", "(", "j", ")", "=", "-", "1", ";", "break", ";", "}", "cfun_gpr_save_slot", "(", "i", ")", "=", "save_reg_slot", "++", ";", "}", "}", "</s>" ]

[ "Update", "gpr_save_slots", "in", "the", "frame", "layout", "trying", "to", "make", "use", "of", "FPRs", "as", "GPR", "save", "slots", ".", "This", "is", "a", "helper", "routine", "of", "s390_register_info", "." ]

[ "s390", "15", "6", "0", "6", "15", "1" ]

[]

[ "<s>", "SUnit", "*", "ConvergingVLIWScheduler", "::", "pickNodeBidrectional", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "SUnit", "*", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ")", "{", "IsTopNode", "=", "false", ";", "return", "SU", ";", "}", "if", "(", "SUnit", "*", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ")", "{", "IsTopNode", "=", "true", ";", "return", "SU", ";", "}", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ".", "Available", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "if", "(", "BotResult", "==", "SingleExcess", "||", "BotResult", "==", "SingleCritical", ")", "{", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ".", "Available", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "if", "(", "TopResult", "==", "SingleExcess", "||", "TopResult", "==", "SingleCritical", ")", "{", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "if", "(", "BotResult", "==", "SingleMax", ")", "{", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "if", "(", "TopResult", "==", "SingleMax", ")", "{", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "if", "(", "TopCand", ".", "SCost", ">", "BotCand", ".", "SCost", ")", "{", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "node", "from", "either", "the", "top", "or", "bottom", "queue", "." ]

[ "Hexagon", "\"failed to find the first candidate\"", "\"failed to find the first candidate\"" ]

[]

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

[ "Return", "true", "if", "ctlz", "instruction", "is", "fast", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "PlaceMarkers", "(", "MF", ",", "MLI", ",", "TII", ",", "MDT", ",", "MFI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

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

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitStoreConditional", "(", "IRBuilderBase", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "isReleaseOrStronger", "(", "Ord", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "aarch64_stlxp", ":", "Intrinsic", "::", "aarch64_stxp", ";", "Function", "*", "Stxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int64Ty", "=", "Type", "::", "getInt64Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int64Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "64", ")", ",", "Int64Ty", ",", "\"hi\"", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Stxr", ",", "{", "Lo", ",", "Hi", ",", "Addr", "}", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "aarch64_stlxr", ":", "Intrinsic", "::", "aarch64_stxr", ";", "const", "DataLayout", "&", "DL", "=", "M", "->", "getDataLayout", "(", ")", ";", "IntegerType", "*", "IntValTy", "=", "Builder", ".", "getIntNTy", "(", "DL", ".", "getTypeSizeInBits", "(", "Val", "->", "getType", "(", ")", ")", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "isPointerTy", "(", ")", ")", "Addr", "=", "Builder", ".", "CreatePointerCast", "(", "Addr", ",", "IntValTy", "->", "getPointerTo", "(", "Addr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Stxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "assert", "(", "!", "DL", ".", "isFatPointer", "(", "Val", "->", "getType", "(", ")", ")", "&&", "\"Should not be handled here!\"", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "isPointerTy", "(", ")", ")", "Val", "=", "Builder", ".", "CreatePtrToInt", "(", "Val", ",", "IntValTy", ")", ";", "else", "Val", "=", "Builder", ".", "CreateBitCast", "(", "Val", ",", "IntValTy", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Stxr", ",", "{", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Stxr", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", "}", ")", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_stlxp", "Intrinsic::aarch64_stxp", "Intrinsic::getDeclaration", "\"lo\"", "64", "\"hi\"", "Intrinsic::ID", "Intrinsic::aarch64_stlxr", "Intrinsic::aarch64_stxr", "Intrinsic::getDeclaration", "\"Should not be handled here!\"", "0" ]

[]

[ "<s>", "void", "SystemZTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "bool", "HasCall", "=", "false", ";", "unsigned", "NumStores", "=", "0", ";", "for", "(", "auto", "&", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "&", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "&", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "HasCall", "=", "true", ";", "if", "(", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memcpy", "||", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memset", ")", "NumStores", "++", ";", "}", "else", "{", "HasCall", "=", "true", ";", "}", "}", "if", "(", "isa", "<", "StoreInst", ">", "(", "&", "I", ")", ")", "{", "NumStores", "++", ";", "Type", "*", "MemAccessTy", "=", "I", ".", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "if", "(", "(", "MemAccessTy", "->", "isIntegerTy", "(", ")", "||", "MemAccessTy", "->", "isFloatingPointTy", "(", ")", ")", "&&", "(", "getDataLayout", "(", ")", ".", "getTypeSizeInBits", "(", "MemAccessTy", ")", "==", "128", ")", ")", "NumStores", "++", ";", "}", "}", "unsigned", "const", "Max", "=", "(", "NumStores", "?", "(", "12", "/", "NumStores", ")", ":", "UINT_MAX", ")", ";", "if", "(", "HasCall", ")", "{", "UP", ".", "FullUnrollMaxCount", "=", "Max", ";", "UP", ".", "MaxCount", "=", "1", ";", "return", ";", "}", "UP", ".", "MaxCount", "=", "Max", ";", "if", "(", "UP", ".", "MaxCount", "<=", "1", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "75", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "Intrinsic::memcpy", "Intrinsic::memset", "0", "128", "12", "1", "1", "75", "4" ]

[]

[ "<s>", "bool", "tilepro_bitfield_operand_p", "(", "HOST_WIDE_INT", "n", ",", "int", "*", "first_bit", ",", "int", "*", "last_bit", ")", "{", "int", "i", ";", "if", "(", "n", "==", "0", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "{", "unsigned", "HOST_WIDE_INT", "x", "=", "rotate_right", "(", "n", ",", "i", ")", ";", "if", "(", "!", "(", "x", "&", "1", ")", ")", "continue", ";", "if", "(", "(", "x", "&", "(", "x", "+", "1", ")", ")", "==", "0", ")", "{", "if", "(", "first_bit", "!=", "NULL", ")", "*", "first_bit", "=", "i", ";", "if", "(", "last_bit", "!=", "NULL", ")", "*", "last_bit", "=", "(", "i", "+", "exact_log2", "(", "x", "^", "(", "x", ">>", "1", ")", ")", ")", "&", "31", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "iff", "n", "contains", "exactly", "one", "contiguous", "sequence", "of", "1", "bits", ",", "possibly", "wrapping", "around", "from", "high", "bits", "to", "low", "bits", "." ]

[ "tilepro", "0", "0", "32", "1", "1", "0", "1", "31" ]

[]

[ "<s>", "void", "emitCommonSymbol", "(", "MCSymbol", "*", "Symbol", ",", "uint64_t", "Size", ",", "unsigned", "ByteAlignment", ")", "override", "{", "}", "</s>" ]

[ "Emit", "a", "common", "symbol", "." ]

[ "Patmos" ]

[]

[ "<s>", "Optional", "<", "ParamLoadedValue", ">", "AArch64InstrInfo", "::", "describeLoadedValue", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "MOVZWi", ":", "case", "AArch64", "::", "MOVZXi", ":", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "return", "None", ";", "int", "Immediate", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "int", "Shift", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "ParamLoadedValue", "(", "MachineOperand", "::", "CreateImm", "(", "Immediate", "<<", "Shift", ")", ",", "nullptr", ")", ";", "}", "return", "TargetInstrInfo", "::", "describeLoadedValue", "(", "MI", ")", ";", "}", "</s>" ]

[ "Produce", "the", "expression", "describing", "the", "MI", "loading", "a", "value", "into", "the", "physical", "register", "Reg", "." ]

[ "AArch64", "AArch64", "AArch64::MOVZWi", "AArch64::MOVZXi", "1", "1", "2" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "MCOp", "=", "MCInstLowering", ".", "LowerOperand", "(", "MO", ")", ";", "return", "MCOp", ".", "isValid", "(", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VSELECT", ":", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformAddCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSubCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "ADC", ":", "return", "PerformADCCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformAndCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "PerformLOADCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "PerformSINT_TO_FPCombine", "(", "N", ",", "DAG", ",", "this", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "PerformFADDCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "PerformFSUBCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "VZEXT_MOVL", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "PerformSExtCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "PerformTruncateCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "SETCC", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SHUFP", ":", "case", "X86ISD", "::", "PALIGN", ":", "case", "X86ISD", "::", "UNPCKH", ":", "case", "X86ISD", "::", "UNPCKL", ":", "case", "X86ISD", "::", "MOVHLPS", ":", "case", "X86ISD", "::", "MOVLHPS", ":", "case", "X86ISD", "::", "PSHUFD", ":", "case", "X86ISD", "::", "PSHUFHW", ":", "case", "X86ISD", "::", "PSHUFLW", ":", "case", "X86ISD", "::", "MOVSS", ":", "case", "X86ISD", "::", "MOVSD", ":", "case", "X86ISD", "::", "VPERMILP", ":", "case", "X86ISD", "::", "VPERM2X128", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::EXTRACT_VECTOR_ELT", "ISD::VSELECT", "ISD::SELECT", "X86ISD::CMOV", "ISD::ADD", "ISD::SUB", "X86ISD::ADC", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::LOAD", "ISD::STORE", "ISD::SINT_TO_FP", "ISD::FADD", "ISD::FSUB", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT", "X86ISD::VZEXT_MOVL", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::TRUNCATE", "X86ISD::SETCC", "X86ISD::SHUFP", "X86ISD::PALIGN", "X86ISD::UNPCKH", "X86ISD::UNPCKL", "X86ISD::MOVHLPS", "X86ISD::MOVLHPS", "X86ISD::PSHUFD", "X86ISD::PSHUFHW", "X86ISD::PSHUFLW", "X86ISD::MOVSS", "X86ISD::MOVSD", "X86ISD::VPERMILP", "X86ISD::VPERM2X128", "ISD::VECTOR_SHUFFLE" ]

[]

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

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

[ "VE" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "AVR" ]

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getFPOpCost", "(", "Type", "*", "Ty", ")", "{", "if", "(", "ST", "->", "hasVFP2", "(", ")", "&&", "!", "ST", "->", "isThumb1Only", "(", ")", ")", "{", "if", "(", "Ty", "->", "isFloatTy", "(", ")", ")", "{", "return", "TargetTransformInfo", "::", "TCC_Basic", ";", "}", "if", "(", "Ty", "->", "isDoubleTy", "(", ")", ")", "{", "return", "ST", "->", "isFPOnlySP", "(", ")", "?", "TargetTransformInfo", "::", "TCC_Expensive", ":", "TargetTransformInfo", "::", "TCC_Basic", ";", "}", "}", "return", "TargetTransformInfo", "::", "TCC_Expensive", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "supporting", "the", "floating", "point", "operation", "of", "the", "specified", "type", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createHexagonELFObjectWriter", "(", "OS", ",", "OSABI", ",", "CPU", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "const", "ARMBaseRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_RecipThroughput", ")", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ",", "Args", ",", "CxtI", ")", ";", "int", "Cost", "=", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "return", "vectorCostAdjustment", "(", "Cost", ",", "Opcode", ",", "Ty", ",", "nullptr", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "PowerPC", "PPC", "\"Invalid opcode\"" ]

[]

[ "<s>", "void", "i386_djgpp_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", ")", "{", "char", "flagchars", "[", "8", "]", ",", "*", "f", "=", "flagchars", ";", "if", "(", "flags", "&", "SECTION_WRITE", ")", "*", "f", "++", "=", "'w'", ";", "if", "(", "flags", "&", "SECTION_CODE", ")", "*", "f", "++", "=", "'x'", ";", "if", "(", "strncmp", "(", "name", ",", "LTO_SECTION_NAME_PREFIX", ",", "strlen", "(", "LTO_SECTION_NAME_PREFIX", ")", ")", "==", "0", ")", "*", "f", "++", "=", "'0'", ";", "*", "f", "++", "=", "'\\0'", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s,\\\"%s\\\"\\n\"", ",", "name", ",", "flagchars", ")", ";", "}", "</s>" ]

[ "Function", "protypes", "for", "gcc/i386/djgpp.cc" ]

[ "i386", "8", "0", "\"\\t.section\\t%s,\\\"%s\\\"\\n\"" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "!", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "return", "ARMBaseInstrInfo", "::", "copyPhysReg", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tMOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM", "ARM::tMOVr" ]

[]

[ "<s>", "SDValue", "XNCMTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "XNCM", "XNCM", "ISD::SHL", "ISD::SRL", "ISD::SRA", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ExternalSymbol", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::SIGN_EXTEND", "\"unimplemented operand\"" ]

[]

[ "<s>", "bool", "LC3bFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

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

[ "LC3b", "LC3b" ]

[]

[ "<s>", "bool", "AArch64SpeculationHardening", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ")", "return", "false", ";", "MisspeculatingTaintReg", "=", "AArch64", "::", "X16", ";", "MisspeculatingTaintReg32Bit", "=", "AArch64", "::", "W16", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "RegsNeedingCSDBBeforeUse", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "RegsAlreadyMasked", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "UseControlFlowSpeculationBarrier", "=", "functionUsesHardeningRegister", "(", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "if", "(", "HardenLoads", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64SpeculationHardening - automatic insertion of \"", "\"SpeculationSafeValue intrinsics *****\\n\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "slhLoads", "(", "MBB", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64SpeculationHardening - track control flow *****\\n\"", ")", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "2", ">", "EntryBlocks", ";", "EntryBlocks", ".", "push_back", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "const", "LandingPadInfo", "&", "LPI", ":", "MF", ".", "getLandingPads", "(", ")", ")", "EntryBlocks", ".", "push_back", "(", "LPI", ".", "LandingPadBlock", ")", ";", "for", "(", "auto", "Entry", ":", "EntryBlocks", ")", "insertSPToRegTaintPropagation", "(", "*", "Entry", ",", "Entry", "->", "SkipPHIsLabelsAndDebug", "(", "Entry", "->", "begin", "(", ")", ")", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "UsesFullSpeculationBarrier", "=", "false", ";", "Modified", "|=", "instrumentControlFlow", "(", "MBB", ",", "UsesFullSpeculationBarrier", ")", ";", "Modified", "|=", "lowerSpeculationSafeValuePseudos", "(", "MBB", ",", "UsesFullSpeculationBarrier", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::X16", "AArch64::W16", "\"***** AArch64SpeculationHardening - automatic insertion of \"", "\"SpeculationSafeValue intrinsics *****\\n\"", "\"***** AArch64SpeculationHardening - track control flow *****\\n\"", "2" ]

[]

[ "<s>", "const", "MCFixup", "*", "RISCVMCExpr", "::", "getPCRelHiFixup", "(", "const", "MCFragment", "*", "*", "DFOut", ")", "const", "{", "MCValue", "AUIPCLoc", ";", "if", "(", "!", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "AUIPCLoc", ",", "nullptr", ",", "nullptr", ")", ")", "return", "nullptr", ";", "const", "MCSymbolRefExpr", "*", "AUIPCSRE", "=", "AUIPCLoc", ".", "getSymA", "(", ")", ";", "if", "(", "!", "AUIPCSRE", ")", "return", "nullptr", ";", "const", "MCSymbol", "*", "AUIPCSymbol", "=", "&", "AUIPCSRE", "->", "getSymbol", "(", ")", ";", "const", "auto", "*", "DF", "=", "dyn_cast_or_null", "<", "MCDataFragment", ">", "(", "AUIPCSymbol", "->", "getFragment", "(", ")", ")", ";", "if", "(", "!", "DF", ")", "return", "nullptr", ";", "uint64_t", "Offset", "=", "AUIPCSymbol", "->", "getOffset", "(", ")", ";", "if", "(", "DF", "->", "getContents", "(", ")", ".", "size", "(", ")", "==", "Offset", ")", "{", "DF", "=", "dyn_cast_or_null", "<", "MCDataFragment", ">", "(", "DF", "->", "getNextNode", "(", ")", ")", ";", "if", "(", "!", "DF", ")", "return", "nullptr", ";", "Offset", "=", "0", ";", "}", "for", "(", "const", "MCFixup", "&", "F", ":", "DF", "->", "getFixups", "(", ")", ")", "{", "if", "(", "F", ".", "getOffset", "(", ")", "!=", "Offset", ")", "continue", ";", "switch", "(", "(", "unsigned", ")", "F", ".", "getKind", "(", ")", ")", "{", "default", ":", "continue", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_hi20", ":", "case", "RISCV", "::", "fixup_riscv_pcrel_hi20", ":", "if", "(", "DFOut", ")", "*", "DFOut", "=", "DF", ";", "return", "&", "F", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Get", "the", "corresponding", "PC-relative", "HI", "fixup", "that", "a", "VK_RISCV_PCREL_LO", "points", "to", ",", "and", "optionally", "the", "fragment", "containing", "it", "." ]

[ "RISCV", "RISCV", "0", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_tls_got_hi20", "RISCV::fixup_riscv_tls_gd_hi20", "RISCV::fixup_riscv_pcrel_hi20" ]

[]

[ "<s>", "bool", "enablePostRAScheduler", "(", ")", "const", "override", "{", "return", "isCortexA53", "(", ")", "||", "isCortexA57", "(", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "RISCVRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "RISCVInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", "=", "getFrameLowering", "(", "MF", ")", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "Offset", ")", ")", "{", "report_fatal_error", "(", "\"Frame offsets outside of the signed 32-bit range not supported\"", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "bool", "FrameRegIsKill", "=", "false", ";", "if", "(", "!", "isInt", "<", "12", ">", "(", "Offset", ")", ")", "{", "assert", "(", "isInt", "<", "32", ">", "(", "Offset", ")", "&&", "\"Int32 expected\"", ")", ";", "unsigned", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "TII", "->", "movImm32", "(", "MBB", ",", "II", ",", "DL", ",", "ScratchReg", ",", "Offset", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", "->", "get", "(", "RISCV", "::", "ADD", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ";", "Offset", "=", "0", ";", "FrameReg", "=", "ScratchReg", ";", "FrameRegIsKill", "=", "true", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "FrameRegIsKill", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "\"Unexpected non-zero SPAdj value\"", "RISCV", "RISCV", "1", "32", "\"Frame offsets outside of the signed 32-bit range not supported\"", "12", "32", "\"Int32 expected\"", "RISCV::GPRRegClass", "RISCV::ADD", "0", "1" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "emitConstantPool", "(", ")", "{", "emitDecls", "(", "*", "MMI", "->", "getModule", "(", ")", ")", ";", "assert", "(", "MF", "->", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ".", "empty", "(", ")", "&&", "\"WebAssembly disables constant pools\"", ")", ";", "}", "</s>" ]

[ "Print", "to", "the", "current", "output", "stream", "assembly", "representations", "of", "the", "constants", "in", "the", "constant", "pool", "MCP", "." ]

[ "WebAssembly", "WebAssembly", "\"WebAssembly disables constant pools\"" ]

[]

[ "<s>", "PIC16SectionType", "getType", "(", ")", "const", "{", "return", "T", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "PIC16", "PIC16" ]

[]

[ "<s>", "void", "AMDGPUMCObjectWriter", "::", "writeObject", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ")", "{", "for", "(", "MCAssembler", "::", "iterator", "I", "=", "Asm", ".", "begin", "(", ")", ",", "E", "=", "Asm", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Asm", ".", "writeSectionData", "(", "&", "*", "I", ",", "Layout", ")", ";", "}", "}", "</s>" ]

[ "Write", "the", "object", "file", "and", "returns", "the", "number", "of", "bytes", "written", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* Hexagon Hardware Loops *********\\n\"", ")", ";", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "auto", "&", "L", ":", "*", "MLI", ")", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "{", "bool", "L0Used", "=", "false", ";", "bool", "L1Used", "=", "false", ";", "Changed", "|=", "convertToHardwareLoop", "(", "L", ",", "L0Used", ",", "L1Used", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"********* Hexagon Hardware Loops *********\\n\"", "Hexagon" ]

[]