Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Mips" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "Nios2AsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createNios2ELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "Nios2" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ",", "bool", "&", "UseOneConstNR", ",", "bool", "Reciprocal", ")", "const", "{", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasFRSQRTES", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "f64", "&&", "Subtarget", ".", "hasFRSQRTE", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasAltivec", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v2f64", "&&", "Subtarget", ".", "hasVSX", "(", ")", ")", ")", "{", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "getEstimateRefinementSteps", "(", "VT", ",", "Subtarget", ")", ";", "UseOneConstNR", "=", "!", "Subtarget", ".", "needsTwoConstNR", "(", ")", ";", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "FRSQRTE", ",", "SDLoc", "(", "Operand", ")", ",", "VT", ",", "Operand", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "PowerPC", "PPC", "MVT::f32", "MVT::f64", "MVT::v4f32", "MVT::v2f64", "PPCISD::FRSQRTE" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBoolRetToIntPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createPPCLowerMASSVEntriesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnablePPCGenScalarMASSEntries", ")", "{", "TM", "->", "Options", ".", "PPCGenScalarMASSEntries", "=", "EnablePPCGenScalarMASSEntries", ";", "addPass", "(", "createPPCGenScalarMASSEntriesPass", "(", ")", ")", ";", "}", "if", "(", "EnablePrefetch", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 FP Stackifier\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 FP Stackifier\"" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "LM32" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isCandidateToMergeOrPair", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "\"Expected a reg or frame index operand.\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "{", "unsigned", "BaseReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "BaseReg", ",", "TRI", ")", ")", "return", "false", ";", "}", "if", "(", "isLdStPairSuppressed", "(", "MI", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "isPaired128Slow", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "STRQui", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "load/store", "that", "can", "be", "potentially", "paired/merged", "." ]

[ "AArch64", "AArch64", "1", "1", "\"Expected a reg or frame index operand.\"", "2", "1", "1", "AArch64::LDURQi", "AArch64::STURQi", "AArch64::LDRQui", "AArch64::STRQui" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "default", ":", "break", ";", "}", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"MachineFunction required\"" ]

[]

[ "<s>", "SDValue", "MergeValues", "(", "ArrayRef", "<", "SDValue", ">", "Values", ")", "{", "return", "DAG", "->", "getMergeValues", "(", "Values", ",", "dl", ")", ";", "}", "</s>" ]

[ "MergeValues", "-", "Compute", "and", "return", "the", "merge", "of", "the", "two", "specified", "lattice", "values", "." ]

[ "X86" ]

[]

[ "<s>", "static", "bool", "alpha_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "(", "code", "==", "'/'", "||", "code", "==", "','", "||", "code", "==", "'-'", "||", "code", "==", "'~'", "||", "code", "==", "'#'", "||", "code", "==", "'*'", "||", "code", "==", "'&'", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_PUNCT_VALID_P", "." ]

[ "alpha" ]

[]

[ "<s>", "void", "TMS320C64XHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"--emit\\n\"", ")", ";", "if", "(", "isPseudo", "(", "SU", ")", ")", "return", ";", "if", "(", "emitMove", "(", "SU", ")", ")", "return", ";", "Hzd", "->", "book", "(", "getUnitIndex", "(", "SU", ")", ",", "getExtraUse", "(", "SU", ")", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "\"--emit\\n\"" ]

[]

[ "<s>", "static", "void", "canonicalize_path_dirsep", "(", "char", "*", "*", "path", ")", "{", "char", "*", "t_path", "=", "*", "path", ";", "int", "len", "=", "strlen", "(", "t_path", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "if", "(", "IS_DIR_SEPARATOR", "(", "t_path", "[", "i", "]", ")", ")", "t_path", "[", "i", "]", "=", "DIR_SEPARATOR", ";", "}", "</s>" ]

[ "This", "is", "to", "canonicalize", "the", "directory", "separators", "in", "the", "path", ".", "On", "Windows", "we", "could", "have", "a", "mix", "of", "'/", "'", "and", "'\\", "'", "in", "the", "path", "." ]

[ "msp430", "0" ]

[]

[ "<s>", "static", "bool", "ix86_const_not_ok_for_debug_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "!=", "UNSPEC_GOTOFF", ")", "return", "true", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "&&", "strcmp", "(", "XSTR", "(", "x", ",", "0", ")", ",", "GOT_SYMBOL_NAME", ")", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "should", "n't", "be", "emitted", "into", "the", "debug", "info", ".", "Disallow", "UNSPECs", "other", "than", "@", "gotoff", "-", "we", "ca", "n't", "emit", "_GLOBAL_OFFSET_TABLE_", "symbol", "easily", "into", "the", ".debug_info", "section", ",", "so", "we", "need", "not", "to", "delegitimize", ",", "but", "instead", "assemble", "as", "@", "gotoff", ".", "Disallow", "_GLOBAL_OFFSET_TABLE_", "SYMBOL_REF", "-", "the", "assembler", "magically", "assembles", "that", "as", "_GLOBAL_OFFSET_TABLE_-", ".", "expression", "." ]

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

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "if", "(", "!", "isInt", "<", "11", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlignment", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "11" ]

[]

[ "<s>", "static", "void", "rs6000_destroy_cost_data", "(", "void", "*", "data", ")", "{", "free", "(", "data", ")", ";", "}", "</s>" ]

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

[ "powerpcspe" ]

[]

[ "<s>", "void", "MOSInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "{", "std", "::", "string", "AiryOperands", ";", "raw_string_ostream", "AiryOperandStream", "(", "AiryOperands", ")", ";", "auto", "MnemonicInfo", "=", "getMnemonic", "(", "MI", ")", ";", "assert", "(", "MnemonicInfo", ".", "second", "&&", "\"Missing opcode for instruction.\"", ")", ";", "printInstruction", "(", "MI", ",", "Address", ",", "AiryOperandStream", ")", ";", "AiryOperands", "=", "AiryOperandStream", ".", "str", "(", ")", ";", "size_t", "SpacesSeen", "=", "0", ";", "std", "::", "string", "CorrectOperands", ";", "for", "(", "const", "auto", "&", "Letter", ":", "AiryOperands", ")", "{", "if", "(", "isspace", "(", "Letter", ")", "!=", "0", ")", "{", "if", "(", "++", "SpacesSeen", "<=", "2", ")", "{", "CorrectOperands", "+=", "'\\t'", ";", "}", "continue", ";", "}", "CorrectOperands", "+=", "Letter", ";", "}", "OS", "<<", "CorrectOperands", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "MOS", "MOS", "\"Missing opcode for instruction.\"", "0", "0", "2" ]

[]

[ "<s>", "SPScope", "::", "child_iterator", "SPScope", "::", "child_begin", "(", ")", "const", "{", "return", "Priv", "->", "Subscopes", ".", "begin", "(", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "DecodeStatus", "LoongArchDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "4", "0", "support::endian", "4" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "Patmos" ]

[]

[ "<s>", "bool", "HexagonStoreWidening", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFn", ")", "{", "MF", "=", "&", "MFn", ";", "auto", "&", "ST", "=", "MFn", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MFn", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "B", ":", "MFn", ")", "Changed", "|=", "processBasicBlock", "(", "B", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "LoadInst", "*", "X86TargetLowering", "::", "lowerIdempotentRMWIntoFencedLoad", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "NativeWidth", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "return", "nullptr", ";", "auto", "Builder", "=", "IRBuilder", "<", ">", "(", "AI", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "SynchScope", "=", "AI", "->", "getSynchScope", "(", ")", ";", "auto", "Order", "=", "AtomicCmpXchgInst", "::", "getStrongestFailureOrdering", "(", "AI", "->", "getOrdering", "(", ")", ")", ";", "auto", "Ptr", "=", "AI", "->", "getPointerOperand", "(", ")", ";", "if", "(", "SynchScope", "==", "SingleThread", ")", "return", "nullptr", ";", "if", "(", "!", "hasMFENCE", "(", "*", "Subtarget", ")", ")", "return", "nullptr", ";", "Function", "*", "MFence", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "x86_sse2_mfence", ")", ";", "Builder", ".", "CreateCall", "(", "MFence", ",", "{", "}", ")", ";", "LoadInst", "*", "Loaded", "=", "Builder", ".", "CreateAlignedLoad", "(", "Ptr", ",", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ")", ";", "Loaded", "->", "setAtomic", "(", "Order", ",", "SynchScope", ")", ";", "AI", "->", "replaceAllUsesWith", "(", "Loaded", ")", ";", "AI", "->", "eraseFromParent", "(", ")", ";", "return", "Loaded", ";", "}", "</s>" ]

[ "On", "some", "platforms", ",", "an", "AtomicRMW", "that", "never", "actually", "modifies", "the", "value", "(", "such", "as", "fetch_add", "of", "0", ")", "can", "be", "turned", "into", "a", "fence", "followed", "by", "an", "atomic", "load", "." ]

[ "X86", "X86", "64", "32", "Intrinsic::getDeclaration", "Intrinsic::x86_sse2_mfence" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TM", ".", "getSubtargetImpl", "(", ")", "->", "postRAScheduler", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "switch", "(", "Subtarget", ".", "getDarwinDirective", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "case", "PPC", "::", "DIR_PWR8", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "0", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "J", "=", "(", "*", "I", ")", "->", "begin", "(", ")", ",", "JE", "=", "(", "*", "I", ")", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "{", "LoopSize", "+=", "TII", "->", "GetInstSizeInBytes", "(", "J", ")", ";", "if", "(", "LoopSize", ">", "32", ")", "break", ";", "}", "if", "(", "LoopSize", ">", "16", "&&", "LoopSize", "<=", "32", ")", "return", "5", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "PowerPC", "PPC", "PPC::DIR_970", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC", "0", "32", "16", "32", "5" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "1", ">", "Accesses", ";", "if", "(", "MI", ".", "mayStore", "(", ")", "&&", "hasStoreToStackSlot", "(", "MI", ",", "Accesses", ")", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "void", "x86_order_regs_for_local_alloc", "(", "void", ")", "{", "int", "pos", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "i", ")", "&&", "call_used_regs", "[", "i", "]", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "i", ")", "&&", "!", "call_used_regs", "[", "i", "]", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "if", "(", "!", "TARGET_SSE_MATH", ")", "for", "(", "i", "=", "FIRST_STACK_REG", ";", "i", "<=", "LAST_STACK_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_SSE_REG", ";", "i", "<=", "LAST_SSE_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_REX_SSE_REG", ";", "i", "<=", "LAST_REX_SSE_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "if", "(", "TARGET_SSE_MATH", ")", "for", "(", "i", "=", "FIRST_STACK_REG", ";", "i", "<=", "LAST_STACK_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "for", "(", "i", "=", "FIRST_MMX_REG", ";", "i", "<=", "LAST_MMX_REG", ";", "i", "++", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "i", ";", "while", "(", "pos", "<", "FIRST_PSEUDO_REGISTER", ")", "reg_alloc_order", "[", "pos", "++", "]", "=", "0", ";", "}", "</s>" ]

[ "Order", "the", "registers", "for", "register", "allocator", "." ]

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

[]

[ "<s>", "static", "rtx_insn", "*", "get_next_important_insn", "(", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "tail", ")", "{", "for", "(", ";", "insn", "&&", "insn", "!=", "tail", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "important_for_bundling_p", "(", "insn", ")", ")", "return", "insn", ";", "return", "NULL", ";", "}", "</s>" ]

[ "The", "following", "function", "returns", "an", "insn", "important", "for", "insn", "bundling", "followed", "by", "INSN", "and", "before", "TAIL", "." ]

[ "ia64" ]

[]

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

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

[ "TL45", "TL45" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "PTXPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createPTXISelDag", "(", "getPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX", "PTX" ]

[]

[ "<s>", "bool", "mips_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "==", "8", "&&", "GET_MODE_SIZE", "(", "to", ")", "==", "8", "&&", "INTEGRAL_MODE_P", "(", "from", ")", "&&", "INTEGRAL_MODE_P", "(", "to", ")", ")", "return", "false", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "from", ")", "&&", "MSA_SUPPORTED_MODE_P", "(", "to", ")", ")", "return", "false", ";", "return", "reg_classes_intersect_p", "(", "FP_REGS", ",", "rclass", ")", ";", "}", "</s>" ]

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

[ "mips", "8", "8" ]

[]

[ "<s>", "void", "mips_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "if", "(", "TARGET_EMBEDDED_DATA", "&&", "TARGET_UNINIT_CONST_IN_RODATA", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "decl", ")", "&&", "(", "DECL_INITIAL", "(", "decl", ")", "==", "0", "||", "DECL_INITIAL", "(", "decl", ")", "==", "error_mark_node", ")", ")", "{", "if", "(", "TREE_PUBLIC", "(", "decl", ")", "&&", "DECL_NAME", "(", "decl", ")", ")", "targetm", ".", "asm_out", ".", "globalize_label", "(", "stream", ",", "name", ")", ";", "switch_to_section", "(", "readonly_data_section", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "mips_declare_object", "(", "stream", ",", "name", ",", "\"\"", ",", "\":\\n\\t.space\\t\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\"\\n\"", ",", "size", ")", ";", "}", "else", "mips_declare_common_object", "(", "stream", ",", "name", ",", "\"\\n\\t.comm\\t\"", ",", "size", ",", "align", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_ALIGNED_DECL_COMMON", ".", "This", "is", "usually", "the", "same", "as", "the", "elfos.h", "version", ",", "but", "we", "also", "need", "to", "handle", "-muninit-const-in-rodata", "." ]

[ "mips", "0", "\"\"", "\":\\n\\t.space\\t\"", "\"\\n\"", "\"\\n\\t.comm\\t\"" ]

[]

[ "<s>", "static", "int", "mips_set_reg_reg_cost", "(", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_CC", ":", "return", "mips_set_reg_reg_piece_cost", "(", "mode", ",", "GET_MODE_SIZE", "(", "CCmode", ")", ")", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "case", "MODE_VECTOR_FLOAT", ":", "if", "(", "TARGET_HARD_FLOAT", ")", "return", "mips_set_reg_reg_piece_cost", "(", "mode", ",", "UNITS_PER_HWFPVALUE", ")", ";", "default", ":", "return", "mips_set_reg_reg_piece_cost", "(", "mode", ",", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "between", "two", "registers", "of", "mode", "MODE", "." ]

[ "mips" ]

[]

[ "<s>", "void", "SystemZXPLINKFrameLowering", "::", "inlineStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "PrologMBB", ")", "const", "{", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineInstr", "*", "StackAllocMI", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "PrologMBB", ")", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SystemZ", "::", "XPLINK_STACKALLOC", ")", "{", "StackAllocMI", "=", "&", "MI", ";", "break", ";", "}", "if", "(", "StackAllocMI", "==", "nullptr", ")", "return", ";", "MachineBasicBlock", "&", "MBB", "=", "PrologMBB", ";", "const", "DebugLoc", "DL", "=", "StackAllocMI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "*", "NextMBB", ";", "MachineBasicBlock", "*", "StackExtMBB", "=", "MF", ".", "CreateMachineBasicBlock", "(", "MBB", ".", "getBasicBlock", "(", ")", ")", ";", "MF", ".", "push_back", "(", "StackExtMBB", ")", ";", "BuildMI", "(", "StackExtMBB", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "LG", ")", ",", "SystemZ", "::", "R3D", ")", ".", "addReg", "(", "SystemZ", "::", "R3D", ")", ".", "addImm", "(", "72", ")", ".", "addReg", "(", "0", ")", ";", "BuildMI", "(", "StackExtMBB", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "CallBASR_STACKEXT", ")", ")", ".", "addReg", "(", "SystemZ", "::", "R3D", ")", ";", "BuildMI", "(", "MBB", ",", "StackAllocMI", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "LLGT", ")", ",", "SystemZ", "::", "R3D", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "1208", ")", ".", "addReg", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "StackAllocMI", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "CG", ")", ")", ".", "addReg", "(", "SystemZ", "::", "R4D", ")", ".", "addReg", "(", "SystemZ", "::", "R3D", ")", ".", "addImm", "(", "64", ")", ".", "addReg", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "StackAllocMI", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "BRC", ")", ")", ".", "addImm", "(", "SystemZ", "::", "CCMASK_ICMP", ")", ".", "addImm", "(", "SystemZ", "::", "CCMASK_CMP_LT", ")", ".", "addMBB", "(", "StackExtMBB", ")", ";", "NextMBB", "=", "SystemZ", "::", "splitBlockBefore", "(", "StackAllocMI", ",", "&", "MBB", ")", ";", "MBB", ".", "addSuccessor", "(", "NextMBB", ")", ";", "MBB", ".", "addSuccessor", "(", "StackExtMBB", ")", ";", "BuildMI", "(", "StackExtMBB", ",", "DL", ",", "ZII", "->", "get", "(", "SystemZ", "::", "J", ")", ")", ".", "addMBB", "(", "NextMBB", ")", ";", "StackExtMBB", "->", "addSuccessor", "(", "NextMBB", ")", ";", "StackAllocMI", "->", "eraseFromParent", "(", ")", ";", "recomputeLiveIns", "(", "*", "NextMBB", ")", ";", "recomputeLiveIns", "(", "*", "StackExtMBB", ")", ";", "}", "</s>" ]

[ "Replace", "a", "StackProbe", "inline-stub", "with", "the", "actual", "probe", "code", "inline", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ::XPLINK_STACKALLOC", "SystemZ::LG", "SystemZ::R3D", "SystemZ::R3D", "72", "0", "SystemZ::CallBASR_STACKEXT", "SystemZ::R3D", "SystemZ::LLGT", "SystemZ::R3D", "0", "1208", "0", "SystemZ::CG", "SystemZ::R4D", "SystemZ::R3D", "64", "0", "SystemZ::BRC", "SystemZ::CCMASK_ICMP", "SystemZ::CCMASK_CMP_LT", "SystemZ::splitBlockBefore", "SystemZ::J" ]

[]

[ "<s>", "static", "bool", "rs6000_real_tls_symbol_ref_p", "(", "rtx", "x", ")", "{", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ">=", "TLS_MODEL_REAL", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "symbol", "that", "refers", "to", "real", "(", "rather", "than", "emulated", ")", "TLS", "." ]

[ "rs6000" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "else", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "GetGBRO", ")", ",", "TempReg", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "PowerPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC", "PPC::GPRCRegClass", "PPC::GetGBRO", "PPC::UpdateGBR", "PPC", "PPC::G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isPTestLikeOpcode", "(", "unsigned", "Opc", ")", "const", "{", "return", "get", "(", "Opc", ")", ".", "TSFlags", "&", "AArch64", "::", "InstrFlagIsPTestLike", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "opcode", "is", "for", "an", "SVE", "instruction", "that", "sets", "the", "condition", "codes", "as", "if", "it", "'s", "results", "had", "been", "fed", "to", "a", "PTEST", "instruction", "along", "with", "the", "same", "general", "predicate", "." ]

[ "AArch64", "AArch64", "AArch64::InstrFlagIsPTestLike" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SP", "::", "RETL", "&&", "\"Can only put epilog before 'retl' instruction!\"", ")", ";", "if", "(", "!", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "RESTORErr", ")", ",", "SP", "::", "G0", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ";", "return", ";", "}", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "NumBytes", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SP", "::", "ADDrr", ",", "SP", "::", "ADDri", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::RETL", "\"Can only put epilog before 'retl' instruction!\"", "SP::RESTORErr", "SP::G0", "SP::G0", "SP::G0", "0", "Sparc", "SP", "SP::ADDrr", "SP::ADDri" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "const", "TargetMachine", "&", "TM", "=", "AP", ".", "TM", ";", "Mangler", "*", "Mang", "=", "AP", ".", "Mang", ";", "const", "DataLayout", "&", "DL", "=", "AP", ".", "getDataLayout", "(", ")", ";", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "bool", "isDarwin", "=", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSDarwin", "(", ")", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", ")", "{", "if", "(", "isDarwin", ")", "Suffix", "=", "\"$stub\"", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "*", "Mang", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", "&&", "isDarwin", ")", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "getOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "PPCII::MO_PLT_OR_STUB", "\"$stub\"", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "\"Isn't a symbol reference\"", "PPCII::MO_PLT_OR_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_NLP_HIDDEN_FLAG", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "AArch64", "::", "RET_ReallyLR", ")", ";", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "bool", "Success", "=", "true", ";", "if", "(", "VReg", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "MRI", ".", "getType", "(", "VReg", ")", ".", "getSizeInBits", "(", ")", "==", "1", ")", "VReg", "=", "MIRBuilder", ".", "buildZExt", "(", "LLT", "::", "scalar", "(", "8", ")", ",", "VReg", ")", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "F", ".", "getCallingConv", "(", ")", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "ArgInfo", "OrigArg", "{", "VReg", ",", "Val", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "F", ".", "getCallingConv", "(", ")", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "MIRBuilder", ".", "buildExtract", "(", "Reg", ",", "VReg", ",", "Offset", ")", ";", "}", ")", ";", "OutgoingArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "AssignFn", ",", "AssignFn", ")", ";", "Success", "=", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "Success", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::RET_ReallyLR", "\"Return value without a vreg\"", "1", "8", "0", "AArch64", "AArch64", "8" ]

[]

[ "<s>", "static", "int", "getMemScale", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "getMemScale", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

[ "Scaling", "factor", "for", "(", "scaled", "or", "unscaled", ")", "load", "or", "store", "." ]

[ "AArch64" ]

[]

[ "<s>", "BitVector", "Cpu0RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "Cpu0", "::", "ZERO", ",", "Cpu0", "::", "AT", ",", "Cpu0", "::", "SP", ",", "Cpu0", "::", "LR", ",", "Cpu0", "::", "PC", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "Cpu0", "::", "FP", ")", ";", "}", "const", "Cpu0FunctionInfo", "*", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0FunctionInfo", ">", "(", ")", ";", "if", "(", "Cpu0FI", "->", "globalBaseRegFixed", "(", ")", ")", "Reserved", ".", "set", "(", "Cpu0", "::", "GP", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "Cpu0", "Cpu0", "Cpu0::ZERO", "Cpu0::AT", "Cpu0::SP", "Cpu0::LR", "Cpu0::PC", "0", "Cpu0::FP", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0::GP" ]

[]

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

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

[ "s390", "1" ]

[]

[ "<s>", "tree", "memory_scalar_type", "(", "const", "function_instance", "&", "fi", ")", "const", "override", "{", "return", "fi", ".", "scalar_type", "(", "0", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "addresses", "memory", ",", "return", "the", "type", "of", "a", "single", "scalar", "memory", "element", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "getMCOpcodeFromPseudo", "(", "Opc", ")", ";", "unsigned", "DescSize", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "isFixedSize", "(", "MI", ")", ")", "{", "unsigned", "Size", "=", "DescSize", ";", "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "ST", ".", "hasOffset3fBug", "(", ")", ")", "Size", "+=", "4", ";", "return", "Size", ";", "}", "if", "(", "isVALU", "(", "MI", ")", "||", "isSALU", "(", "MI", ")", ")", "{", "if", "(", "isDPP", "(", "MI", ")", ")", "return", "DescSize", ";", "bool", "HasLiteral", "=", "false", ";", "for", "(", "int", "I", "=", "0", ",", "E", "=", "MI", ".", "getNumExplicitOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "isLiteralConstant", "(", "MI", ",", "I", ")", ")", "{", "HasLiteral", "=", "true", ";", "break", ";", "}", "}", "return", "HasLiteral", "?", "DescSize", "+", "4", ":", "DescSize", ";", "}", "if", "(", "isMIMG", "(", "MI", ")", ")", "{", "int", "VAddr0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "vaddr0", ")", ";", "if", "(", "VAddr0Idx", "<", "0", ")", "return", "8", ";", "int", "RSrcIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "srsrc", ")", ";", "return", "8", "+", "4", "*", "(", "(", "RSrcIdx", "-", "VAddr0Idx", "+", "2", ")", "/", "4", ")", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleSize", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ",", "&", "ST", ")", ";", "}", "default", ":", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "return", "DescSize", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AMDGPU", "SI", "4", "0", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "8", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "8", "4", "2", "4", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "M88kMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MI", "->", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "I", ")", ";", "if", "(", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isImplicit", "(", ")", ")", "&&", "!", "MO", ".", "isRegMask", "(", ")", ")", "OutMI", ".", "addOperand", "(", "lowerOperand", "(", "MO", ")", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "M88k", "M88k", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "gen_prefix", "(", "tree", "decl", ")", "{", "if", "(", "DECL_ONE_ONLY", "(", "decl", ")", ")", "return", "NULL", ";", "if", "(", "has_attr", "(", "\"section\"", ",", "decl", ")", ")", "return", "NULL", ";", "if", "(", "has_section_name", "(", "\".lowtext\"", ",", "decl", ")", ")", "return", "NULL", ";", "if", "(", "!", "TARGET_LARGE", ")", "return", "NULL", ";", "if", "(", "has_attr", "(", "ATTR_LOWER", ",", "decl", ")", ")", "return", "lower_prefix", ";", "if", "(", "has_attr", "(", "ATTR_UPPER", ",", "decl", ")", ")", "return", "upper_prefix", ";", "if", "(", "has_attr", "(", "ATTR_EITHER", ",", "decl", ")", ")", "return", "either_prefix", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "if", "(", "(", "msp430_code_region", "==", "MSP430_REGION_LOWER", ")", "&&", "TARGET_USE_LOWER_REGION_PREFIX", ")", "return", "lower_prefix", ";", "if", "(", "msp430_code_region", "==", "MSP430_REGION_UPPER", ")", "return", "upper_prefix", ";", "if", "(", "msp430_code_region", "==", "MSP430_REGION_EITHER", ")", "return", "either_prefix", ";", "}", "else", "{", "if", "(", "(", "msp430_data_region", "==", "MSP430_REGION_LOWER", ")", "&&", "TARGET_USE_LOWER_REGION_PREFIX", ")", "return", "lower_prefix", ";", "if", "(", "msp430_data_region", "==", "MSP430_REGION_UPPER", ")", "return", "upper_prefix", ";", "if", "(", "msp430_data_region", "==", "MSP430_REGION_EITHER", ")", "return", "either_prefix", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Generate", "a", "prefix", "for", "a", "section", "name", ",", "based", "upon", "the", "region", "into", "which", "the", "object", "should", "be", "placed", "." ]

[ "msp430", "\"section\"", "\".lowtext\"" ]

[]

[ "<s>", "bool", "isFPImm", "(", ")", "const", "{", "return", "Kind", "==", "k_FPImm", ";", "}", "</s>" ]

[ "isFPImm", "-", "Tests", "if", "this", "is", "a", "MO_FPImmediate", "operand", "." ]

[ "ARM64" ]

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "Instruction", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "Instruction", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "Instruction", ";", "if", "(", "Instruction", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "Instruction", "->", "getOpcode", "(", ")", "!=", "Lanai", "::", "BT", "&&", "Instruction", "->", "getOpcode", "(", ")", "!=", "Lanai", "::", "BRCC", ")", "{", "break", ";", "}", "Instruction", "->", "eraseFromParent", "(", ")", ";", "Instruction", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "\"code size not handled\"", "0", "Lanai::BT", "Lanai::BRCC" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_in_loop_reduction_latency", "(", "vec_info", "*", "vinfo", ",", "stmt_vec_info", "stmt_info", ",", "tree", "vectype", ",", "unsigned", "int", "vec_flags", ")", "{", "const", "cpu_vector_cost", "*", "vec_costs", "=", "aarch64_tune_params", ".", "vec_costs", ";", "const", "sve_vec_cost", "*", "sve_costs", "=", "nullptr", ";", "if", "(", "vec_flags", "&", "VEC_ANY_SVE", ")", "sve_costs", "=", "aarch64_tune_params", ".", "vec_costs", "->", "sve", ";", "if", "(", "sve_costs", ")", "{", "unsigned", "int", "latency", "=", "aarch64_sve_in_loop_reduction_latency", "(", "vinfo", ",", "stmt_info", ",", "vectype", ",", "sve_costs", ")", ";", "if", "(", "latency", ")", "return", "latency", ";", "}", "if", "(", "vec_flags", "==", "0", ")", "{", "if", "(", "FLOAT_TYPE_P", "(", "vectype", ")", ")", "return", "vec_costs", "->", "scalar_fp_stmt_cost", ";", "return", "vec_costs", "->", "scalar_int_stmt_cost", ";", "}", "const", "simd_vec_cost", "*", "simd_costs", "=", "aarch64_simd_vec_costs_for_flags", "(", "vec_flags", ")", ";", "if", "(", "FLOAT_TYPE_P", "(", "vectype", ")", ")", "return", "simd_costs", "->", "fp_stmt_cost", ";", "return", "simd_costs", "->", "int_stmt_cost", ";", "}", "</s>" ]

[ "STMT_INFO", "describes", "a", "loop-carried", "operation", "in", "the", "original", "scalar", "code", "that", "we", "are", "considering", "implementing", "as", "a", "reduction", ".", "Return", "one", "of", "the", "following", "values", ",", "depending", "on", "VEC_FLAGS", ":", "-", "If", "VEC_FLAGS", "is", "zero", ",", "return", "the", "loop", "carry", "latency", "of", "the", "original", "scalar", "operation", ".", "-", "If", "VEC_FLAGS", "&", "VEC_ADVSIMD", ",", "return", "the", "loop", "carry", "latency", "of", "the", "the", "Advanced", "SIMD", "implementation", ".", "-", "If", "VEC_FLAGS", "&", "VEC_ANY_SVE", ",", "return", "the", "loop", "carry", "latency", "of", "the", "SVE", "implementation", ".", "VECTYPE", "is", "the", "type", "of", "vector", "that", "the", "vectorizer", "is", "considering", "using", "for", "STMT_INFO", ",", "which", "might", "be", "different", "from", "the", "type", "of", "vector", "described", "by", "VEC_FLAGS", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFMADLegal", "(", "const", "SelectionDAG", "&", "DAG", ",", "const", "SDNode", "*", "N", ")", "const", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "Subtarget", "->", "hasMadMacF32Insts", "(", ")", "&&", "!", "hasFP32Denormals", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f16", ")", "{", "return", "Subtarget", "->", "hasMadF16", "(", ")", "&&", "!", "hasFP64FP16Denormals", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "MI", "can", "be", "combined", "with", "another", "instruction", "to", "form", "TargetOpcode", ":", ":G_FMAD", "." ]

[ "AMDGPU", "SI", "0", "MVT::f32", "MVT::f16" ]

[]

[ "<s>", "rtx", "msp430_subreg", "(", "machine_mode", "mode", ",", "rtx", "r", ",", "machine_mode", "omode", ",", "int", "byte", ")", "{", "rtx", "rv", ";", "if", "(", "GET_CODE", "(", "r", ")", "==", "SUBREG", "&&", "SUBREG_BYTE", "(", "r", ")", "==", "0", ")", "{", "rtx", "ireg", "=", "SUBREG_REG", "(", "r", ")", ";", "machine_mode", "imode", "=", "GET_MODE", "(", "ireg", ")", ";", "if", "(", "imode", "==", "PSImode", "&&", "mode", "==", "HImode", "&&", "byte", "==", "0", ")", "rv", "=", "gen_rtx_SUBREG", "(", "mode", ",", "ireg", ",", "byte", ")", ";", "else", "rv", "=", "simplify_gen_subreg", "(", "mode", ",", "ireg", ",", "imode", ",", "byte", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "r", ")", "==", "MEM", ")", "rv", "=", "adjust_address", "(", "r", ",", "mode", ",", "byte", ")", ";", "else", "rv", "=", "simplify_gen_subreg", "(", "mode", ",", "r", ",", "omode", ",", "byte", ")", ";", "if", "(", "!", "rv", ")", "gcc_unreachable", "(", ")", ";", "return", "rv", ";", "}", "</s>" ]

[ "Simplify_gen_subreg", "(", ")", "does", "n't", "handle", "memory", "references", "the", "way", "we", "need", "it", "to", "below", ",", "so", "we", "use", "this", "function", "for", "when", "we", "must", "get", "a", "valid", "subreg", "in", "a", "``", "natural", "''", "state", "." ]

[ "msp430", "0", "0" ]

[]

[ "<s>", "bool", "ARCTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "ARC", "ARC" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Dummy", ";", "if", "(", "isFrameLoadOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "Dummy", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "1", ">", "Accesses", ";", "if", "(", "hasLoadFromStackSlot", "(", "MI", ",", "Accesses", ")", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "X86", "X86", "1", "1", "0" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", "||", "Size", "==", "8", ")", "&&", "\"Unsupported size\"", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "Register", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", ",", "32", ")", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "AddrReg", ",", "FI", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

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

[ "ARM", "1", "2", "4", "8", "\"Unsupported size\"", "32" ]

[]

[ "<s>", "static", "bool", "x86_can_output_mi_thunk", "(", "const_tree", ",", "HOST_WIDE_INT", ",", "HOST_WIDE_INT", "vcall_offset", ",", "const_tree", "function", ")", "{", "if", "(", "TARGET_64BIT", ")", "return", "true", ";", "if", "(", "ix86_function_regparm", "(", "TREE_TYPE", "(", "function", ")", ",", "function", ")", "<", "3", ")", "return", "true", ";", "if", "(", "vcall_offset", ")", "return", "false", ";", "if", "(", "flag_pic", "&&", "!", "targetm", ".", "binds_local_p", "(", "function", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Determine", "whether", "x86_output_mi_thunk", "can", "succeed", "." ]

[ "i386", "3" ]

[]

[ "<s>", "static", "unsigned", "int", "cris_postdbr_cmpelim", "(", ")", "{", "rtx_insn", "*", "insn", ";", "rtx_insn", "*", "next", ";", "rtx_insn", "*", "prev_cc_setter", "=", "0", ";", "rtx_insn", "*", "prev_cc_outer", "=", "0", ";", "rtx", "dccr", "=", "gen_rtx_REG", "(", "CCmode", ",", "CRIS_CC0_REGNUM", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next", ")", "{", "rtx_insn", "*", "outer_insn", "=", "insn", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "next", "=", "NEXT_INSN", "(", "outer_insn", ")", ";", "if", "(", "LABEL_P", "(", "insn", ")", ")", "{", "prev_cc_setter", "=", "0", ";", "continue", ";", "}", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SEQUENCE", ")", "insn", "=", "as_a", "<", "rtx_insn", "*", ">", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ";", "else", "if", "(", "prev_cc_setter", "!=", "0", "&&", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "prev_set", ";", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", "==", "CRIS_CC0_REGNUM", "&&", "GET_CODE", "(", "src", ")", "==", "COMPARE", "&&", "REG_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "XEXP", "(", "src", ",", "1", ")", "==", "const0_rtx", "&&", "(", "prev_set", "=", "single_set", "(", "prev_cc_setter", ")", ")", "!=", "0", ")", "{", "rtx", "reg", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "prev_dest", "=", "SET_DEST", "(", "prev_set", ")", ";", "rtx", "prev_src", "=", "SET_SRC", "(", "prev_set", ")", ";", "bool", "src_same", "=", "rtx_equal_p", "(", "prev_src", ",", "reg", ")", ";", "if", "(", "REG_P", "(", "prev_dest", ")", "&&", "!", "reg_set_p", "(", "reg", ",", "prev_src", ")", "&&", "!", "reg_set_between_p", "(", "reg", ",", "prev_cc_outer", ",", "outer_insn", ")", "&&", "(", "src_same", "||", "rtx_equal_p", "(", "prev_dest", ",", "reg", ")", ")", ")", "{", "machine_mode", "ccmode", "=", "GET_MODE", "(", "src", ")", ";", "rtx", "modeadjusted_dccr", "=", "(", "ccmode", "==", "CCmode", "?", "dccr", ":", "gen_rtx_REG", "(", "CCmode", ",", "CRIS_CC0_REGNUM", ")", ")", ";", "rtx", "compare", "=", "(", "src_same", "?", "pat", ":", "gen_rtx_SET", "(", "modeadjusted_dccr", ",", "gen_rtx_COMPARE", "(", "ccmode", ",", "copy_rtx", "(", "prev_src", ")", ",", "const0_rtx", ")", ")", ")", ";", "validate_change", "(", "prev_cc_setter", ",", "&", "XVECEXP", "(", "PATTERN", "(", "prev_cc_setter", ")", ",", "0", ",", "0", ")", ",", "compare", ",", "true", ")", ";", "validate_change", "(", "prev_cc_setter", ",", "&", "XVECEXP", "(", "PATTERN", "(", "prev_cc_setter", ")", ",", "0", ",", "1", ")", ",", "prev_set", ",", "true", ")", ";", "if", "(", "apply_change_group", "(", ")", ")", "{", "delete_insn", "(", "insn", ")", ";", "prev_cc_setter", "=", "0", ";", "continue", ";", "}", "}", "}", "}", "if", "(", "reg_set_p", "(", "dccr", ",", "insn", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "prev_cc_setter", "=", "0", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "XVECLEN", "(", "pat", ",", "0", ")", "==", "2", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ")", "==", "CLOBBER", ")", "{", "prev_cc_setter", "=", "insn", ";", "prev_cc_outer", "=", "outer_insn", ";", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "``", "Cheap", "version", "''", "of", "cmpelim", ",", "making", "use", "of", "the", "opportunities", "opened", "up", "by", "reorg", ".", "Go", "through", "the", "insns", "of", "a", "function", "and", "look", "at", "each", "actual", "compare", "insn", ";", "considering", "only", "those", "that", "compare", "a", "register", "to", "0", ".", "If", "the", "previous", "CC-affecting", "insn", "sets", "the", "compared", "register", "or", "if", "a", "move", "reads", "from", "it", ",", "try", "to", "change", "that", "into", "a", "CC-setting", "move", "and", "try", "to", "have", "it", "recognized", ".", "Bail", "at", "labels", "or", "non-matching", "insns", "that", "clobber", "the", "compared", "register", ".", "If", "successful", ",", "delete", "the", "compare", ".", "Also", ",", "reorg", "is", "n't", "up", "to", "date", "regarding", "data-flow", "handling", ",", "so", "we", "ca", "n't", "go", "beyond", "classic", "RTL", "scanning", "." ]

[ "cris", "0", "0", "0", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "2", "0", "1", "0" ]

[]

[ "<s>", "void", "arc_ccfsm_record_branch_deleted", "(", "void", ")", "{", "ARC_CCFSM_RECORD_BRANCH_DELETED", "(", "&", "arc_ccfsm_current", ")", ";", "}", "</s>" ]

[ "Record", "a", "branch", "is", "n't", "output", "because", "subsequent", "insns", "can", "be", "conditionalized", "." ]

[ "arc" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_nregs_internal", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "reg_size", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "||", "VECTOR_ALIGNMENT_P", "(", "mode", ")", "?", "UNITS_PER_VSX_WORD", ":", "UNITS_PER_FP_WORD", ")", ";", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_ALTIVEC_WORD", ";", "else", "reg_size", "=", "UNITS_PER_WORD", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "reg_size", "-", "1", ")", "/", "reg_size", ";", "}", "</s>" ]

[ "Return", "number", "of", "consecutive", "hard", "regs", "needed", "starting", "at", "reg", "REGNO", "to", "hold", "something", "of", "mode", "MODE", ".", "This", "is", "ordinarily", "the", "length", "in", "words", "of", "a", "value", "of", "mode", "MODE", "but", "can", "be", "less", "for", "certain", "modes", "in", "special", "long", "registers", ".", "POWER", "and", "PowerPC", "GPRs", "hold", "32", "bits", "worth", ";", "PowerPC64", "GPRs", "and", "FPRs", "point", "register", "holds", "64", "bits", "worth", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 vzeroupper inserter\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 vzeroupper inserter\"" ]

[]

[ "<s>", "void", "vax_notice_update_cc", "(", "rtx", "exp", ",", "rtx", "insn", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "exp", ")", "==", "SET", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "exp", ")", ")", "==", "CALL", ")", "CC_STATUS_INIT", ";", "else", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "exp", ")", ")", "!=", "ZERO_EXTRACT", "&&", "GET_CODE", "(", "SET_DEST", "(", "exp", ")", ")", "!=", "PC", ")", "{", "cc_status", ".", "flags", "=", "0", ";", "switch", "(", "GET_CODE", "(", "SET_SRC", "(", "exp", ")", ")", ")", "{", "case", "NEG", ":", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "exp", ")", ")", "==", "MODE_FLOAT", ")", "break", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "NOT", ":", "case", "MEM", ":", "case", "REG", ":", "cc_status", ".", "flags", "=", "CC_NO_OVERFLOW", ";", "break", ";", "default", ":", "break", ";", "}", "cc_status", ".", "value1", "=", "SET_DEST", "(", "exp", ")", ";", "cc_status", ".", "value2", "=", "SET_SRC", "(", "exp", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "exp", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "exp", ",", "0", ",", "0", ")", ")", "==", "SET", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "exp", ",", "0", ",", "0", ")", ")", ")", "==", "CALL", ")", "CC_STATUS_INIT", ";", "else", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "XVECEXP", "(", "exp", ",", "0", ",", "0", ")", ")", ")", "!=", "PC", ")", "{", "cc_status", ".", "flags", "=", "0", ";", "cc_status", ".", "value1", "=", "SET_DEST", "(", "XVECEXP", "(", "exp", ",", "0", ",", "0", ")", ")", ";", "cc_status", ".", "value2", "=", "SET_SRC", "(", "XVECEXP", "(", "exp", ",", "0", ",", "0", ")", ")", ";", "}", "else", "CC_STATUS_INIT", ";", "}", "else", "CC_STATUS_INIT", ";", "if", "(", "cc_status", ".", "value1", "&&", "REG_P", "(", "cc_status", ".", "value1", ")", "&&", "cc_status", ".", "value2", "&&", "reg_overlap_mentioned_p", "(", "cc_status", ".", "value1", ",", "cc_status", ".", "value2", ")", ")", "cc_status", ".", "value2", "=", "0", ";", "if", "(", "cc_status", ".", "value1", "&&", "MEM_P", "(", "cc_status", ".", "value1", ")", "&&", "cc_status", ".", "value2", "&&", "MEM_P", "(", "cc_status", ".", "value2", ")", ")", "cc_status", ".", "value2", "=", "0", ";", "}", "</s>" ]

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

[ "vax", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "nvptx_goacc_fork_join", "(", "gcall", "*", "call", ",", "const", "int", "dims", "[", "]", ",", "bool", "ARG_UNUSED", "(", "is_fork", ")", ")", "{", "tree", "arg", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "unsigned", "axis", "=", "TREE_INT_CST_LOW", "(", "arg", ")", ";", "if", "(", "axis", "<", "GOMP_DIM_WORKER", ")", "return", "false", ";", "if", "(", "dims", "[", "axis", "]", "==", "1", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Determine", "whether", "fork", "&", "joins", "are", "needed", "." ]

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

[]

[ "<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", ";", "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", ")", "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", ")", ";", "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", "0" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "<=", "UINT32_MAX", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "static_cast", "<", "uint32_t", ">", "(", "Value", ")", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", "{", "Value", "=", "(", "uint32_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "Endian", "==", "support", "::", "little", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x10", ";", "support", "::", "endian", "::", "write32le", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x1", ";", "support", "::", "endian", "::", "write32be", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", ",", "Value", ",", "Endian", ")", ";", "}", "}", "</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", "." ]

[ "BPF", "BPF", "support::endian", "4", "support::endian", "support::endian", "8", "8", "support::little", "1", "0x10", "support::endian", "4", "1", "0x1", "support::endian", "4", "8", "8", "support::endian", "2" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "READ_REGISTER", ":", "ExpandREAD_REGISTER", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "Res", "=", "LowerREM", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::SREM", "ISD::UREM", "ISD::READCYCLECOUNTER" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "return", "FramePtr", ";", "return", "ARM", "::", "SP", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::SP" ]

[]

[ "<s>", "static", "unsigned", "int", "riscv_dwarf_poly_indeterminate_value", "(", "unsigned", "int", "i", ",", "unsigned", "int", "*", "factor", ",", "int", "*", "offset", ")", "{", "gcc_assert", "(", "i", "==", "1", ")", ";", "*", "factor", "=", "riscv_bytes_per_vector_chunk", ";", "*", "offset", "=", "1", ";", "return", "RISCV_DWARF_VLENB", ";", "}", "</s>" ]

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

[ "riscv", "1", "1" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "Size", ",", "unsigned", "Align", ")", "const", "{", "MachineFunction", "&", "MF", "=", "State", "->", "getMachineFunction", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "assert", "(", "Size", "&&", "\"Byval argument's size shouldn't be 0.\"", ")", ";", "Align", "=", "std", "::", "min", "(", "Align", ",", "TFL", "->", "getStackAlignment", "(", ")", ")", ";", "unsigned", "FirstReg", "=", "0", ";", "unsigned", "NumRegs", "=", "0", ";", "if", "(", "State", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "Fast", ")", "{", "unsigned", "RegSizeInBytes", "=", "Subtarget", ".", "getGPRSizeInBytes", "(", ")", ";", "const", "ArrayRef", "<", "MCPhysReg", ">", "IntArgRegs", "=", "Subtarget", ".", "getABI", "(", ")", ".", "GetByValArgRegs", "(", ")", ";", "const", "MCPhysReg", "*", "ShadowRegs", "=", "Subtarget", ".", "isABI_O32", "(", ")", "?", "IntArgRegs", ".", "data", "(", ")", ":", "Mips64DPRegs", ";", "assert", "(", "!", "(", "Align", "%", "RegSizeInBytes", ")", "&&", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", ")", ";", "FirstReg", "=", "State", "->", "getFirstUnallocated", "(", "IntArgRegs", ".", "data", "(", ")", ",", "IntArgRegs", ".", "size", "(", ")", ")", ";", "if", "(", "(", "Align", ">", "RegSizeInBytes", ")", "&&", "(", "FirstReg", "%", "2", ")", ")", "{", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "FirstReg", "]", ",", "ShadowRegs", "[", "FirstReg", "]", ")", ";", "++", "FirstReg", ";", "}", "Size", "=", "RoundUpToAlignment", "(", "Size", ",", "RegSizeInBytes", ")", ";", "for", "(", "unsigned", "I", "=", "FirstReg", ";", "Size", ">", "0", "&&", "(", "I", "<", "IntArgRegs", ".", "size", "(", ")", ")", ";", "Size", "-=", "RegSizeInBytes", ",", "++", "I", ",", "++", "NumRegs", ")", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "I", "]", ",", "ShadowRegs", "[", "I", "]", ")", ";", "}", "State", "->", "addInRegsParamInfo", "(", "FirstReg", ",", "FirstReg", "+", "NumRegs", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "Mips", "Mips", "\"Byval argument's size shouldn't be 0.\"", "0", "0", "Mips", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", "2", "0" ]

[]

[ "<s>", "static", "void", "core2i7_first_cycle_multipass_fini", "(", "void", "*", "_data", ")", "{", "ix86_first_cycle_multipass_data_t", "data", "=", "(", "ix86_first_cycle_multipass_data_t", ")", "_data", ";", "if", "(", "data", "->", "ready_try_change", ")", "{", "sbitmap_free", "(", "data", "->", "ready_try_change", ")", ";", "data", "->", "ready_try_change", "=", "NULL", ";", "data", "->", "ready_try_change_size", "=", "0", ";", "}", "}", "</s>" ]

[ "Deallocate", "target", "data", "." ]

[ "i386", "0" ]

[]

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

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

[ "PowerPC" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "void", "DCPU16FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "1", ",", "-", "1", ",", "true", ")", ";", "(", "void", ")", "FrameIdx", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectIndexBegin", "(", ")", "&&", "\"Slot for J register must be last in order to be found!\"", ")", ";", "}", "}", "</s>" ]

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

[ "Dcpu16", "DCPU16", "1", "1", "\"Slot for J register must be last in order to be found!\"" ]

[]

[ "<s>", "SDValue", "LanaiTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCCE", ":", "return", "LowerSETCCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "Lanai", "Lanai", "ISD::MUL", "ISD::BR_CC", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::SETCC", "ISD::SETCCE", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC", "ISD::RETURNADDR", "ISD::FRAMEADDR", "\"unimplemented operand\"" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_call_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "call_op", ")", "{", "bool", "direct_p", "=", "constant_call_address_operand", "(", "call_op", ",", "VOIDmode", ")", ";", "bool", "seh_nop_p", "=", "false", ";", "const", "char", "*", "xasm", ";", "if", "(", "SIBLING_CALL_P", "(", "insn", ")", ")", "{", "if", "(", "direct_p", ")", "xasm", "=", "\"%!jmp\\t%P0\"", ";", "else", "if", "(", "TARGET_SEH", ")", "xasm", "=", "\"%!rex.W jmp %A0\"", ";", "else", "xasm", "=", "\"%!jmp\\t%A0\"", ";", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "return", "\"\"", ";", "}", "if", "(", "TARGET_SEH", ")", "{", "rtx_insn", "*", "i", ";", "for", "(", "i", "=", "NEXT_INSN", "(", "insn", ")", ";", "i", ";", "i", "=", "NEXT_INSN", "(", "i", ")", ")", "{", "if", "(", "INSN_P", "(", "i", ")", ")", "break", ";", "if", "(", "NOTE_P", "(", "i", ")", "&&", "NOTE_KIND", "(", "i", ")", "==", "NOTE_INSN_EPILOGUE_BEG", "&&", "!", "flag_non_call_exceptions", "&&", "!", "can_throw_internal", "(", "insn", ")", ")", "{", "seh_nop_p", "=", "true", ";", "break", ";", "}", "}", "if", "(", "i", "==", "NULL", ")", "seh_nop_p", "=", "true", ";", "}", "if", "(", "direct_p", ")", "xasm", "=", "\"%!call\\t%P0\"", ";", "else", "xasm", "=", "\"%!call\\t%A0\"", ";", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "if", "(", "seh_nop_p", ")", "return", "\"nop\"", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "for", "a", "call", "instruction", "." ]

[ "i386", "\"%!jmp\\t%P0\"", "\"%!rex.W jmp %A0\"", "\"%!jmp\\t%A0\"", "\"\"", "\"%!call\\t%P0\"", "\"%!call\\t%A0\"", "\"nop\"", "\"\"" ]

[]

[ "<s>", "static", "void", "arm_output_function_prologue", "(", "FILE", "*", "f", ",", "HOST_WIDE_INT", "frame_size", ")", "{", "unsigned", "long", "func_type", ";", "if", "(", "!", "TARGET_ARM", ")", "{", "thumb_output_function_prologue", "(", "f", ",", "frame_size", ")", ";", "return", ";", "}", "gcc_assert", "(", "!", "arm_ccfsm_state", "&&", "!", "arm_target_insn", ")", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "switch", "(", "(", "int", ")", "ARM_FUNC_TYPE", "(", "func_type", ")", ")", "{", "default", ":", "case", "ARM_FT_NORMAL", ":", "break", ";", "case", "ARM_FT_INTERWORKED", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ Function supports interworking.\\n\"", ")", ";", "break", ";", "case", "ARM_FT_ISR", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ Interrupt Service Routine.\\n\"", ")", ";", "break", ";", "case", "ARM_FT_FIQ", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ Fast Interrupt Service Routine.\\n\"", ")", ";", "break", ";", "case", "ARM_FT_EXCEPTION", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ ARM Exception Handler.\\n\"", ")", ";", "break", ";", "}", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Naked Function: prologue and epilogue provided by programmer.\\n\"", ")", ";", "if", "(", "IS_VOLATILE", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Volatile: function does not return.\\n\"", ")", ";", "if", "(", "IS_NESTED", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Nested: function declared inside another function.\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\t%@ args = %d, pretend = %d, frame = %wd\\n\"", ",", "current_function_args_size", ",", "current_function_pretend_args_size", ",", "frame_size", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\t%@ frame_needed = %d, uses_anonymous_args = %d\\n\"", ",", "frame_pointer_needed", ",", "cfun", "->", "machine", "->", "uses_anonymous_args", ")", ";", "if", "(", "cfun", "->", "machine", "->", "lr_save_eliminated", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ link register save eliminated.\\n\"", ")", ";", "if", "(", "current_function_calls_eh_return", ")", "asm_fprintf", "(", "f", ",", "\"\\t@ Calls __builtin_eh_return.\\n\"", ")", ";", "if", "(", "flag_pic", ")", "asm_fprintf", "(", "f", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "IP_REGNUM", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "return_used_this_function", "=", "0", ";", "}", "</s>" ]

[ "Place", "some", "comments", "into", "the", "assembler", "stream", "describing", "the", "current", "function", "." ]

[ "arm", "\"\\t%@ Function supports interworking.\\n\"", "\"\\t%@ Interrupt Service Routine.\\n\"", "\"\\t%@ Fast Interrupt Service Routine.\\n\"", "\"\\t%@ ARM Exception Handler.\\n\"", "\"\\t%@ Naked Function: prologue and epilogue provided by programmer.\\n\"", "\"\\t%@ Volatile: function does not return.\\n\"", "\"\\t%@ Nested: function declared inside another function.\\n\"", "\"\\t%@ args = %d, pretend = %d, frame = %wd\\n\"", "\"\\t%@ frame_needed = %d, uses_anonymous_args = %d\\n\"", "\"\\t%@ link register save eliminated.\\n\"", "\"\\t@ Calls __builtin_eh_return.\\n\"", "\"\\tmov\\t%r, %r\\n\"", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "read_file", "(", "FILE", "*", "stream", ",", "size_t", "*", "plen", ")", "{", "size_t", "alloc", "=", "16384", ";", "size_t", "base", "=", "0", ";", "char", "*", "buffer", ";", "if", "(", "!", "fseek", "(", "stream", ",", "0", ",", "SEEK_END", ")", ")", "{", "long", "s", "=", "ftell", "(", "stream", ")", ";", "if", "(", "s", ">=", "0", ")", "alloc", "=", "s", "+", "100", ";", "fseek", "(", "stream", ",", "0", ",", "SEEK_SET", ")", ";", "}", "buffer", "=", "XNEWVEC", "(", "char", ",", "alloc", ")", ";", "for", "(", ";", ";", ")", "{", "size_t", "n", "=", "fread", "(", "buffer", "+", "base", ",", "1", ",", "alloc", "-", "base", "-", "1", ",", "stream", ")", ";", "if", "(", "!", "n", ")", "break", ";", "base", "+=", "n", ";", "if", "(", "base", "+", "1", "==", "alloc", ")", "{", "alloc", "*=", "2", ";", "buffer", "=", "XRESIZEVEC", "(", "char", ",", "buffer", ",", "alloc", ")", ";", "}", "}", "buffer", "[", "base", "]", "=", "0", ";", "*", "plen", "=", "base", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Read", "the", "whole", "input", "file", ".", "It", "will", "be", "NUL", "terminated", "(", "but", "remember", ",", "there", "could", "be", "a", "NUL", "in", "the", "file", "itself", "." ]

[ "nvptx", "16384", "0", "0", "0", "100", "0", "1", "1", "1", "2", "0" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "Size", ",", "unsigned", "Align", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFL", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "assert", "(", "Size", "&&", "\"Byval argument's size shouldn't be 0.\"", ")", ";", "Align", "=", "std", "::", "min", "(", "Align", ",", "TFL", "->", "getStackAlignment", "(", ")", ")", ";", "unsigned", "FirstReg", "=", "0", ";", "unsigned", "NumRegs", "=", "0", ";", "if", "(", "State", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "Fast", ")", "{", "unsigned", "RegSizeInBytes", "=", "Subtarget", ".", "getGPRSizeInBytes", "(", ")", ";", "const", "ArrayRef", "<", "MCPhysReg", ">", "IntArgRegs", "=", "ABI", ".", "GetByValArgRegs", "(", ")", ";", "const", "MCPhysReg", "*", "ShadowRegs", "=", "ABI", ".", "IsO32", "(", ")", "?", "IntArgRegs", ".", "data", "(", ")", ":", "Mips64DPRegs", ";", "assert", "(", "!", "(", "Align", "%", "RegSizeInBytes", ")", "&&", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", ")", ";", "FirstReg", "=", "State", "->", "getFirstUnallocated", "(", "IntArgRegs", ".", "data", "(", ")", ",", "IntArgRegs", ".", "size", "(", ")", ")", ";", "if", "(", "(", "Align", ">", "RegSizeInBytes", ")", "&&", "(", "FirstReg", "%", "2", ")", ")", "{", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "FirstReg", "]", ",", "ShadowRegs", "[", "FirstReg", "]", ")", ";", "++", "FirstReg", ";", "}", "Size", "=", "RoundUpToAlignment", "(", "Size", ",", "RegSizeInBytes", ")", ";", "for", "(", "unsigned", "I", "=", "FirstReg", ";", "Size", ">", "0", "&&", "(", "I", "<", "IntArgRegs", ".", "size", "(", ")", ")", ";", "Size", "-=", "RegSizeInBytes", ",", "++", "I", ",", "++", "NumRegs", ")", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "I", "]", ",", "ShadowRegs", "[", "I", "]", ")", ";", "}", "State", "->", "addInRegsParamInfo", "(", "FirstReg", ",", "FirstReg", "+", "NumRegs", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "Mips", "Mips", "\"Byval argument's size shouldn't be 0.\"", "0", "0", "Mips", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", "2", "0" ]

[]

[ "<s>", "void", "MMIXAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Kind", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "if", "(", "Kind", "==", "static_cast", "<", "MCFixupKind", ">", "(", "MMIX", "::", "fixup_mmix_rel_16", ")", "||", "Kind", "==", "static_cast", "<", "MCFixupKind", ">", "(", "MMIX", "::", "fixup_mmix_rel_24", ")", ")", "Data", "[", "Offset", "]", "&=", "0xfe", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "(", "Info", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "3", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "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", "." ]

[ "MMIX", "MMIX", "MMIX::fixup_mmix_rel_16", "MMIX::fixup_mmix_rel_24", "0xfe", "7", "8", "\"Invalid fixup offset!\"", "0", "4", "3", "8", "0xff" ]

[]

[ "<s>", "SDValue", "DLXSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", ",", "const", "SDLoc", "&", ",", "SDValue", ",", "SDValue", ",", "SDValue", ",", "SDValue", "Size", ",", "unsigned", ",", "bool", ",", "bool", ",", "MachinePointerInfo", ",", "MachinePointerInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "DLX", "DLX" ]

[]

[ "<s>", "static", "rtx", "mips_function_value_1", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "machine_mode", "mode", ")", "{", "if", "(", "valtype", ")", "{", "tree", "fields", "[", "2", "]", ";", "int", "unsigned_p", ";", "const_tree", "func", ";", "if", "(", "fn_decl_or_type", "&&", "DECL_P", "(", "fn_decl_or_type", ")", ")", "func", "=", "fn_decl_or_type", ";", "else", "func", "=", "NULL", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsigned_p", ",", "func", ",", "1", ")", ";", "switch", "(", "mips_fpr_return_fields", "(", "valtype", ",", "fields", ")", ")", "{", "case", "1", ":", "return", "mips_return_fpr_single", "(", "mode", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "0", "]", ")", ")", ")", ";", "case", "2", ":", "return", "mips_return_fpr_pair", "(", "mode", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "0", "]", ")", ")", ",", "int_byte_position", "(", "fields", "[", "0", "]", ")", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "1", "]", ")", ")", ",", "int_byte_position", "(", "fields", "[", "1", "]", ")", ")", ";", "}", "if", "(", "mips_return_in_msb", "(", "valtype", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "if", "(", "size", "%", "UNITS_PER_WORD", "!=", "0", ")", "{", "size", "+=", "UNITS_PER_WORD", "-", "size", "%", "UNITS_PER_WORD", ";", "mode", "=", "mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "}", "}", "if", "(", "mips_abi", "!=", "ABI_EABI", "&&", "!", "FLOAT_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GP_RETURN", ")", ";", "}", "if", "(", "!", "TARGET_MIPS16", ")", "{", "if", "(", "mode", "==", "TFmode", ")", "return", "mips_return_fpr_pair", "(", "mode", ",", "DImode", ",", "0", ",", "DImode", ",", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", ")", ";", "if", "(", "mips_return_mode_in_fpr_p", "(", "mode", ")", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "return", "mips_return_fpr_pair", "(", "mode", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "0", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "FP_RETURN", ")", ";", "}", "}", "return", "gen_rtx_REG", "(", "mode", ",", "GP_RETURN", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "and", "TARGET_LIBCALL_VALUE", ".", "For", "normal", "calls", ",", "VALTYPE", "is", "the", "return", "type", "and", "MODE", "is", "VOIDmode", ".", "For", "libcalls", ",", "VALTYPE", "is", "null", "and", "MODE", "is", "the", "mode", "of", "the", "return", "value", "." ]

[ "mips", "2", "1", "1", "0", "2", "0", "0", "1", "1", "0", "0", "0", "2", "0", "2" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "void", "arm_output_multireg_pop", "(", "rtx", "*", "operands", ",", "bool", "return_pc", ",", "rtx", "cond", ",", "bool", "reverse", ",", "bool", "update", ")", "{", "int", "i", ";", "char", "pattern", "[", "100", "]", ";", "int", "offset", ";", "const", "char", "*", "conditional", ";", "int", "num_saves", "=", "XVECLEN", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "unsigned", "int", "regno", ";", "unsigned", "int", "regno_base", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "bool", "interrupt_p", "=", "IS_INTERRUPT", "(", "arm_current_func_type", "(", ")", ")", ";", "offset", "=", "0", ";", "offset", "+=", "update", "?", "1", ":", "0", ";", "offset", "+=", "return_pc", "?", "1", ":", "0", ";", "for", "(", "i", "=", "offset", ";", "i", "<", "num_saves", ";", "i", "++", ")", "{", "regno", "=", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "operands", "[", "0", "]", ",", "0", ",", "i", ")", ",", "0", ")", ")", ";", "gcc_assert", "(", "(", "regno", "!=", "SP_REGNUM", ")", "||", "(", "regno_base", "==", "SP_REGNUM", ")", ")", ";", "if", "(", "regno", "==", "regno_base", ")", "gcc_assert", "(", "!", "update", ")", ";", "}", "conditional", "=", "reverse", "?", "\"%?%D0\"", ":", "\"%?%d0\"", ";", "if", "(", "(", "regno_base", "==", "SP_REGNUM", ")", "&&", "update", "&&", "!", "(", "interrupt_p", "&&", "return_pc", ")", ")", "sprintf", "(", "pattern", ",", "\"pop%s\\t{\"", ",", "conditional", ")", ";", "else", "{", "if", "(", "regno_base", "==", "SP_REGNUM", ")", "sprintf", "(", "pattern", ",", "\"ldmfd%s\\t\"", ",", "conditional", ")", ";", "else", "if", "(", "update", ")", "sprintf", "(", "pattern", ",", "\"ldmia%s\\t\"", ",", "conditional", ")", ";", "else", "sprintf", "(", "pattern", ",", "\"ldm%s\\t\"", ",", "conditional", ")", ";", "strcat", "(", "pattern", ",", "reg_names", "[", "regno_base", "]", ")", ";", "if", "(", "update", ")", "strcat", "(", "pattern", ",", "\"!, {\"", ")", ";", "else", "strcat", "(", "pattern", ",", "\", {\"", ")", ";", "}", "strcat", "(", "pattern", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "operands", "[", "0", "]", ",", "0", ",", "offset", ")", ",", "0", ")", ")", "]", ")", ";", "for", "(", "i", "=", "offset", "+", "1", ";", "i", "<", "num_saves", ";", "i", "++", ")", "{", "strcat", "(", "pattern", ",", "\", \"", ")", ";", "strcat", "(", "pattern", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "operands", "[", "0", "]", ",", "0", ",", "i", ")", ",", "0", ")", ")", "]", ")", ";", "}", "strcat", "(", "pattern", ",", "\"}\"", ")", ";", "if", "(", "interrupt_p", "&&", "return_pc", ")", "strcat", "(", "pattern", ",", "\"^\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "&", "cond", ")", ";", "}", "</s>" ]

[ "OPERANDS", "[", "0", "]", "is", "the", "entire", "list", "of", "insns", "that", "constitute", "pop", ",", "OPERANDS", "[", "1", "]", "is", "the", "base", "register", ",", "RETURN_PC", "is", "true", "iff", "return", "insn", "is", "in", "the", "list", ",", "UPDATE", "is", "true", "iff", "the", "list", "contains", "explicit", "update", "of", "base", "register", "." ]

[ "arm", "100", "0", "0", "1", "0", "1", "0", "1", "0", "0", "0", "0", "\"%?%D0\"", "\"%?%d0\"", "\"pop%s\\t{\"", "\"ldmfd%s\\t\"", "\"ldmia%s\\t\"", "\"ldm%s\\t\"", "\"!, {\"", "\", {\"", "0", "0", "0", "1", "\", \"", "0", "0", "0", "\"}\"", "\"^\"" ]

[]

[ "<s>", "void", "BT", "::", "run", "(", ")", "{", "reset", "(", ")", ";", "assert", "(", "FlowQ", ".", "empty", "(", ")", ")", ";", "typedef", "GraphTraits", "<", "const", "MachineFunction", "*", ">", "MachineFlowGraphTraits", ";", "const", "MachineBasicBlock", "*", "Entry", "=", "MachineFlowGraphTraits", "::", "getEntryNode", "(", "&", "MF", ")", ";", "unsigned", "MaxBN", "=", "0", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "assert", "(", "I", "->", "getNumber", "(", ")", ">=", "0", "&&", "\"Disconnected block\"", ")", ";", "unsigned", "BN", "=", "I", "->", "getNumber", "(", ")", ";", "if", "(", "BN", ">", "MaxBN", ")", "MaxBN", "=", "BN", ";", "}", "BitVector", "BlockScanned", "(", "MaxBN", "+", "1", ")", ";", "int", "EntryN", "=", "Entry", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "-", "1", ",", "EntryN", ")", ")", ";", "while", "(", "!", "FlowQ", ".", "empty", "(", ")", ")", "{", "CFGEdge", "Edge", "=", "FlowQ", ".", "front", "(", ")", ";", "FlowQ", ".", "pop", "(", ")", ";", "if", "(", "EdgeExec", ".", "count", "(", "Edge", ")", ")", "continue", ";", "EdgeExec", ".", "insert", "(", "Edge", ")", ";", "const", "MachineBasicBlock", "&", "B", "=", "*", "MF", ".", "getBlockNumbered", "(", "Edge", ".", "second", ")", ";", "MachineBasicBlock", "::", "const_iterator", "It", "=", "B", ".", "begin", "(", ")", ",", "End", "=", "B", ".", "end", "(", ")", ";", "while", "(", "It", "!=", "End", "&&", "It", "->", "isPHI", "(", ")", ")", "{", "const", "MachineInstr", "*", "PI", "=", "&", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "PI", ")", ";", "visitPHI", "(", "PI", ")", ";", "}", "if", "(", "BlockScanned", "[", "Edge", ".", "second", "]", ")", "continue", ";", "BlockScanned", "[", "Edge", ".", "second", "]", "=", "true", ";", "while", "(", "It", "!=", "End", "&&", "!", "It", "->", "isBranch", "(", ")", ")", "{", "const", "MachineInstr", "*", "MI", "=", "&", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "MI", ")", ";", "visitNonBranch", "(", "MI", ")", ";", "}", "if", "(", "It", "==", "End", ")", "{", "MachineFunction", "::", "const_iterator", "BIt", "=", "B", ".", "getIterator", "(", ")", ";", "MachineFunction", "::", "const_iterator", "Next", "=", "std", "::", "next", "(", "BIt", ")", ";", "if", "(", "Next", "!=", "MF", ".", "end", "(", ")", "&&", "B", ".", "isSuccessor", "(", "&", "*", "Next", ")", ")", "{", "int", "ThisN", "=", "B", ".", "getNumber", "(", ")", ";", "int", "NextN", "=", "Next", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "ThisN", ",", "NextN", ")", ")", ";", "}", "}", "else", "{", "visitBranchesFrom", "(", "It", ")", ";", "}", "}", "if", "(", "Trace", ")", "{", "dbgs", "(", ")", "<<", "\"Cells after propagation:\\n\"", ";", "for", "(", "CellMapType", "::", "iterator", "I", "=", "Map", ".", "begin", "(", ")", ",", "E", "=", "Map", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "dbgs", "(", ")", "<<", "PrintReg", "(", "I", "->", "first", ",", "&", "ME", ".", "TRI", ")", "<<", "\" -> \"", "<<", "I", "->", "second", "<<", "\"\\n\"", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "0", "0", "\"Disconnected block\"", "1", "1", "\"Cells after propagation:\\n\"", "\" -> \"", "\"\\n\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "*", "TII", "=", "BB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "const", "RISCVVectorPseudosTable", "::", "RISCVVectorPseudoInfo", "*", "pseudo", "=", "RISCVVectorPseudosTable", "::", "getRISCVVectorPseudoInfo", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "int", "Sew", "=", "MI", ".", "getOperand", "(", "pseudo", "->", "SEWIndex", ")", ".", "getImm", "(", ")", ";", "int", "Vlmul", "=", "pseudo", "->", "VLMul", ";", "unsigned", "vtypei", "=", "0", ";", "switch", "(", "Sew", ")", "{", "case", "8", ":", "vtypei", "|=", "RISCVVectorSEW", "::", "SEW8", ";", "break", ";", "case", "16", ":", "vtypei", "|=", "RISCVVectorSEW", "::", "SEW16", ";", "break", ";", "case", "32", ":", "vtypei", "|=", "RISCVVectorSEW", "::", "SEW32", ";", "break", ";", "case", "64", ":", "vtypei", "|=", "RISCVVectorSEW", "::", "SEW64", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"unknown sew value\"", ")", ";", "}", "switch", "(", "Vlmul", ")", "{", "case", "1", ":", "vtypei", "|=", "RISCVVectorLMUL", "::", "M1", ";", "break", ";", "case", "2", ":", "vtypei", "|=", "RISCVVectorLMUL", "::", "M2", ";", "break", ";", "case", "4", ":", "vtypei", "|=", "RISCVVectorLMUL", "::", "M4", ";", "break", ";", "case", "8", ":", "vtypei", "|=", "RISCVVectorLMUL", "::", "M8", ";", "break", ";", "case", "9", ":", "vtypei", "|=", "RISCVVectorLMUL", "::", "MF2", ";", "break", ";", "case", "10", ":", "vtypei", "|=", "RISCVVectorLMUL", "::", "MF4", ";", "break", ";", "case", "11", ":", "vtypei", "|=", "RISCVVectorLMUL", "::", "MF8", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"unknown vlmul value!\"", ")", ";", "}", "BuildMI", "(", "*", "BB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "RISCV", "::", "VSETVLI", ")", ",", "RISCV", "::", "X0", ")", ".", "addReg", "(", "RISCV", "::", "X0", ")", ".", "addImm", "(", "vtypei", ")", ";", "return", "BB", ";", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "ReadCycleWide", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"ReadCycleWrite is only to be used on riscv32\"", ")", ";", "return", "emitReadCycleWidePseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR64_Using_CC_GPR", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "BuildPairF64Pseudo", ":", "return", "emitBuildPairF64Pseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "SplitF64Pseudo", ":", "return", "emitSplitF64Pseudo", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVVectorPseudosTable::RISCVVectorPseudoInfo", "RISCVVectorPseudosTable::getRISCVVectorPseudoInfo", "0", "8", "RISCVVectorSEW::SEW8", "16", "RISCVVectorSEW::SEW16", "32", "RISCVVectorSEW::SEW32", "64", "RISCVVectorSEW::SEW64", "\"unknown sew value\"", "1", "RISCVVectorLMUL::M1", "2", "RISCVVectorLMUL::M2", "4", "RISCVVectorLMUL::M4", "8", "RISCVVectorLMUL::M8", "9", "RISCVVectorLMUL::MF2", "10", "RISCVVectorLMUL::MF4", "11", "RISCVVectorLMUL::MF8", "\"unknown vlmul value!\"", "RISCV::VSETVLI", "RISCV::X0", "RISCV::X0", "\"Unexpected instr type to insert\"", "RISCV::ReadCycleWide", "\"ReadCycleWrite is only to be used on riscv32\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo" ]

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "SystemZTTIImpl", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Type width must be power of 2\"", ")", ";", "if", "(", "ST", "->", "hasPopulationCount", "(", ")", "&&", "TyWidth", "<=", "64", ")", "return", "TTI", "::", "PSK_FastHardware", ";", "return", "TTI", "::", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "SystemZ", "SystemZ", "\"Type width must be power of 2\"", "64" ]

