Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "XCoreTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createXCoreISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore" ]

[]

[ "<s>", "void", "Mips16InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ";", "if", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Mips", "::", "GPR32RegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Mips", "::", "MoveR3216", ";", "else", "if", "(", "Mips", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ")", "&&", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Mips", "::", "Move32R16", ";", "else", "if", "(", "(", "SrcReg", "==", "Mips", "::", "HI", ")", "&&", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ")", "Opc", "=", "Mips", "::", "Mfhi16", ",", "SrcReg", "=", "0", ";", "else", "if", "(", "(", "SrcReg", "==", "Mips", "::", "LO", ")", "&&", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ")", "Opc", "=", "Mips", "::", "Mflo16", ",", "SrcReg", "=", "0", ";", "assert", "(", "Opc", "&&", "\"Cannot copy registers\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "DestReg", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "SrcReg", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::CPU16RegsRegClass", "Mips::GPR32RegClass", "Mips::MoveR3216", "Mips::GPR32RegClass", "Mips::CPU16RegsRegClass", "Mips::Move32R16", "Mips::HI", "Mips::CPU16RegsRegClass", "Mips::Mfhi16", "0", "Mips::LO", "Mips::CPU16RegsRegClass", "Mips::Mflo16", "0", "\"Cannot copy registers\"" ]

[]

[ "<s>", "Register", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "XCore", "::", "R1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "XCore", "XCore::R1" ]

[]

[ "<s>", "void", "SNESMCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "const", "uint16_t", "*", "Words", "=", "reinterpret_cast", "<", "uint16_t", "const", "*", ">", "(", "&", "Val", ")", ";", "size_t", "WordCount", "=", "Size", "/", "2", ";", "for", "(", "int64_t", "i", "=", "WordCount", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "uint16_t", "Word", "=", "Words", "[", "i", "]", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0x00ff", ")", ">>", "0", ")", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0xff00", ")", ">>", "8", ")", ";", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "SNES", "SNES", "2", "1", "0", "0x00ff", "0", "0xff00", "8" ]

[]

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

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

[ "BPF" ]

[]

[ "<s>", "void", "tilepro_final_prescan_insn", "(", "rtx_insn", "*", "insn", ")", "{", "insn_mode", "=", "GET_MODE", "(", "insn", ")", ";", "}", "</s>" ]

[ "Implement", "FINAL_PRESCAN_INSN", ".", "This", "is", "used", "to", "emit", "bundles", "." ]

[ "tilepro" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ")", "return", "false", ";", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "true", ";", "if", "(", "HasAlloca", "||", "HasExtraAlign", ")", "return", "true", ";", "if", "(", "MFI", ".", "getStackSize", "(", ")", ">", "0", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "TM", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "!", "EliminateFramePointer", ")", "return", "true", ";", "if", "(", "EnableStackOVFSanitizer", ")", "return", "true", ";", "}", "const", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", "||", "HMFI", ".", "hasClobberLR", "(", ")", ")", "return", "true", ";", "assert", "(", "MFI", ".", "isCalleeSavedInfoValid", "(", ")", "&&", "\"Need to know CSI\"", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "useSpillFunction", "(", "MF", ",", "CSI", ")", "||", "useRestoreFunction", "(", "MF", ",", "CSI", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "0", "Hexagon", "\"Need to know CSI\"" ]

[]

[ "<s>", "void", "MipsAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "FK_Data_2", ":", "case", "Mips", "::", "fixup_Mips_16", ":", "case", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ":", "FullSize", "=", "2", ";", "break", ";", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "case", "FK_Data_4", ":", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "bool", "microMipsLEByteOrder", "=", "needsMMLEByteOrder", "(", "(", "unsigned", ")", "Kind", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "7", "8", "Mips::fixup_Mips_16", "Mips::fixup_MICROMIPS_PC10_S1", "2", "Mips::fixup_Mips_64", "8", "4", "0", "Mips", "0", "Mips", "1", "8", "1", "64", "0", "Mips", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ",", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "empty", "(", ")", "&&", "I", "->", "back", "(", ")", ".", "isReturn", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "PPCLinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getDataLayout", "(", ")", ";", "bool", "isPPC64", "=", "TD", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "PPCTargetStreamer", "&", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "&", ">", "(", "*", "OutStreamer", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "!", "TOC", ".", "empty", "(", ")", ")", "{", "const", "MCSectionELF", "*", "Section", ";", "if", "(", "isPPC64", ")", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".toc\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "else", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".got2\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "Section", ")", ";", "for", "(", "MapVector", "<", "MCSymbol", "*", ",", "MCSymbol", "*", ">", "::", "iterator", "I", "=", "TOC", ".", "begin", "(", ")", ",", "E", "=", "TOC", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "I", "->", "second", ")", ";", "MCSymbol", "*", "S", "=", "OutContext", ".", "GetOrCreateSymbol", "(", "I", "->", "first", "->", "getName", "(", ")", ")", ";", "if", "(", "isPPC64", ")", "TS", ".", "emitTCEntry", "(", "*", "S", ")", ";", "else", "OutStreamer", ".", "EmitSymbolValue", "(", "S", ",", "4", ")", ";", "}", "}", "MachineModuleInfoELF", "&", "MMIELF", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MachineModuleInfoELF", "::", "SymbolListTy", "Stubs", "=", "MMIELF", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "PowerPC", "PPC", "PPC", "64", "PPC", "PPC", "PPC", "\".toc\"", "\".got2\"", "PPC", "4", "0", "PPC", "8", "4" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"OR1K PIC Global Base Reg Initialization\"", ";", "}", "</s>" ]

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

[ "OR1K", "\"OR1K PIC Global Base Reg Initialization\"" ]

[]

[ "<s>", "static", "int", "aarch64_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "elements", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "scalar_stmt_cost", ";", "case", "scalar_load", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "vec_stmt_cost", ";", "case", "vector_load", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "vec_align_load_cost", ";", "case", "vector_store", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "vec_store_cost", ";", "case", "vec_to_scalar", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "vec_unalign_load_cost", ";", "case", "unaligned_store", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "vec_unalign_store_cost", ";", "case", "cond_branch_taken", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "return", "aarch64_tune_params", "->", "vec_costs", "->", "vec_stmt_cost", ";", "case", "vec_construct", ":", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SparcTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'f'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SP", "::", "FPRegsRegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "v2i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SP", "::", "IntPairRegClass", ")", ";", "else", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SP", "::", "IntRegsRegClass", ")", ";", "}", "}", "else", "if", "(", "!", "Constraint", ".", "empty", "(", ")", "&&", "Constraint", ".", "size", "(", ")", "<=", "5", "&&", "Constraint", "[", "0", "]", "==", "'{'", "&&", "*", "(", "Constraint", ".", "end", "(", ")", "-", "1", ")", "==", "'}'", ")", "{", "StringRef", "name", "(", "Constraint", ".", "data", "(", ")", "+", "1", ",", "Constraint", ".", "size", "(", ")", "-", "2", ")", ";", "uint64_t", "intVal", "=", "0", ";", "if", "(", "name", ".", "substr", "(", "0", ",", "1", ")", ".", "equals", "(", "\"r\"", ")", "&&", "!", "name", ".", "substr", "(", "1", ")", ".", "getAsInteger", "(", "10", ",", "intVal", ")", "&&", "intVal", "<=", "31", ")", "{", "const", "char", "regTypes", "[", "]", "=", "{", "'g'", ",", "'o'", ",", "'l'", ",", "'i'", "}", ";", "char", "regType", "=", "regTypes", "[", "intVal", "/", "8", "]", ";", "char", "regIdx", "=", "'0'", "+", "(", "intVal", "%", "8", ")", ";", "char", "tmp", "[", "]", "=", "{", "'{'", ",", "regType", ",", "regIdx", ",", "'}'", ",", "0", "}", ";", "std", "::", "string", "newConstraint", "=", "std", "::", "string", "(", "tmp", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "newConstraint", ",", "VT", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "Sparc", "Sparc", "1", "0", "0U", "SP::FPRegsRegClass", "MVT::v2i32", "0U", "SP::IntPairRegClass", "0U", "SP::IntRegsRegClass", "5", "0", "1", "1", "2", "0", "0", "1", "\"r\"", "1", "10", "31", "8", "8", "0" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "return", "STI", ".", "hasLoadStoreOnCond", "(", ")", "&&", "getConditionalMove", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "addRange", "(", "uint64_t", "Start", ",", "uint64_t", "End", ",", "Instruction", "*", "Inst", ")", "{", "auto", "I", "=", "std", "::", "lower_bound", "(", "Ranges", ".", "begin", "(", ")", ",", "Ranges", ".", "end", "(", ")", ",", "Start", ",", "[", "]", "(", "const", "Range", "&", "LHS", ",", "uint64_t", "RHS", ")", "{", "return", "LHS", ".", "End", "<=", "RHS", ";", "}", ")", ";", "if", "(", "I", "!=", "Ranges", ".", "end", "(", ")", "&&", "End", ">", "I", "->", "Start", ")", "{", "return", "false", ";", "}", "Ranges", ".", "insert", "(", "I", ",", "{", "Start", ",", "End", ",", "Inst", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "addRange", "-", "Add", "an", "address", "range", "to", "the", "list", "of", "ranges", "for", "this", "unit", "." ]

[ "AArch64" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Assembly Printer\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", ";", "Imm", ".", "Val", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"Mem<\"", ";", "Mem", ".", "Base", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\", \"", ";", "Mem", ".", "Off", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_PhysRegister", ":", "OS", "<<", "\"PhysReg<\"", "<<", "PhysReg", ".", "Num", "<<", "\">\"", ";", "break", ";", "case", "k_RegisterIndex", ":", "OS", "<<", "\"RegIdx<\"", "<<", "RegIdx", ".", "Index", "<<", "\":\"", "<<", "RegIdx", ".", "Kind", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "case", "k_RegList", ":", "OS", "<<", "\"RegList< \"", ";", "for", "(", "auto", "Reg", ":", "(", "*", "RegList", ".", "List", ")", ")", "OS", "<<", "Reg", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_RegPair", ":", "OS", "<<", "\"RegPair<\"", "<<", "RegIdx", ".", "Index", "<<", "\",\"", "<<", "RegIdx", ".", "Index", "+", "1", "<<", "\">\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Mips", "\"Imm<\"", "\">\"", "\"Mem<\"", "\", \"", "\">\"", "\"PhysReg<\"", "\">\"", "\"RegIdx<\"", "\":\"", "\">\"", "\"RegList< \"", "\" \"", "\">\"", "\"RegPair<\"", "\",\"", "1", "\">\"" ]