[]

[ "<s>", "StackOffset", "SparcFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "bool", "UseFP", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "if", "(", "isFixed", ")", "{", "UseFP", "=", "true", ";", "}", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "{", "UseFP", "=", "true", ";", "}", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", "+", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "if", "(", "UseFP", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", ")", ";", "}", "else", "{", "FrameReg", "=", "SP", "::", "O6", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::O6" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STRBui", ":", "case", "AArch64", "::", "STRHui", ":", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STRQui", ":", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "AArch64", "AArch64", "AArch64::STRWui", "AArch64::STRXui", "AArch64::STRBui", "AArch64::STRHui", "AArch64::STRSui", "AArch64::STRDui", "AArch64::STRQui", "0", "0", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "MINA32RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32" ]

[]

[ "<s>", "LoadInst", "*", "X86TargetLowering", "::", "lowerIdempotentRMWIntoFencedLoad", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "NativeWidth", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "const", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "return", "nullptr", ";", "auto", "Builder", "=", "IRBuilder", "<", ">", "(", "AI", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "SynchScope", "=", "AI", "->", "getSynchScope", "(", ")", ";", "auto", "Order", "=", "AtomicCmpXchgInst", "::", "getStrongestFailureOrdering", "(", "AI", "->", "getOrdering", "(", ")", ")", ";", "auto", "Ptr", "=", "AI", "->", "getPointerOperand", "(", ")", ";", "if", "(", "SynchScope", "==", "SingleThread", ")", "{", "return", "nullptr", ";", "}", "else", "if", "(", "hasMFENCE", "(", "*", "Subtarget", ")", ")", "{", "Function", "*", "MFence", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "x86_sse2_mfence", ")", ";", "Builder", ".", "CreateCall", "(", "MFence", ")", ";", "}", "else", "{", "return", "nullptr", ";", "}", "LoadInst", "*", "Loaded", "=", "Builder", ".", "CreateAlignedLoad", "(", "Ptr", ",", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ")", ";", "Loaded", "->", "setAtomic", "(", "Order", ",", "SynchScope", ")", ";", "AI", "->", "replaceAllUsesWith", "(", "Loaded", ")", ";", "AI", "->", "eraseFromParent", "(", ")", ";", "return", "Loaded", ";", "}", "</s>" ]