[]

[ "<s>", "static", "void", "reorg_emit_nops", "(", "rtx_insn", "*", "*", "call_labels", ")", "{", "bool", "first", ";", "rtx", "last_call", ";", "rtx_insn", "*", "prev", ";", "int", "prev_clock", ",", "earliest_bb_end", ";", "int", "prev_implicit_nops", ";", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "last_call", "=", "prev", "=", "NULL", ";", "prev_clock", "=", "-", "1", ";", "earliest_bb_end", "=", "0", ";", "prev_implicit_nops", "=", "0", ";", "first", "=", "true", ";", "while", "(", "insn", ")", "{", "int", "this_clock", "=", "-", "1", ";", "rtx_insn", "*", "next", ";", "int", "max_cycles", "=", "0", ";", "next", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "shadow_or_blockage_p", "(", "insn", ")", "||", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "goto", "next_insn", ";", "if", "(", "!", "c6x_flag_schedule_insns2", ")", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "else", "{", "int", "cycles", ";", "this_clock", "=", "insn_get_clock", "(", "insn", ")", ";", "if", "(", "this_clock", "!=", "prev_clock", ")", "{", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "if", "(", "!", "first", ")", "{", "cycles", "=", "this_clock", "-", "prev_clock", ";", "cycles", "-=", "prev_implicit_nops", ";", "if", "(", "cycles", ">", "1", ")", "{", "rtx", "nop", "=", "emit_nop_after", "(", "cycles", "-", "1", ",", "prev", ")", ";", "insn_set_clock", "(", "nop", ",", "prev_clock", "+", "prev_implicit_nops", "+", "1", ")", ";", "}", "}", "prev_clock", "=", "this_clock", ";", "if", "(", "last_call", "&&", "insn_get_clock", "(", "last_call", ")", "+", "6", "<=", "this_clock", ")", "{", "emit_label_before", "(", "call_labels", "[", "INSN_UID", "(", "last_call", ")", "]", ",", "insn", ")", ";", "last_call", "=", "NULL_RTX", ";", "}", "prev_implicit_nops", "=", "0", ";", "}", "}", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "(", "c6x_flag_schedule_insns2", "||", "!", "returning_call_p", "(", "insn", ")", ")", ")", "{", "max_cycles", "=", "get_attr_cycles", "(", "insn", ")", ";", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_CALLP", ")", "prev_implicit_nops", "=", "5", ";", "}", "else", "max_cycles", "=", "1", ";", "if", "(", "returning_call_p", "(", "insn", ")", ")", "last_call", "=", "insn", ";", "if", "(", "c6x_flag_schedule_insns2", ")", "{", "gcc_assert", "(", "this_clock", ">=", "0", ")", ";", "if", "(", "earliest_bb_end", "<", "this_clock", "+", "max_cycles", ")", "earliest_bb_end", "=", "this_clock", "+", "max_cycles", ";", "}", "else", "if", "(", "max_cycles", ">", "1", ")", "emit_nop_after", "(", "max_cycles", "-", "1", ",", "insn", ")", ";", "prev", "=", "insn", ";", "first", "=", "false", ";", "next_insn", ":", "if", "(", "c6x_flag_schedule_insns2", "&&", "(", "next", "==", "NULL_RTX", "||", "(", "GET_MODE", "(", "next", ")", "==", "TImode", "&&", "INSN_INFO_ENTRY", "(", "INSN_UID", "(", "next", ")", ")", ".", "ebb_start", ")", ")", "&&", "earliest_bb_end", ">", "0", ")", "{", "int", "cycles", "=", "earliest_bb_end", "-", "prev_clock", ";", "if", "(", "cycles", ">", "1", ")", "{", "prev", "=", "emit_nop_after", "(", "cycles", "-", "1", ",", "prev", ")", ";", "insn_set_clock", "(", "prev", ",", "prev_clock", "+", "prev_implicit_nops", "+", "1", ")", ";", "}", "earliest_bb_end", "=", "0", ";", "prev_clock", "=", "-", "1", ";", "first", "=", "true", ";", "if", "(", "last_call", ")", "emit_label_after", "(", "call_labels", "[", "INSN_UID", "(", "last_call", ")", "]", ",", "prev", ")", ";", "last_call", "=", "NULL_RTX", ";", "}", "insn", "=", "next", ";", "}", "}", "</s>" ]

[ "Called", "as", "part", "of", "c6x_reorg", ".", "This", "function", "emits", "multi-cycle", "NOP", "insns", "as", "required", "for", "correctness", ".", "CALL_LABELS", "is", "the", "array", "that", "holds", "the", "return", "labels", "for", "call", "insns", ";", "we", "emit", "these", "here", "if", "scheduling", "was", "run", "earlier", "." ]

[ "c6x", "1", "0", "0", "1", "0", "1", "1", "1", "6", "0", "0", "5", "1", "0", "1", "1", "0", "1", "1", "1", "0", "1" ]

[]

[ "<s>", "bool", "AArch64MCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetGlobalAddressSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "\"unknown operand type\"" ]

[]

[ "<s>", "static", "void", "ix86_emit_mode_set", "(", "int", "entity", ",", "int", "mode", ",", "int", "prev_mode", "ATTRIBUTE_UNUSED", ",", "HARD_REG_SET", "regs_live", ")", "{", "switch", "(", "entity", ")", "{", "case", "AVX_U128", ":", "if", "(", "mode", "==", "AVX_U128_CLEAN", ")", "ix86_avx_emit_vzeroupper", "(", "regs_live", ")", ";", "break", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "case", "I387_MASK_PM", ":", "if", "(", "mode", "!=", "I387_CW_ANY", "&&", "mode", "!=", "I387_CW_UNINITIALIZED", ")", "emit_i387_cw_initialization", "(", "mode", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "one", "or", "more", "insns", "to", "set", "ENTITY", "to", "MODE", ".", "HARD_REG_LIVE", "is", "the", "set", "of", "hard", "registers", "live", "at", "the", "point", "where", "the", "insn", "(", "s", ")", "are", "to", "be", "inserted", "." ]

[ "i386" ]

[]

[ "<s>", "void", "rs6000_emit_swdiv", "(", "rtx", "dst", ",", "rtx", "n", ",", "rtx", "d", ",", "bool", "note_p", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "rtx", "one", ",", "x0", ",", "e0", ",", "x1", ",", "xprev", ",", "eprev", ",", "xnext", ",", "enext", ",", "u", ",", "v", ";", "int", "i", ";", "int", "passes", "=", "(", "TARGET_RECIP_PRECISION", ")", "?", "1", ":", "3", ";", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "V2DFmode", ")", "passes", "++", ";", "enum", "insn_code", "code", "=", "optab_handler", "(", "smul_optab", ",", "mode", ")", ";", "insn_gen_fn", "gen_mul", "=", "GEN_FCN", "(", "code", ")", ";", "gcc_assert", "(", "code", "!=", "CODE_FOR_nothing", ")", ";", "one", "=", "rs6000_load_constant_and_splat", "(", "mode", ",", "dconst1", ")", ";", "x0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "x0", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "d", ")", ",", "UNSPEC_FRES", ")", ")", ")", ";", "if", "(", "passes", ">", "1", ")", "{", "e0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_nmsub", "(", "e0", ",", "d", ",", "x0", ",", "one", ")", ";", "x1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_madd", "(", "x1", ",", "e0", ",", "x0", ",", "x0", ")", ";", "for", "(", "i", "=", "0", ",", "xprev", "=", "x1", ",", "eprev", "=", "e0", ";", "i", "<", "passes", "-", "2", ";", "++", "i", ",", "xprev", "=", "xnext", ",", "eprev", "=", "enext", ")", "{", "enext", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_mul", "(", "enext", ",", "eprev", ",", "eprev", ")", ")", ";", "xnext", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_madd", "(", "xnext", ",", "enext", ",", "xprev", ",", "xprev", ")", ";", "}", "}", "else", "xprev", "=", "x0", ";", "u", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_mul", "(", "u", ",", "n", ",", "xprev", ")", ")", ";", "v", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_nmsub", "(", "v", ",", "d", ",", "u", ",", "n", ")", ";", "rs6000_emit_madd", "(", "dst", ",", "v", ",", "xprev", ",", "u", ")", ";", "if", "(", "note_p", ")", "add_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "gen_rtx_DIV", "(", "mode", ",", "n", ",", "d", ")", ")", ";", "}", "</s>" ]

[ "Newton-Raphson", "approximation", "of", "floating", "point", "divide", "DST", "=", "N/D", ".", "If", "NOTE_P", ",", "add", "a", "reg_note", "saying", "that", "this", "was", "a", "division", ".", "Support", "both", "scalar", "and", "vector", "divide", ".", "Assumes", "no", "trapping", "math", "and", "finite", "arguments", "." ]

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

[]

[ "<s>", "static", "int", "thumb1_base_register_rtx_p", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "strict_p", ")", "{", "int", "regno", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "return", "0", ";", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "strict_p", ")", "return", "THUMB1_REGNO_MODE_OK_FOR_BASE_P", "(", "regno", ",", "mode", ")", ";", "return", "(", "regno", "<=", "LAST_LO_REGNUM", "||", "regno", ">", "LAST_VIRTUAL_REGISTER", "||", "regno", "==", "FRAME_POINTER_REGNUM", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "&&", "(", "regno", "==", "STACK_POINTER_REGNUM", "||", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "x", "==", "hard_frame_pointer_rtx", "||", "x", "==", "arg_pointer_rtx", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "valid", "as", "a", "16-bit", "Thumb", "state", "base", "register", "." ]

[ "arm", "0", "4" ]

[]

[ "<s>", "virtual", "const", "TargetFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "SystemZ" ]

[]

[ "<s>", "static", "HARD_REG_SET", "ix86_zero_call_used_regs", "(", "HARD_REG_SET", "need_zeroed_hardregs", ")", "{", "HARD_REG_SET", "zeroed_hardregs", ";", "bool", "all_sse_zeroed", "=", "false", ";", "int", "all_st_zeroed_num", "=", "0", ";", "bool", "all_mm_zeroed", "=", "false", ";", "CLEAR_HARD_REG_SET", "(", "zeroed_hardregs", ")", ";", "rtx", "zero_all_vec_insn", "=", "zero_all_vector_registers", "(", "need_zeroed_hardregs", ")", ";", "if", "(", "zero_all_vec_insn", ")", "{", "emit_insn", "(", "zero_all_vec_insn", ")", ";", "all_sse_zeroed", "=", "true", ";", "}", "bool", "exit_with_mmx_mode", "=", "(", "crtl", "->", "return_rtx", "&&", "(", "MMX_REG_P", "(", "crtl", "->", "return_rtx", ")", ")", ")", ";", "if", "(", "!", "exit_with_mmx_mode", ")", "{", "all_st_zeroed_num", "=", "zero_all_st_registers", "(", "need_zeroed_hardregs", ")", ";", "if", "(", "all_st_zeroed_num", ">", "0", ")", "for", "(", "unsigned", "int", "regno", "=", "FIRST_STACK_REG", ";", "regno", "<=", "LAST_STACK_REG", ";", "regno", "++", ")", "if", "(", "all_st_zeroed_num", "==", "8", "||", "!", "(", "(", "all_st_zeroed_num", ">=", "6", "&&", "regno", "==", "REGNO", "(", "crtl", "->", "return_rtx", ")", ")", "||", "(", "all_st_zeroed_num", "==", "6", "&&", "(", "regno", "==", "(", "REGNO", "(", "crtl", "->", "return_rtx", ")", "+", "1", ")", ")", ")", ")", ")", "SET_HARD_REG_BIT", "(", "zeroed_hardregs", ",", "regno", ")", ";", "}", "else", "{", "unsigned", "int", "exit_mmx_regno", "=", "REGNO", "(", "crtl", "->", "return_rtx", ")", ";", "all_mm_zeroed", "=", "zero_all_mm_registers", "(", "need_zeroed_hardregs", ",", "exit_mmx_regno", ")", ";", "if", "(", "all_mm_zeroed", ")", "for", "(", "unsigned", "int", "regno", "=", "FIRST_MMX_REG", ";", "regno", "<=", "LAST_MMX_REG", ";", "regno", "++", ")", "if", "(", "regno", "!=", "exit_mmx_regno", ")", "SET_HARD_REG_BIT", "(", "zeroed_hardregs", ",", "regno", ")", ";", "}", "for", "(", "unsigned", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "{", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ")", "continue", ";", "if", "(", "!", "zero_call_used_regno_p", "(", "regno", ",", "all_sse_zeroed", ",", "exit_with_mmx_mode", "&&", "!", "all_mm_zeroed", ")", ")", "continue", ";", "SET_HARD_REG_BIT", "(", "zeroed_hardregs", ",", "regno", ")", ";", "machine_mode", "mode", "=", "zero_call_used_regno_mode", "(", "regno", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rtx", "tmp", "=", "gen_rtx_SET", "(", "reg", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "if", "(", "!", "TARGET_USE_MOV0", "||", "optimize_insn_for_size_p", "(", ")", ")", "{", "rtx", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "tmp", ",", "clob", ")", ")", ";", "}", "case", "E_V4SFmode", ":", "case", "E_HImode", ":", "case", "E_V2SImode", ":", "emit_insn", "(", "tmp", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "zeroed_hardregs", ";", "}", "</s>" ]

[ "Generate", "a", "sequence", "of", "instructions", "that", "zero", "registers", "specified", "by", "NEED_ZEROED_HARDREGS", ".", "Return", "the", "ZEROED_HARDREGS", "that", "are", "actually", "zeroed", "." ]

[ "i386", "0", "0", "8", "6", "6", "1", "0", "2" ]

[]

[ "<s>", "const", "char", "*", "output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ";", "rtx", "xops", "[", "3", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "-", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"addl %0 = %1, %0\"", ",", "xops", ")", ";", "fputs", "(", "\"\\t;;\\n\"", ",", "asm_out_file", ")", ";", "output_asm_insn", "(", "\"probe.w.fault %0, 0\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "reg2", ";", "xops", "[", "2", "]", "=", "gen_rtx_REG", "(", "BImode", ",", "PR_REG", "(", "6", ")", ")", ";", "output_asm_insn", "(", "\"cmp.eq %2, %I2 = %0, %1\"", ",", "xops", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t(%s) br.cond.dpnt \"", ",", "reg_names", "[", "PR_REG", "(", "7", ")", "]", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Wrapper", "around", "the", "output_probe_stack_range", "routines", "." ]

[ "ia64", "0", "32", "3", "\"LPSRL\"", "0", "1", "\"addl %0 = %1, %0\"", "\"\\t;;\\n\"", "\"probe.w.fault %0, 0\"", "1", "2", "6", "\"cmp.eq %2, %I2 = %0, %1\"", "\"\\t(%s) br.cond.dpnt \"", "7", "\"\"" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "Offset", "<=", "INT_MAX", "&&", "\"Offset too big to fit in int.\"", ")", ";", "assert", "(", "MI", "&&", "\"Unable to get the legal offset for nil instruction.\"", ")", ";", "StackOffset", "SaveOffset", "(", "Offset", ",", "MVT", "::", "i8", ")", ";", "return", "isAArch64FrameOffsetLegal", "(", "*", "MI", ",", "SaveOffset", ")", "&", "AArch64FrameOffsetIsLegal", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "AArch64", "AArch64", "\"Offset too big to fit in int.\"", "\"Unable to get the legal offset for nil instruction.\"", "MVT::i8", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "rs6000_file_start", "(", "void", ")", "{", "size_t", "i", ";", "char", "buffer", "[", "80", "]", ";", "const", "char", "*", "start", "=", "buffer", ";", "struct", "rs6000_cpu_select", "*", "ptr", ";", "const", "char", "*", "default_cpu", "=", "TARGET_CPU_DEFAULT", ";", "FILE", "*", "file", "=", "asm_out_file", ";", "default_file_start", "(", ")", ";", "if", "(", "(", "TARGET_DEFAULT", "^", "target_flags", ")", "&", "MASK_64BIT", ")", "default_cpu", "=", "0", ";", "if", "(", "flag_verbose_asm", ")", "{", "sprintf", "(", "buffer", ",", "\"\\n%s rs6000/powerpc options:\"", ",", "ASM_COMMENT_START", ")", ";", "rs6000_select", "[", "0", "]", ".", "string", "=", "default_cpu", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "rs6000_select", ")", ";", "i", "++", ")", "{", "ptr", "=", "&", "rs6000_select", "[", "i", "]", ";", "if", "(", "ptr", "->", "string", "!=", "(", "char", "*", ")", "0", "&&", "ptr", "->", "string", "[", "0", "]", "!=", "'\\0'", ")", "{", "fprintf", "(", "file", ",", "\"%s %s%s\"", ",", "start", ",", "ptr", "->", "name", ",", "ptr", "->", "string", ")", ";", "start", "=", "\"\"", ";", "}", "}", "if", "(", "PPC405_ERRATUM77", ")", "{", "fprintf", "(", "file", ",", "\"%s PPC405CR_ERRATUM77\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "}", "switch", "(", "rs6000_sdata", ")", "{", "case", "SDATA_NONE", ":", "fprintf", "(", "file", ",", "\"%s -msdata=none\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "case", "SDATA_DATA", ":", "fprintf", "(", "file", ",", "\"%s -msdata=data\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "case", "SDATA_SYSV", ":", "fprintf", "(", "file", ",", "\"%s -msdata=sysv\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "case", "SDATA_EABI", ":", "fprintf", "(", "file", ",", "\"%s -msdata=eabi\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "}", "if", "(", "rs6000_sdata", "&&", "g_switch_value", ")", "{", "fprintf", "(", "file", ",", "\"%s -G \"", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "start", ",", "g_switch_value", ")", ";", "start", "=", "\"\"", ";", "}", "if", "(", "*", "start", "==", "'\\0'", ")", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "(", "TARGET_ELF", "&&", "flag_pic", "==", "2", ")", ")", "{", "toc_section", "(", ")", ";", "text_section", "(", ")", ";", "}", "}", "</s>" ]

[ "Do", "anything", "needed", "at", "the", "start", "of", "the", "asm", "file", "." ]

[ "rs6000", "80", "0", "\"\\n%s rs6000/powerpc options:\"", "0", "0", "0", "0", "\"%s %s%s\"", "\"\"", "\"%s PPC405CR_ERRATUM77\"", "\"\"", "\"%s -msdata=none\"", "\"\"", "\"%s -msdata=data\"", "\"\"", "\"%s -msdata=sysv\"", "\"\"", "\"%s -msdata=eabi\"", "\"\"", "\"%s -G \"", "\"\"", "2" ]

[]

[ "<s>", "static", "bool", "mn10300_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "*", "total", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "0", "&&", "outer_code", "==", "SET", ")", "*", "total", "=", "0", ";", "else", "if", "(", "INT_8_BITS", "(", "INTVAL", "(", "x", ")", ")", ")", "*", "total", "=", "1", ";", "else", "if", "(", "INT_16_BITS", "(", "INTVAL", "(", "x", ")", ")", "||", "(", "INTVAL", "(", "x", ")", "&", "0xffff", ")", "==", "0", "||", "(", "INTVAL", "(", "x", ")", "&", "0xffff0000", ")", "==", "0", ")", "*", "total", "=", "2", ";", "else", "*", "total", "=", "4", ";", "return", "true", ";", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "6", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "*", "total", "=", "8", ";", "return", "true", ";", "case", "MOD", ":", "case", "DIV", ":", "case", "MULT", ":", "*", "total", "=", "8", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_RTX_COSTS", "hook", ".", "Speed-relative", "costs", "are", "relative", "to", "COSTS_N_INSNS", ",", "which", "is", "intended", "to", "represent", "cycles", ".", "Size-relative", "costs", "are", "in", "bytes", "." ]

[ "mn10300", "0", "0", "1", "0xffff", "0", "0xffff0000", "0", "2", "4", "6", "8", "8" ]

[]

[ "<s>", "static", "int", "get_insn_side", "(", "rtx_insn", "*", "insn", ",", "enum", "attr_units", "units", ")", "{", "if", "(", "units", "==", "UNITS_D_ADDR", ")", "return", "(", "get_attr_addr_regfile", "(", "insn", ")", "==", "ADDR_REGFILE_A", "?", "0", ":", "1", ")", ";", "else", "{", "enum", "attr_dest_regfile", "rf", "=", "get_attr_dest_regfile", "(", "insn", ")", ";", "if", "(", "rf", "==", "DEST_REGFILE_ANY", ")", "return", "get_attr_type", "(", "insn", ")", "==", "TYPE_BRANCH", "?", "0", ":", "1", ";", "else", "return", "rf", "==", "DEST_REGFILE_A", "?", "0", ":", "1", ";", "}", "}", "</s>" ]

[ "Compute", "the", "side", "of", "the", "machine", "used", "by", "INSN", ",", "which", "reserves", "UNITS", ".", "This", "must", "match", "the", "reservations", "in", "the", "scheduling", "description", "." ]

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

[]

[ "<s>", "const", "char", "*", "LC3TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "LC3ISD", "::", "RET_FLAG", ":", "return", "\"RetFlag\"", ";", "case", "LC3ISD", "::", "LOAD_SYM", ":", "return", "\"LOAD_SYM\"", ";", "case", "LC3ISD", "::", "MOVEi16", ":", "return", "\"MOVEi16\"", ";", "case", "LC3ISD", "::", "CALL", ":", "return", "\"CALL\"", ";", "}", "}", "</s>" ]

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

[ "LC3", "LC3", "LC3ISD::RET_FLAG", "\"RetFlag\"", "LC3ISD::LOAD_SYM", "\"LOAD_SYM\"", "LC3ISD::MOVEi16", "\"MOVEi16\"", "LC3ISD::CALL", "\"CALL\"" ]

[]

[ "<s>", "void", "ix86_expand_truncdf_32", "(", "rtx", "operand0", ",", "rtx", "operand1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "xa2", ",", "TWO52", ",", "tmp", ",", "one", ",", "res", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "copy_to_reg", "(", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xa2", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "xa", ",", "TWO52", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "xa2", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa2", ",", "TWO52", ",", "xa2", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "one", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "dconst1", ",", "mode", ")", ")", ";", "tmp", "=", "ix86_expand_sse_compare_mask", "(", "UNGT", ",", "xa2", ",", "xa", ",", "false", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_AND", "(", "mode", ",", "one", ",", "tmp", ")", ")", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa2", ",", "tmp", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "HONOR_SIGNED_ZEROS", "(", "mode", ")", "&&", "flag_rounding_math", ")", "tmp", "=", "ix86_expand_sse_fabs", "(", "tmp", ",", "NULL", ")", ";", "ix86_sse_copysign_to_positive", "(", "res", ",", "tmp", ",", "res", ",", "mask", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE", "sequence", "for", "computing", "trunc", "from", "OPERAND1", "storing", "into", "OPERAND0", "." ]

[ "i386", "0", "0", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"2003f Eliminate Pseudo Instr FI_MALKRZ\"", ";", "}", "</s>" ]

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

[ "F2003f", "\"2003f Eliminate Pseudo Instr FI_MALKRZ\"" ]

[]

[ "<s>", "static", "reg_class_t", "pa_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "int", "regno", ";", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "if", "(", "rclass", "==", "R1_REGS", ")", "return", "NO_REGS", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "rclass", "==", "BASE_REG_CLASS", "&&", "regno", "<", "FIRST_PSEUDO_REGISTER", ")", "return", "NO_REGS", ";", "}", "else", "regno", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "MEM", ")", "return", "NO_REGS", ";", "if", "(", "flag_pic", "&&", "FP_REG_CLASS_P", "(", "rclass", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insi_r1", ";", "break", ";", "case", "E_DImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indi_r1", ";", "break", ";", "case", "E_SFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insf_r1", ";", "break", ";", "case", "E_DFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indf_r1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "NO_REGS", ";", "}", "if", "(", "pa_symbolic_expression_p", "(", "x", ")", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "flag_pic", "||", "!", "read_only_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insi_r1", ";", "break", ";", "case", "E_DImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indi_r1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "NO_REGS", ";", "}", "}", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "==", "-", "1", ")", "&&", "FP_REG_CLASS_P", "(", "rclass", ")", ")", "{", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "IS_INDEX_ADDR_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "}", "sri", "->", "icode", "=", "(", "in_p", "?", "direct_optab_handler", "(", "reload_in_optab", ",", "mode", ")", ":", "direct_optab_handler", "(", "reload_out_optab", ",", "mode", ")", ")", ";", "return", "NO_REGS", ";", "}", "if", "(", "rclass", "==", "SHIFT_REGS", ")", "{", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "<", "0", ")", "{", "sri", "->", "icode", "=", "(", "in_p", "?", "direct_optab_handler", "(", "reload_in_optab", ",", "mode", ")", ":", "direct_optab_handler", "(", "reload_out_optab", ",", "mode", ")", ")", ";", "return", "NO_REGS", ";", "}", "if", "(", "FP_REG_CLASS_P", "(", "REGNO_REG_CLASS", "(", "regno", ")", ")", ")", "return", "GENERAL_REGS", ";", "}", "if", "(", "regno", ">=", "0", "&&", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_REG_CLASS", "(", "regno", ")", "==", "SHIFT_REGS", "&&", "FP_REG_CLASS_P", "(", "rclass", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Inform", "reload", "about", "cases", "where", "moving", "X", "with", "a", "mode", "MODE", "to", "or", "from", "a", "register", "in", "RCLASS", "requires", "an", "extra", "scratch", "or", "immediate", "register", ".", "Return", "the", "class", "needed", "for", "the", "immediate", "register", "." ]

[ "pa", "1", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Prepare For LiveIntervals\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Prepare For LiveIntervals\"" ]

[]

[ "<s>", "static", "tree", "v850_handle_interrupt_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "v850", "\"%qs attribute only applies to functions\"" ]

[]

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

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "InstructionCost", "RISCVTTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsUnsigned", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "!", "isa", "<", "FixedVectorType", ">", "(", "Ty", ")", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "if", "(", "!", "ST", "->", "useRVVForFixedLengthVectors", "(", ")", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "if", "(", "Ty", "->", "getScalarSizeInBits", "(", ")", ">", "ST", "->", "getMaxELENForFixedLengthVectors", "(", ")", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "InstructionCost", "BaseCost", "=", "2", ";", "unsigned", "VL", "=", "cast", "<", "FixedVectorType", ">", "(", "Ty", ")", "->", "getNumElements", "(", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "(", "LT", ".", "first", "-", "1", ")", "+", "BaseCost", "+", "Log2_32_Ceil", "(", "VL", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "2", "1" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDValue", "Result", "=", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "(", "!", "Result", ".", "getNode", "(", ")", "||", "Result", ".", "getNode", "(", ")", "->", "getNumValues", "(", ")", "==", "2", ")", "&&", "\"Load should return a value and a chain\"", ")", ";", "return", "Result", ";", "}", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "return", "LowerTrig", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "LowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "LowerGlobalAddress", "(", "MFI", ",", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDRSPACECAST", ":", "return", "lowerADDRSPACECAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAP", ":", "return", "lowerTRAP", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "ISD::FrameIndex", "ISD::BRCOND", "ISD::LOAD", "2", "\"Load should return a value and a chain\"", "ISD::FSIN", "ISD::FCOS", "ISD::SELECT", "ISD::FDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::STORE", "ISD::GlobalAddress", "SI", "SI", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::INTRINSIC_W_CHAIN", "SI", "ISD::INTRINSIC_VOID", "SI", "ISD::ADDRSPACECAST", "ISD::TRAP" ]

[]

[ "<s>", "static", "void", "set_callers_may_not_allocate_frame", "(", "function", "*", "fn", ")", "{", "basic_block", "bb", ";", "gimple_stmt_iterator", "gsi", ";", "gimple", "*", "stmt", ";", "tree", "called_fn_tree", ";", "function", "*", "called_fn", ";", "if", "(", "fn", "->", "cfg", "==", "NULL", ")", "return", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "fn", ")", "{", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "{", "stmt", "=", "gsi_stmt", "(", "gsi", ")", ";", "if", "(", "is_gimple_call", "(", "stmt", ")", ")", "{", "called_fn_tree", "=", "gimple_call_fndecl", "(", "stmt", ")", ";", "if", "(", "called_fn_tree", "!=", "NULL", ")", "{", "called_fn", "=", "DECL_STRUCT_FUNCTION", "(", "called_fn_tree", ")", ";", "if", "(", "called_fn", "!=", "NULL", ")", "called_fn", "->", "machine", "->", "callers_may_not_allocate_frame", "=", "true", ";", "}", "}", "}", "}", "return", ";", "}", "</s>" ]

[ "Set", "the", "callers_may_not_allocate_frame", "flag", "for", "any", "function", "which", "function", "FN", "calls", "because", "FN", "may", "not", "allocate", "a", "frame", "header", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "AnalyzeArguments", "(", "CCState", "&", "State", ",", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "ArgLocs", ",", "const", "SmallVectorImpl", "<", "ArgT", ">", "&", "Args", ")", "{", "static", "const", "uint16_t", "RegList", "[", "]", "=", "{", "MD", "::", "R0", ",", "MD", "::", "R1", ",", "MD", "::", "R2", ",", "MD", "::", "R3", "}", ";", "static", "const", "unsigned", "NbRegs", "=", "array_lengthof", "(", "RegList", ")", ";", "if", "(", "State", ".", "isVarArg", "(", ")", ")", "{", "AnalyzeVarArgs", "(", "State", ",", "Args", ")", ";", "return", ";", "}", "SmallVector", "<", "unsigned", ",", "4", ">", "ArgsParts", ";", "ParseFunctionArgs", "(", "Args", ",", "ArgsParts", ")", ";", "unsigned", "RegsLeft", "=", "NbRegs", ";", "bool", "UseStack", "=", "false", ";", "unsigned", "ValNo", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgsParts", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "MVT", "ArgVT", "=", "Args", "[", "ValNo", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Args", "[", "ValNo", "]", ".", "Flags", ";", "MVT", "LocVT", "=", "ArgVT", ";", "CCValAssign", "::", "LocInfo", "LocInfo", "=", "CCValAssign", "::", "Full", ";", "if", "(", "ArgFlags", ".", "isByVal", "(", ")", ")", "{", "State", ".", "HandleByVal", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "2", ",", "2", ",", "ArgFlags", ")", ";", "continue", ";", "}", "unsigned", "Parts", "=", "ArgsParts", "[", "i", "]", ";", "if", "(", "!", "UseStack", "&&", "Parts", "<=", "RegsLeft", ")", "{", "unsigned", "FirstVal", "=", "ValNo", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "{", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "RegList", ",", "NbRegs", ")", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", "++", ",", "ArgVT", ",", "Reg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "RegsLeft", "--", ";", "}", "}", "else", "{", "UseStack", "=", "true", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "{", "if", "(", "ArgFlags", ".", "isByVal", "(", ")", ")", "{", "State", ".", "HandleByVal", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "4", ",", "4", ",", "ArgFlags", ")", ";", "continue", ";", "}", "if", "(", "LocVT", "==", "MVT", "::", "i32", "||", "LocVT", "==", "MVT", "::", "f32", ")", "{", "unsigned", "Offset1", "=", "State", ".", "AllocateStack", "(", "4", ",", "4", ")", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getMem", "(", "ValNo", "++", ",", "ArgVT", ",", "Offset1", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "continue", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "The", "function", "will", "invoke", "AnalyzeCallOperands", "." ]

[ "Mandarin", "MD::R0", "MD::R1", "MD::R2", "MD::R3", "4", "0", "0", "ISD::ArgFlagsTy", "2", "2", "0", "0", "4", "4", "MVT::i32", "MVT::f32", "4", "4" ]

[]

[ "<s>", "static", "section", "*", "ft32_select_section", "(", "tree", "decl", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "&&", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", "==", "ADDR_SPACE_PM", ")", "{", "if", "(", "!", "DECL_P", "(", "decl", ")", ")", "return", "get_section", "(", "\"._pm\"", ",", "SECTION_WRITE", "|", "SECTION_DEBUG", ",", "NULL", ")", ";", "return", "get_named_section", "(", "decl", ",", "\"._pm\"", ",", "reloc", ")", ";", "}", "return", "default_elf_select_section", "(", "decl", ",", "reloc", ",", "align", ")", ";", "}", "</s>" ]

[ "Implement", "targetm.select_section", "." ]

[ "ft32", "\"._pm\"", "\"._pm\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "8", ")", "-", "1", ")", "*", "4", "/", "2", ")", "return", "false", ";", "return", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "1", "8", "1", "4", "2" ]

[]

[ "<s>", "void", "PPCPostRASchedStrategy", "::", "enterMBB", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "PostGenericScheduler", "::", "enterMBB", "(", "MBB", ")", ";", "}", "</s>" ]

[ "Tell", "the", "strategy", "that", "MBB", "is", "about", "to", "be", "processed", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "bool", "ix86_tieable_integer_mode_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "case", "E_SImode", ":", "return", "true", ";", "case", "E_QImode", ":", "return", "TARGET_64BIT", "||", "!", "TARGET_PARTIAL_REG_STALL", ";", "case", "E_DImode", ":", "return", "TARGET_64BIT", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_modes_tieable_p", ".", "Return", "true", "if", "MODE", "is", "a", "tieable", "integer", "mode", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "moxie_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "mem", ",", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "4", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "16", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "}", "</s>" ]

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

[ "moxie", "0", "4", "16" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "X86_64Relocator", "::", "getName", "(", "Relocation", "::", "Type", "pType", ")", "const", "{", "return", "X86_64ApplyFunctions", "[", "pType", "]", ".", "name", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "avr_asm_len", "(", "const", "char", "*", "tpl", ",", "rtx", "*", "operands", ",", "int", "*", "plen", ",", "int", "n_words", ")", "{", "if", "(", "plen", "==", "NULL", ")", "output_asm_insn", "(", "tpl", ",", "operands", ")", ";", "else", "{", "if", "(", "n_words", "<", "0", ")", "*", "plen", "=", "-", "n_words", ";", "else", "*", "plen", "+=", "n_words", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Helper", "function", "to", "print", "assembler", "resp", ".", "track", "instruction", "sequence", "lengths", ".", "Always", "return", "``", "''", ".", "If", "PLEN", "==", "NULL", ":", "Output", "assembler", "code", "from", "template", "TPL", "with", "operands", "supplied", "by", "OPERANDS", ".", "This", "is", "just", "forwarding", "to", "output_asm_insn", ".", "If", "PLEN", "!", "=", "NULL", ":", "If", "N_WORDS", ">", "=", "0", "Add", "N_WORDS", "to", "*", "PLEN", ".", "If", "N_WORDS", "<", "0", "Set", "*", "PLEN", "to", "-N_WORDS", ".", "Do", "n't", "output", "anything", "." ]

[ "avr", "0", "\"\"" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "\"should not see multiple frame indices\"", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "\"frame index must be address operand\"", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", ")", ";", "assert", "(", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", "->", "getReg", "(", ")", "==", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "getStackPtrOffsetReg", "(", ")", "&&", "\"should only be seeing stack pointer offset relative FrameIndex\"", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "assert", "(", "isUInt", "<", "12", ">", "(", "NewOffset", ")", "&&", "\"offset should be legal\"", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AMDGPU", "SI", "SI", "\"should not see multiple frame indices\"", "AMDGPU::OpName", "\"frame index must be address operand\"", "AMDGPU::OpName", "SI", "\"should only be seeing stack pointer offset relative FrameIndex\"", "AMDGPU::OpName", "12", "\"offset should be legal\"" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", ")", ")", ";", "addPass", "(", "&", "AMDGPUUnifyDivergentExitNodesID", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createStructurizeCFGPass", "(", "true", ")", ")", ";", "}", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "TuneCPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "MaybeAlign", "StackAlignOverride", ",", "unsigned", "PreferVectorWidthOverride", ",", "unsigned", "RequiredVectorWidth", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "TuneCPU", ",", "FS", ")", ",", "PICStyle", "(", "PICStyles", "::", "Style", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "PreferVectorWidthOverride", "(", "PreferVectorWidthOverride", ")", ",", "RequiredVectorWidth", "(", "RequiredVectorWidth", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "TuneCPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "None", ")", ";", "else", "if", "(", "is64Bit", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "RIPRel", ")", ";", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "None", ")", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "GOT", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "this", ",", "TM", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "InstSelector", ".", "reset", "(", "createX86InstructionSelector", "(", "TM", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "DecodeStatus", "AMDGPUDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes_", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "WS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "bool", "IsSDWA", "=", "false", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureGCN3Encoding", "]", ")", "report_fatal_error", "(", "\"Disassembly not yet supported for subtarget\"", ")", ";", "const", "unsigned", "MaxInstBytesNum", "=", "(", "std", "::", "min", ")", "(", "(", "size_t", ")", "8", ",", "Bytes_", ".", "size", "(", ")", ")", ";", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "DecodeStatus", "Res", "=", "MCDisassembler", "::", "Fail", ";", "do", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "const", "uint64_t", "QW", "=", "eatBytes", "<", "uint64_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableDPP64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "{", "IsSDWA", "=", "true", ";", "break", ";", "}", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA964", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "{", "IsSDWA", "=", "true", ";", "break", ";", "}", "}", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint32_t", "DW", "=", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint64_t", "QW", "=", "(", "(", "uint64_t", ")", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", "<<", "32", ")", "|", "DW", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "}", "while", "(", "false", ")", ";", "if", "(", "Res", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_vi", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_si", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_e64_vi", ")", ")", "{", "insertNamedMCOperand", "(", "MI", ",", "MCOperand", "::", "createImm", "(", "0", ")", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "}", "if", "(", "Res", "&&", "IsSDWA", ")", "Res", "=", "convertSDWAInst", "(", "MI", ")", ";", "Size", "=", "Res", "?", "(", "MaxInstBytesNum", "-", "Bytes", ".", "size", "(", ")", ")", ":", "0", ";", "return", "Res", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::FeatureGCN3Encoding", "\"Disassembly not yet supported for subtarget\"", "8", "0", "8", "0", "4", "AMDGPU", "4", "32", "AMDGPU", "AMDGPU::V_MAC_F32_e64_vi", "AMDGPU::V_MAC_F32_e64_si", "AMDGPU::V_MAC_F16_e64_vi", "0", "AMDGPU::OpName", "0" ]

[]

[ "<s>", "void", "ARMHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "{", "LastMI", "=", "MI", ";", "FpMLxStalls", "=", "0", ";", "}", "ScoreboardHazardRecognizer", "::", "EmitInstruction", "(", "SU", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "inline", "bool", "save_reg_p", "(", "int", "r", ")", "{", "return", "!", "call_used_regs", "[", "r", "]", "&&", "df_regs_ever_live_p", "(", "r", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "the", "REG", "is", "really", "used", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "bool", "isPairedLdSt", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "LDPSWi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "STPQi", ":", "case", "AArch64", "::", "STPWi", ":", "case", "AArch64", "::", "STPXi", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "a", "paired", "load/store", "." ]

[ "AArch64", "AArch64::LDPSi", "AArch64::LDPSWi", "AArch64::LDPDi", "AArch64::LDPQi", "AArch64::LDPWi", "AArch64::LDPXi", "AArch64::STPSi", "AArch64::STPDi", "AArch64::STPQi", "AArch64::STPWi", "AArch64::STPXi" ]

[]

[ "<s>", "uint64_t", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ")", "const", "{", "unsigned", "LblOperand", "=", "Inst", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "Bcc", "?", "1", ":", "0", ";", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "LblOperand", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "-", "1ULL", ";", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "LblOperand", ")", ".", "getImm", "(", ")", ";", "return", "Addr", "+", "Imm", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "AArch64", "AArch64::Bcc", "1", "0", "1ULL" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "HexagonISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::OutputArg", "16", "Hexagon", "4", "1", "0", "1", "0", "HexagonISD::RET_FLAG", "MVT::Other", "0" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "this", "->", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "MCS51" ]

[]

[ "<s>", "static", "bool", "aarch64_rtx_costs_wrapper", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer", ",", "int", "param", ",", "int", "*", "cost", ",", "bool", "speed", ")", "{", "bool", "result", "=", "aarch64_rtx_costs", "(", "x", ",", "mode", ",", "outer", ",", "param", ",", "cost", ",", "speed", ")", ";", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "{", "print_rtl_single", "(", "dump_file", ",", "x", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n%s cost: %d (%s)\\n\"", ",", "speed", "?", "\"Hot\"", ":", "\"Cold\"", ",", "*", "cost", ",", "result", "?", "\"final\"", ":", "\"partial\"", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Wrapper", "around", "aarch64_rtx_costs", ",", "dumps", "the", "partial", ",", "or", "total", "cost", "calculated", "for", "X", ".", "This", "cost", "is", "stored", "in", "*", "COST", ".", "Returns", "true", "if", "the", "total", "cost", "of", "X", "was", "calculated", "." ]

[ "aarch64", "\"\\n%s cost: %d (%s)\\n\"", "\"Hot\"", "\"Cold\"", "\"final\"", "\"partial\"" ]

[]

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

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Expand Condsets\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Expand Condsets\"" ]

[]

[ "<s>", "static", "void", "single_move_for_cpymem", "(", "rtx", "dst", ",", "rtx", "src", ",", "machine_mode", "mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "scratch", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "srcmem", ",", "dstmem", ";", "srcmem", "=", "adjust_address_nv", "(", "src", ",", "mode", ",", "offset", ")", ";", "dstmem", "=", "adjust_address_nv", "(", "dst", ",", "mode", ",", "offset", ")", ";", "emit_move_insn", "(", "scratch", ",", "srcmem", ")", ";", "emit_move_insn", "(", "dstmem", ",", "scratch", ")", ";", "}", "</s>" ]

[ "Adjust", "DST", "and", "SRC", "by", "OFFSET", "bytes", ",", "and", "generate", "one", "move", "in", "mode", "MODE", "." ]

[ "bfin" ]

[]

[ "<s>", "const", "char", "*", "output_add_immediate", "(", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "!=", "0", "||", "REGNO", "(", "operands", "[", "0", "]", ")", "!=", "REGNO", "(", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "n", "<", "0", ")", "output_multi_immediate", "(", "operands", ",", "\"sub%?\\t%0, %1, %2\"", ",", "\"sub%?\\t%0, %0, %2\"", ",", "2", ",", "-", "n", ")", ";", "else", "output_multi_immediate", "(", "operands", ",", "\"add%?\\t%0, %1, %2\"", ",", "\"add%?\\t%0, %0, %2\"", ",", "2", ",", "n", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "an", "ADD", "r", ",", "s", ",", "#", "n", "where", "n", "may", "be", "too", "big", "for", "one", "instruction", ".", "If", "adding", "zero", "to", "one", "register", ",", "output", "nothing", "." ]

[ "arm", "2", "0", "0", "1", "0", "\"sub%?\\t%0, %1, %2\"", "\"sub%?\\t%0, %0, %2\"", "2", "\"add%?\\t%0, %1, %2\"", "\"add%?\\t%0, %0, %2\"", "2", "\"\"" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "ft32_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Zero", "initialization", "is", "OK", "for", "all", "current", "fields", "." ]

[ "ft32" ]

[]

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

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

[ "sparc", "8", "16", "2" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "X86TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "Type", "*", "MemType", "=", "LI", "->", "getType", "(", ")", ";", "bool", "NoImplicitFloatOps", "=", "LI", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "useSoftFloat", "(", ")", "&&", "!", "NoImplicitFloatOps", "&&", "(", "Subtarget", ".", "hasSSE2", "(", ")", "||", "Subtarget", ".", "hasX87", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "needsCmpXchgNb", "(", "MemType", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

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

[]

[ "<s>", "static", "bool", "consume", "(", "InternalInstruction", "*", "insn", ",", "T", "&", "ptr", ")", "{", "auto", "r", "=", "insn", "->", "bytes", ";", "uint64_t", "offset", "=", "insn", "->", "readerCursor", "-", "insn", "->", "startLocation", ";", "if", "(", "offset", "+", "sizeof", "(", "T", ")", ">", "r", ".", "size", "(", ")", ")", "return", "true", ";", "T", "ret", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "sizeof", "(", "T", ")", ";", "++", "i", ")", "ret", "|=", "(", "uint64_t", ")", "r", "[", "offset", "+", "i", "]", "<<", "(", "i", "*", "8", ")", ";", "ptr", "=", "ret", ";", "insn", "->", "readerCursor", "+=", "sizeof", "(", "T", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Consume", "N", "operations", "." ]

[ "X86", "0", "0", "8" ]

[]

[ "<s>", "TargetPassConfig", "*", "DCPU16TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "DCPU16PassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "Dcpu16", "DCPU16", "DCPU16" ]

[]

[ "<s>", "static", "bool", "extract_base_offset_in_addr", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "*", "offset", "=", "const0_rtx", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "true", ";", "}", "*", "base", "=", "NULL_RTX", ";", "*", "offset", "=", "NULL_RTX", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "MEM", "is", "in", "the", "form", "of", "``", "base+offset", "''", ",", "extract", "the", "two", "parts", "of", "address", "and", "set", "to", "BASE", "and", "OFFSET", ",", "otherwise", "return", "false", "after", "clearing", "BASE", "and", "OFFSET", "." ]

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

[]

[ "<s>", "Optional", "<", "uint64_t", ">", "X86MCInstrAnalysis", "::", "evaluateMemoryOperandAddress", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "*", "STI", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "int", "MemOpStart", "=", "X86II", "::", "getMemoryOperandNo", "(", "MCID", ".", "TSFlags", ")", ";", "if", "(", "MemOpStart", "==", "-", "1", ")", "return", "None", ";", "MemOpStart", "+=", "X86II", "::", "getOperandBias", "(", "MCID", ")", ";", "const", "MCOperand", "&", "SegReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrSegmentReg", ")", ";", "const", "MCOperand", "&", "BaseReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrBaseReg", ")", ";", "const", "MCOperand", "&", "IndexReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrIndexReg", ")", ";", "const", "MCOperand", "&", "ScaleAmt", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrScaleAmt", ")", ";", "const", "MCOperand", "&", "Disp", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "SegReg", ".", "getReg", "(", ")", "!=", "0", "||", "IndexReg", ".", "getReg", "(", ")", "!=", "0", "||", "ScaleAmt", ".", "getImm", "(", ")", "!=", "1", "||", "!", "Disp", ".", "isImm", "(", ")", ")", "return", "None", ";", "if", "(", "BaseReg", ".", "getReg", "(", ")", "==", "X86", "::", "RIP", ")", "return", "Addr", "+", "Size", "+", "Disp", ".", "getImm", "(", ")", ";", "return", "None", ";", "}", "</s>" ]

[ "Given", "an", "instruction", "tries", "to", "get", "the", "address", "of", "a", "memory", "operand", "." ]

[ "X86", "X86", "X86II::getMemoryOperandNo", "1", "X86II::getOperandBias", "X86::AddrSegmentReg", "X86::AddrBaseReg", "X86::AddrIndexReg", "X86::AddrScaleAmt", "X86::AddrDisp", "0", "0", "1", "X86::RIP" ]

[]

[ "<s>", "bool", "VEInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineInstr", "*", "LastInst", "=", "&", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "if", "(", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isCondBranchOpcode", "(", "LastOpc", ")", ")", "{", "parseCondBranch", "(", "LastInst", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "*", "SecondLastInst", "=", "&", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "AllowModify", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "while", "(", "isUncondBranchOpcode", "(", "SecondLastOpc", ")", ")", "{", "LastInst", "->", "eraseFromParent", "(", ")", ";", "LastInst", "=", "SecondLastInst", ";", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "SecondLastInst", "=", "&", "*", "I", ";", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "}", "}", "if", "(", "SecondLastInst", "&&", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "return", "true", ";", "if", "(", "isCondBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "parseCondBranch", "(", "SecondLastInst", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isUncondBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isIndirectBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "I", "=", "LastInst", ";", "if", "(", "AllowModify", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "0", "0", "0" ]

[]

[ "<s>", "int", "general_scalar_chain", "::", "vector_const_cost", "(", "rtx", "exp", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "exp", ")", ")", ";", "if", "(", "standard_sse_constant_p", "(", "exp", ",", "vmode", ")", ")", "return", "ix86_cost", "->", "sse_op", ";", "return", "ix86_cost", "->", "sse_load", "[", "smode", "==", "DImode", "?", "1", ":", "0", "]", ";", "}", "</s>" ]

[ "Return", "a", "cost", "of", "building", "a", "vector", "costant", "instead", "of", "using", "a", "scalar", "one", "." ]

[ "i386", "1", "0" ]

[]

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

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "DataTy", ")", "{", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", "&&", "!", "isPowerOf2_32", "(", "DataTy", "->", "getVectorNumElements", "(", ")", ")", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "isa", "<", "PointerType", ">", "(", "ScalarTy", ")", "?", "DL", ".", "getPointerSizeInBits", "(", ")", ":", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "DataWidth", ">=", "32", "&&", "ST", "->", "hasAVX512", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

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

[]

[ "<s>", "InstructionCost", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", "=", "nullptr", ")", "{", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_RecipThroughput", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "isLegalMaskedGather", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", "&&", "!", "forceScalarizeMaskedGather", "(", "cast", "<", "VectorType", ">", "(", "SrcVTy", ")", ",", "Align", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "isLegalMaskedScatter", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", "&&", "!", "forceScalarizeMaskedScatter", "(", "cast", "<", "VectorType", ">", "(", "SrcVTy", ")", ",", "Align", "(", "Alignment", ")", ")", ")", ")", "return", "1", ";", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "CostKind", ",", "I", ")", ";", "}", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "\"Unexpected data type for Gather/Scatter\"", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "cast", "<", "VectorType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "\"Unexpected type for Ptr argument\"", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "(", "!", "isLegalMaskedGather", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", "||", "forceScalarizeMaskedGather", "(", "cast", "<", "VectorType", ">", "(", "SrcVTy", ")", ",", "Align", "(", "Alignment", ")", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "(", "!", "isLegalMaskedScatter", "(", "SrcVTy", ",", "Align", "(", "Alignment", ")", ")", "||", "forceScalarizeMaskedScatter", "(", "cast", "<", "VectorType", ">", "(", "SrcVTy", ")", ",", "Align", "(", "Alignment", ")", ")", ")", ")", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "X86", "X86", "1", "\"Unexpected data type for Gather/Scatter\"", "\"Unexpected type for Ptr argument\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "PPCSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "hasVSX", "(", ")", "||", "!", "STI", ".", "needsSwapsForVSXMemOps", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "initialize", "(", "MF", ")", ";", "if", "(", "gatherVectorInstructions", "(", ")", ")", "{", "formWebs", "(", ")", ";", "recordUnoptimizableWebs", "(", ")", ";", "markSwapsForRemoval", "(", ")", ";", "Changed", "=", "removeSwaps", "(", ")", ";", "}", "delete", "EC", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreSched2", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "const", "MOSMCExpr", "*", "MOSMCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "bool", "Negated", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "MOSMCExpr", "(", "Kind", ",", "Expr", ",", "Negated", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "MOS", "MOS", "MOS", "MOS" ]

[]

[ "<s>", "EVT", "PPCTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "MVT::i32" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for Sparc.\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "\"TLS not implemented for Sparc.\"", "ISD::GlobalAddress", "ISD::ConstantPool", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::VAARG", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "SelectFrameIndex", "(", "N", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "SelectBitcast", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "SelectZeroExtend", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SelectIntrinsicWChain", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::FrameIndex", "ISD::BITCAST", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "static", "rtx", "rs6000_emit_vector_compare", "(", "enum", "rtx_code", "rcode", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "dmode", ")", "{", "rtx", "mask", ";", "bool", "swap_operands", "=", "false", ";", "bool", "try_again", "=", "false", ";", "gcc_assert", "(", "VECTOR_UNIT_ALTIVEC_OR_VSX_P", "(", "dmode", ")", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "op0", ")", "==", "GET_MODE", "(", "op1", ")", ")", ";", "mask", "=", "rs6000_emit_vector_compare_inner", "(", "rcode", ",", "op0", ",", "op1", ")", ";", "if", "(", "mask", ")", "return", "mask", ";", "switch", "(", "rcode", ")", "{", "case", "LT", ":", "rcode", "=", "GT", ";", "swap_operands", "=", "true", ";", "try_again", "=", "true", ";", "break", ";", "case", "LTU", ":", "rcode", "=", "GTU", ";", "swap_operands", "=", "true", ";", "try_again", "=", "true", ";", "break", ";", "case", "NE", ":", "case", "UNLE", ":", "case", "UNLT", ":", "case", "UNGE", ":", "case", "UNGT", ":", "{", "enum", "rtx_code", "rev_code", ";", "enum", "insn_code", "nor_code", ";", "rtx", "mask2", ";", "rev_code", "=", "reverse_condition_maybe_unordered", "(", "rcode", ")", ";", "if", "(", "rev_code", "==", "UNKNOWN", ")", "return", "NULL_RTX", ";", "nor_code", "=", "optab_handler", "(", "one_cmpl_optab", ",", "dmode", ")", ";", "if", "(", "nor_code", "==", "CODE_FOR_nothing", ")", "return", "NULL_RTX", ";", "mask2", "=", "rs6000_emit_vector_compare", "(", "rev_code", ",", "op0", ",", "op1", ",", "dmode", ")", ";", "if", "(", "!", "mask2", ")", "return", "NULL_RTX", ";", "mask", "=", "gen_reg_rtx", "(", "dmode", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "nor_code", ")", "(", "mask", ",", "mask2", ")", ")", ";", "return", "mask", ";", "}", "break", ";", "case", "GE", ":", "case", "GEU", ":", "case", "LE", ":", "case", "LEU", ":", "{", "rtx", "c_rtx", ",", "eq_rtx", ";", "enum", "insn_code", "ior_code", ";", "enum", "rtx_code", "new_code", ";", "switch", "(", "rcode", ")", "{", "case", "GE", ":", "new_code", "=", "GT", ";", "break", ";", "case", "GEU", ":", "new_code", "=", "GTU", ";", "break", ";", "case", "LE", ":", "new_code", "=", "LT", ";", "break", ";", "case", "LEU", ":", "new_code", "=", "LTU", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "ior_code", "=", "optab_handler", "(", "ior_optab", ",", "dmode", ")", ";", "if", "(", "ior_code", "==", "CODE_FOR_nothing", ")", "return", "NULL_RTX", ";", "c_rtx", "=", "rs6000_emit_vector_compare", "(", "new_code", ",", "op0", ",", "op1", ",", "dmode", ")", ";", "if", "(", "!", "c_rtx", ")", "return", "NULL_RTX", ";", "eq_rtx", "=", "rs6000_emit_vector_compare", "(", "EQ", ",", "op0", ",", "op1", ",", "dmode", ")", ";", "if", "(", "!", "eq_rtx", ")", "return", "NULL_RTX", ";", "mask", "=", "gen_reg_rtx", "(", "dmode", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "ior_code", ")", "(", "mask", ",", "c_rtx", ",", "eq_rtx", ")", ")", ";", "return", "mask", ";", "}", "break", ";", "default", ":", "return", "NULL_RTX", ";", "}", "if", "(", "try_again", ")", "{", "if", "(", "swap_operands", ")", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "mask", "=", "rs6000_emit_vector_compare_inner", "(", "rcode", ",", "op0", ",", "op1", ")", ";", "if", "(", "mask", ")", "return", "mask", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Emit", "vector", "compare", "for", "operands", "OP0", "and", "OP1", "using", "code", "RCODE", ".", "DMODE", "is", "expected", "destination", "mode", ".", "This", "is", "a", "recursive", "function", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "void", "SPUHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "DOUT", "<<", "\"SPUHazardRecognizer::AdvanceCycle\\n\"", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "\"SPUHazardRecognizer::AdvanceCycle\\n\"" ]

[]

[ "<s>", "bool", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "return", "lowerRISCVMachineOperandToMCOperand", "(", "MO", ",", "MCOp", ",", "*", "this", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "HCE", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "\": skipping \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" due to exception handling\\n\"", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ")", ";", "HST", "=", "&", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "HII", "=", "HST", "->", "getInstrInfo", "(", ")", ";", "HRI", "=", "HST", "->", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AssignmentMap", "IMap", ";", "collect", "(", "MF", ")", ";", "llvm", "::", "sort", "(", "Extenders", ",", "[", "this", "]", "(", "const", "ExtDesc", "&", "A", ",", "const", "ExtDesc", "&", "B", ")", "{", "ExtValue", "VA", "(", "A", ")", ",", "VB", "(", "B", ")", ";", "if", "(", "VA", "!=", "VB", ")", "return", "VA", "<", "VB", ";", "const", "MachineInstr", "*", "MA", "=", "A", ".", "UseMI", ";", "const", "MachineInstr", "*", "MB", "=", "B", ".", "UseMI", ";", "if", "(", "MA", "==", "MB", ")", "{", "return", "A", ".", "OpNum", "<", "B", ".", "OpNum", ";", "}", "const", "MachineBasicBlock", "*", "BA", "=", "MA", "->", "getParent", "(", ")", ";", "const", "MachineBasicBlock", "*", "BB", "=", "MB", "->", "getParent", "(", ")", ";", "assert", "(", "BA", "->", "getNumber", "(", ")", "!=", "-", "1", "&&", "BB", "->", "getNumber", "(", ")", "!=", "-", "1", ")", ";", "if", "(", "BA", "!=", "BB", ")", "return", "BA", "->", "getNumber", "(", ")", "<", "BB", "->", "getNumber", "(", ")", ";", "return", "MDT", "->", "dominates", "(", "MA", ",", "MB", ")", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Collected \"", "<<", "Extenders", ".", "size", "(", ")", "<<", "\" extenders\\n\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Extenders", ".", "size", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "unsigned", "B", "=", "I", ";", "const", "ExtRoot", "&", "T", "=", "Extenders", "[", "B", "]", ".", "getOp", "(", ")", ";", "while", "(", "I", "!=", "E", "&&", "ExtRoot", "(", "Extenders", "[", "I", "]", ".", "getOp", "(", ")", ")", "==", "T", ")", "++", "I", ";", "IMap", ".", "clear", "(", ")", ";", "assignInits", "(", "T", ",", "B", ",", "I", ",", "IMap", ")", ";", "Changed", "|=", "replaceExtenders", "(", "IMap", ")", ";", "}", "LLVM_DEBUG", "(", "{", "if", "(", "Changed", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ";", "else", "dbgs", "(", ")", "<<", "\"No changes\\n\"", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "\": skipping \"", "\" due to exception handling\\n\"", "\"Before \"", "Hexagon", "1", "1", "\"Collected \"", "\" extenders\\n\"", "0", "\"After \"", "\"No changes\\n\"" ]

[]

[ "<s>", "uint64_t", "SIMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "return", "getRegBinaryCode", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "MO", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "union", "{", "float", "F", ";", "uint32_t", "I", ";", "}", "Imm", ";", "Imm", ".", "F", "=", "MO", ".", "getFPImm", "(", ")", ";", "return", "Imm", ".", "I", ";", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCFixupKind", "Kind", "=", "MCFixupKind", "(", "FK_PCRel_4", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "return", "0", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Encoding of this operand type is not supported yet.\"", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "R600", "SI", "0", "0", "\"Encoding of this operand type is not supported yet.\"", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getAddrModeArguments", "(", "IntrinsicInst", "*", "II", ",", "SmallVectorImpl", "<", "Value", "*", ">", "&", "Ops", ",", "Type", "*", "&", "AccessTy", ")", "const", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_atomic_fmin", ":", "case", "Intrinsic", "::", "amdgcn_atomic_fmax", ":", "{", "Value", "*", "Ptr", "=", "II", "->", "getArgOperand", "(", "0", ")", ";", "AccessTy", "=", "II", "->", "getType", "(", ")", ";", "Ops", ".", "push_back", "(", "Ptr", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "CodeGenPrepare", "sinks", "address", "calculations", "into", "the", "same", "BB", "as", "Load/Store", "instructions", "reading", "the", "address", "." ]

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_atomic_fadd", "Intrinsic::amdgcn_atomic_fmin", "Intrinsic::amdgcn_atomic_fmax", "0" ]

[]

[ "<s>", "void", "function_arg_advance", "(", "struct", "sparc_args", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "int", "slotno", ",", "regno", ",", "padding", ";", "slotno", "=", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "0", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "!=", "-", "1", ")", "cum", "->", "words", "+=", "padding", ";", "if", "(", "TARGET_ARCH32", ")", "{", "cum", "->", "words", "+=", "(", "mode", "!=", "BLKmode", "?", "ROUND_ADVANCE", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ":", "ROUND_ADVANCE", "(", "int_size_in_bytes", "(", "type", ")", ")", ")", ";", "}", "else", "{", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", "<=", "8", ")", "++", "cum", "->", "words", ";", "else", "if", "(", "size", "<=", "16", ")", "cum", "->", "words", "+=", "2", ";", "else", "++", "cum", "->", "words", ";", "}", "else", "{", "cum", "->", "words", "+=", "(", "mode", "!=", "BLKmode", "?", "ROUND_ADVANCE", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ":", "ROUND_ADVANCE", "(", "int_size_in_bytes", "(", "type", ")", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "sparc", "0", "1", "8", "16", "2" ]

[]

[ "<s>", "bool", "X86AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "static", "const", "uint8_t", "Nops", "[", "10", "]", "[", "10", "]", "=", "{", "{", "0x90", "}", ",", "{", "0x66", ",", "0x90", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x40", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x80", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x2e", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "}", ";", "if", "(", "CPU", "==", "\"geode\"", ")", "{", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "++", "i", ")", "OW", "->", "Write8", "(", "0x90", ")", ";", "return", "true", ";", "}", "const", "uint64_t", "OptimalCount", "=", "(", "Count", "<", "16", ")", "?", "Count", ":", "15", ";", "const", "uint64_t", "Prefixes", "=", "OptimalCount", "<=", "10", "?", "0", ":", "OptimalCount", "-", "10", ";", "for", "(", "uint64_t", "i", "=", "0", ",", "e", "=", "Prefixes", ";", "i", "!=", "e", ";", "i", "++", ")", "OW", "->", "Write8", "(", "0x66", ")", ";", "const", "uint64_t", "Rest", "=", "OptimalCount", "-", "Prefixes", ";", "for", "(", "uint64_t", "i", "=", "0", ",", "e", "=", "Rest", ";", "i", "!=", "e", ";", "i", "++", ")", "OW", "->", "Write8", "(", "Nops", "[", "Rest", "-", "1", "]", "[", "i", "]", ")", ";", "for", "(", "uint64_t", "i", "=", "OptimalCount", ",", "e", "=", "Count", ";", "i", "!=", "e", ";", "++", "i", ")", "OW", "->", "Write8", "(", "0x90", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "10", "10", "0x90", "0x66", "0x90", "0x0f", "0x1f", "0x00", "0x0f", "0x1f", "0x40", "0x00", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x0f", "0x1f", "0x80", "0x00", "0x00", "0x00", "0x00", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x2e", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "\"geode\"", "0", "0x90", "16", "15", "10", "0", "10", "0", "0x66", "0", "1", "0x90" ]

[]

[ "<s>", "PointerTypeMap", "PointerTypeAnalysis", "::", "run", "(", "const", "Module", "&", "M", ")", "{", "PointerTypeMap", "Map", ";", "for", "(", "auto", "&", "G", ":", "M", ".", "globals", "(", ")", ")", "{", "if", "(", "G", ".", "getType", "(", ")", "->", "isOpaquePointerTy", "(", ")", ")", "Map", "[", "&", "G", "]", "=", "classifyPointerType", "(", "&", "G", ")", ";", "}", "for", "(", "auto", "&", "F", ":", "M", ")", "{", "classifyFunctionType", "(", "F", ",", "Map", ")", ";", "for", "(", "const", "auto", "&", "B", ":", "F", ")", "{", "for", "(", "const", "auto", "&", "I", ":", "B", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isOpaquePointerTy", "(", ")", ")", "Map", "[", "&", "I", "]", "=", "classifyPointerType", "(", "&", "I", ")", ";", "}", "}", "}", "return", "Map", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "DirectX" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "getFnAttributes", "(", ")", ".", "hasOptimizeForSizeAttr", "(", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "||", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "EVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "bool", "SrcIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "static", "tree", "make_resolver_func", "(", "const", "tree", "default_decl", ",", "const", "tree", "dispatch_decl", ",", "basic_block", "*", "empty_bb", ")", "{", "tree", "decl_name", "=", "clone_function_name", "(", "default_decl", ",", "\"resolver\"", ")", ";", "const", "char", "*", "resolver_name", "=", "IDENTIFIER_POINTER", "(", "decl_name", ")", ";", "tree", "type", "=", "build_function_type_list", "(", "ptr_type_node", ",", "NULL_TREE", ")", ";", "tree", "decl", "=", "build_fn_decl", "(", "resolver_name", ",", "type", ")", ";", "SET_DECL_ASSEMBLER_NAME", "(", "decl", ",", "decl_name", ")", ";", "DECL_NAME", "(", "decl", ")", "=", "decl_name", ";", "TREE_USED", "(", "decl", ")", "=", "1", ";", "DECL_ARTIFICIAL", "(", "decl", ")", "=", "1", ";", "DECL_IGNORED_P", "(", "decl", ")", "=", "0", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "0", ";", "DECL_UNINLINABLE", "(", "decl", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "decl", ")", "=", "0", ";", "DECL_EXTERNAL", "(", "dispatch_decl", ")", "=", "0", ";", "DECL_CONTEXT", "(", "decl", ")", "=", "NULL_TREE", ";", "DECL_INITIAL", "(", "decl", ")", "=", "make_node", "(", "BLOCK", ")", ";", "DECL_STATIC_CONSTRUCTOR", "(", "decl", ")", "=", "0", ";", "tree", "t", "=", "build_decl", "(", "UNKNOWN_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "ptr_type_node", ")", ";", "DECL_CONTEXT", "(", "t", ")", "=", "decl", ";", "DECL_ARTIFICIAL", "(", "t", ")", "=", "1", ";", "DECL_IGNORED_P", "(", "t", ")", "=", "1", ";", "DECL_RESULT", "(", "decl", ")", "=", "t", ";", "gimplify_function_tree", "(", "decl", ")", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "decl", ")", ")", ";", "*", "empty_bb", "=", "init_lowered_empty_function", "(", "decl", ",", "false", ",", "profile_count", "::", "uninitialized", "(", ")", ")", ";", "cgraph_node", "::", "add_new_function", "(", "decl", ",", "true", ")", ";", "symtab", "->", "call_cgraph_insertion_hooks", "(", "cgraph_node", "::", "get_create", "(", "decl", ")", ")", ";", "pop_cfun", "(", ")", ";", "DECL_ATTRIBUTES", "(", "dispatch_decl", ")", "=", "make_attribute", "(", "\"ifunc\"", ",", "resolver_name", ",", "DECL_ATTRIBUTES", "(", "dispatch_decl", ")", ")", ";", "cgraph_node", "::", "create_same_body_alias", "(", "dispatch_decl", ",", "decl", ")", ";", "return", "decl", ";", "}", "</s>" ]

[ "Make", "the", "resolver", "function", "decl", "to", "dispatch", "the", "versions", "of", "a", "multi-", "versioned", "function", ",", "DEFAULT_DECL", ".", "Create", "an", "empty", "basic", "block", "in", "the", "resolver", "and", "store", "the", "pointer", "in", "EMPTY_BB", ".", "Return", "the", "decl", "of", "the", "resolver", "function", "." ]

[ "rs6000", "\"resolver\"", "1", "1", "0", "0", "1", "0", "0", "0", "1", "1", "\"ifunc\"" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", ".", "estimateStackSize", "(", "MF", ")", ":", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", ".", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "1", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "0", ")", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", "&&", "!", "MustSaveLR", "(", "MF", ",", "LR", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "UpdateMF", ")", "MFI", ".", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getLinkageSize", "(", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", ".", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "HexagonTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "Runtime", "=", "UP", ".", "Partial", "=", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "MCInst", "ARMInstrInfo", "::", "getNop", "(", ")", "const", "{", "MCInst", "NopInst", ";", "if", "(", "hasNOP", "(", ")", ")", "{", "NopInst", ".", "setOpcode", "(", "ARM", "::", "HINT", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "ARMCC", "::", "AL", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "0", ")", ")", ";", "}", "else", "{", "NopInst", ".", "setOpcode", "(", "ARM", "::", "MOVr", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "ARM", "::", "R0", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "ARM", "::", "R0", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "ARMCC", "::", "AL", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "0", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "0", ")", ")", ";", "}", "return", "NopInst", ";", "}", "</s>" ]

[ "Return", "the", "noop", "instruction", "to", "use", "for", "a", "noop", "." ]

[ "ARM", "ARM", "ARM::HINT", "0", "ARMCC::AL", "0", "ARM::MOVr", "ARM::R0", "ARM::R0", "ARMCC::AL", "0", "0" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_PPC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::InputArg", "16", "PPC", "0", "\"Can only return in registers!\"", "1", "2", "\"Unknown loc info!\"", "ISD::TRUNCATE", "ISD::AssertZext", "ISD::TRUNCATE", "ISD::AssertSext", "ISD::TRUNCATE" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isSimple", "(", ")", "||", "!", "VT2", ".", "isSimple", "(", ")", ")", "return", "false", ";", "return", "VT1", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "i64", "&&", "VT2", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

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

[]

[ "<s>", "Register", "OutgoingValueHandler", "::", "getStackAddress", "(", "const", "CCValAssign", "&", "VA", ",", "MachineMemOperand", "*", "&", "MMO", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ";", "LLT", "s32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "Register", "SPReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "SPReg", ",", "Register", "(", "Mips", "::", "SP", ")", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "s32", ")", ";", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "OffsetReg", ",", "Offset", ")", ";", "Register", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildGEP", "(", "AddrReg", ",", "SPReg", ",", "OffsetReg", ")", ";", "MachinePointerInfo", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Offset", ")", ";", "unsigned", "Size", "=", "alignTo", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ",", "8", ")", "/", "8", ";", "unsigned", "Align", "=", "MinAlign", "(", "TFL", "->", "getStackAlignment", "(", ")", ",", "Offset", ")", ";", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "Mips", "0", "32", "32", "Mips::SP", "8", "8" ]

[]