[ "On", "some", "platforms", ",", "an", "AtomicRMW", "that", "never", "actually", "modifies", "the", "value", "(", "such", "as", "fetch_add", "of", "0", ")", "can", "be", "turned", "into", "a", "fence", "followed", "by", "an", "atomic", "load", "." ]

[ "X86", "X86", "64", "32", "Intrinsic::getDeclaration", "Intrinsic::x86_sse2_mfence" ]

[]

[ "<s>", "SDValue", "M68kTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_M68k", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "VA", ".", "isExtInLoc", "(", ")", "&&", "VA", ".", "getValVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "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", "." ]

[ "M68k", "M68k", "ISD::InputArg", "16", "M68k", "0", "1", "0", "MVT::i1", "ISD::TRUNCATE", "2" ]

[]

[ "<s>", "int", "PPCInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "*", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "int", "Latency", "=", "PPCGenInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "const", "MachineOperand", "&", "DefMO", "=", "DefMI", "->", "getOperand", "(", "DefIdx", ")", ";", "unsigned", "Reg", "=", "DefMO", ".", "getReg", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "bool", "IsRegCR", ";", "if", "(", "TRI", "->", "isVirtualRegister", "(", "Reg", ")", ")", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "DefMI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "IsRegCR", "=", "MRI", "->", "getRegClass", "(", "Reg", ")", "->", "hasSuperClassEq", "(", "&", "PPC", "::", "CRRCRegClass", ")", "||", "MRI", "->", "getRegClass", "(", "Reg", ")", "->", "hasSuperClassEq", "(", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "}", "else", "{", "IsRegCR", "=", "PPC", "::", "CRRCRegClass", ".", "contains", "(", "Reg", ")", "||", "PPC", "::", "CRBITRCRegClass", ".", "contains", "(", "Reg", ")", ";", "}", "if", "(", "UseMI", "->", "isBranch", "(", ")", "&&", "IsRegCR", ")", "{", "if", "(", "Latency", "<", "0", ")", "Latency", "=", "getInstrLatency", "(", "ItinData", ",", "DefMI", ")", ";", "unsigned", "Directive", "=", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "switch", "(", "Directive", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_7400", ":", "case", "PPC", "::", "DIR_750", ":", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_E5500", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "Latency", "+=", "2", ";", "break", ";", "}", "}", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::CRRCRegClass", "PPC::CRBITRCRegClass", "PPC::CRRCRegClass", "PPC::CRBITRCRegClass", "0", "PPC", "PPC::DIR_7400", "PPC::DIR_750", "PPC::DIR_970", "PPC::DIR_E5500", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "2" ]

[]

[ "<s>", "static", "rtx", "rs6000_load_constant_and_splat", "(", "machine_mode", "mode", ",", "REAL_VALUE_TYPE", "dconst", ")", "{", "rtx", "reg", ";", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "{", "rtx", "d", "=", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "dconst", ",", "mode", ")", ";", "reg", "=", "force_reg", "(", "mode", ",", "d", ")", ";", "}", "else", "if", "(", "mode", "==", "V4SFmode", ")", "{", "rtx", "d", "=", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "dconst", ",", "SFmode", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "4", ",", "d", ",", "d", ",", "d", ",", "d", ")", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_expand_vector_init", "(", "reg", ",", "gen_rtx_PARALLEL", "(", "mode", ",", "v", ")", ")", ";", "}", "else", "if", "(", "mode", "==", "V2DFmode", ")", "{", "rtx", "d", "=", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "dconst", ",", "DFmode", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "2", ",", "d", ",", "d", ")", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_expand_vector_init", "(", "reg", ",", "gen_rtx_PARALLEL", "(", "mode", ",", "v", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Load", "up", "a", "constant", ".", "If", "the", "mode", "is", "a", "vector", "mode", ",", "splat", "the", "value", "across", "all", "of", "the", "vector", "elements", "." ]

[ "rs6000", "4", "2" ]

[]

[ "<s>", "tree", "riscv_builtin_decl", "(", "unsigned", "int", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "subcode", "=", "code", ">>", "RISCV_BUILTIN_SHIFT", ";", "switch", "(", "code", "&", "RISCV_BUILTIN_CLASS", ")", "{", "case", "RISCV_BUILTIN_GENERAL", ":", "if", "(", "subcode", ">=", "ARRAY_SIZE", "(", "riscv_builtins", ")", ")", "return", "error_mark_node", ";", "return", "riscv_builtin_decls", "[", "subcode", "]", ";", "case", "RISCV_BUILTIN_VECTOR", ":", "return", "riscv_vector", "::", "builtin_decl", "(", "subcode", ",", "initialize_p", ")", ";", "}", "return", "error_mark_node", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "." ]

[ "riscv", "riscv_vector::builtin_decl" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateUniformValues", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "AMDGPUASI", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "M", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "AMDGPU", "SI", "AMDGPU::getAMDGPUAS" ]

[]

[ "<s>", "bool", "PatmosAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "MCInst", "MCI", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "MCI", ")", ";", "PatmosInstPrinter", "PIP", "(", "*", "OutContext", ".", "getAsmInfo", "(", ")", ",", "*", "TM", ".", "getMCInstrInfo", "(", ")", ",", "*", "TM", ".", "getMCRegisterInfo", "(", ")", ")", ";", "PIP", ".", "printOperand", "(", "&", "MCI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "0", "Patmos" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "const", "HexagonEvaluator", "HE", "(", "HRI", ",", "MRI", ",", "HII", ",", "MF", ")", ";", "BitTracker", "BT", "(", "HE", ",", "MF", ")", ";", "DEBUG", "(", "BT", ".", "trace", "(", "true", ")", ")", ";", "BT", ".", "run", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "RegisterSet", "AIG", ";", "ConstGeneration", "ImmG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "ImmG", ",", "AIG", ")", ";", "RegisterSet", "ARE", ";", "RedundantInstrElimination", "RIE", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "RIE", ",", "ARE", ")", ";", "RegisterSet", "ACG", ";", "CopyGeneration", "CopyG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyG", ",", "ACG", ")", ";", "RegisterSet", "ACP", ";", "CopyPropagation", "CopyP", "(", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyP", ",", "ACP", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "BT", ".", "run", "(", ")", ";", "RegisterSet", "ABS", ";", "BitSimplification", "BitS", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "BitS", ",", "ABS", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "if", "(", "Changed", ")", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "for", "(", "auto", "&", "I", ":", "B", ")", "I", ".", "clearKillInfo", "(", ")", ";", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mips_expand_ins_as_unaligned_store", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "width", ",", "HOST_WIDE_INT", "bitpos", ")", "{", "rtx", "left", ",", "right", ";", "machine_mode", "mode", ";", "if", "(", "!", "mips_get_unaligned_mem", "(", "dest", ",", "width", ",", "bitpos", ",", "&", "left", ",", "&", "right", ")", ")", "return", "false", ";", "mode", "=", "mode_for_size", "(", "width", ",", "MODE_INT", ",", "0", ")", ";", "src", "=", "gen_lowpart", "(", "mode", ",", "src", ")", ";", "if", "(", "mode", "==", "DImode", ")", "{", "emit_insn", "(", "gen_mov_sdl", "(", "dest", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_sdr", "(", "copy_rtx", "(", "dest", ")", ",", "copy_rtx", "(", "src", ")", ",", "right", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_mov_swl", "(", "dest", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_swr", "(", "copy_rtx", "(", "dest", ")", ",", "copy_rtx", "(", "src", ")", ",", "right", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "use", "left/right", "stores", "to", "expand", "an", "``", "ins", "''", "pattern", ".", "DEST", ",", "WIDTH", ",", "BITPOS", "and", "SRC", "are", "the", "operands", "passed", "to", "the", "expander", ";", "the", "operation", "is", "the", "equivalent", "of", ":", "(", "set", "(", "zero_extract", "DEST", "WIDTH", "BITPOS", ")", "SRC", ")", "Return", "true", "on", "success", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "bool", "isConditionalBranch", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "TBZW", ":", "case", "AArch64", "::", "TBNZW", ":", "case", "AArch64", "::", "TBZX", ":", "case", "AArch64", "::", "TBNZX", ":", "case", "AArch64", "::", "CBZW", ":", "case", "AArch64", "::", "CBNZW", ":", "case", "AArch64", "::", "CBZX", ":", "case", "AArch64", "::", "CBNZX", ":", "case", "AArch64", "::", "Bcc", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "branch", "which", "may", "fall", "through", "to", "the", "next", "instruction", "or", "may", "transfer", "control", "flow", "to", "some", "other", "block", "." ]

[ "AArch64", "AArch64::TBZW", "AArch64::TBNZW", "AArch64::TBZX", "AArch64::TBNZX", "AArch64::CBZW", "AArch64::CBNZW", "AArch64::CBZX", "AArch64::CBNZX", "AArch64::Bcc" ]

[]

[ "<s>", "static", "bool", "get_load_info", "(", "rtx_insn", "*", "insn", ",", "struct", "loop", "*", "loop", ",", "rtx", "*", "dest", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ",", "bool", "*", "pre_post", ",", "bool", "*", "ldp", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "false", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "unsigned", "code", "=", "GET_CODE", "(", "pat", ")", ";", "bool", "load_pair", "=", "(", "code", "==", "PARALLEL", ")", ";", "if", "(", "load_pair", ")", "{", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "code", "=", "GET_CODE", "(", "pat", ")", ";", "}", "if", "(", "code", "!=", "SET", ")", "return", "false", ";", "rtx", "dest_rtx", "=", "SET_DEST", "(", "pat", ")", ";", "if", "(", "!", "REG_P", "(", "dest_rtx", ")", ")", "return", "false", ";", "unsigned", "regno", "=", "REGNO", "(", "dest_rtx", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest_rtx", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "if", "(", "!", "GET_MODE_SIZE", "(", "mode", ")", ".", "is_constant", "(", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "!=", "GET_MODE_SIZE", "(", "inner_mode", ")", ".", "to_constant", "(", ")", ")", "return", "false", ";", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "<<", "load_pair", ")", ">", "GET_MODE_SIZE", "(", "OImode", ")", ")", "return", "false", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "false", ";", "if", "(", "valid_src_p", "(", "SET_SRC", "(", "pat", ")", ",", "insn", ",", "loop", ",", "pre_post", ",", "base", ",", "offset", ",", "load_pair", ")", ")", "{", "*", "dest", "=", "dest_rtx", ";", "*", "ldp", "=", "load_pair", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "a", "strided", "load", "in", "LOOP", ".", "If", "it", "is", "a", "strided", "load", ",", "set", "the", "DEST", ",", "BASE", "and", "OFFSET", ".", "Also", ",", "if", "this", "is", "a", "pre/post", "increment", "load", ",", "set", "PRE_POST", "to", "true", ".", "The", "routine", "does", "checks", "on", "the", "destination", "of", "the", "insn", "and", "depends", "on", "STRIDED_LOAD_P", "to", "check", "the", "source", "and", "fill", "in", "the", "BASE", "and", "OFFSET", "." ]

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

[]