Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "X86TargetLowering", "::", "shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd", "(", "SDValue", "X", ",", "ConstantSDNode", "*", "XC", ",", "ConstantSDNode", "*", "CC", ",", "SDValue", "Y", ",", "unsigned", "OldShiftOpcode", ",", "unsigned", "NewShiftOpcode", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "TargetLowering", "::", "shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd", "(", "X", ",", "XC", ",", "CC", ",", "Y", ",", "OldShiftOpcode", ",", "NewShiftOpcode", ",", "DAG", ")", ")", "return", "false", ";", "if", "(", "X", ".", "getValueType", "(", ")", ".", "isScalarInteger", "(", ")", ")", "return", "true", ";", "if", "(", "DAG", ".", "isSplatValue", "(", "Y", ",", "true", ")", ")", "return", "true", ";", "if", "(", "Subtarget", ".", "hasAVX2", "(", ")", ")", "return", "true", ";", "return", "NewShiftOpcode", "==", "ISD", "::", "SHL", ";", "}", "</s>" ]

[ "Given", "the", "pattern", "(", "X", "&", "(", "C", "l", ">", ">", "/", "<", "<", "Y", ")", ")", "==/", "!", "=", "0", "return", "true", "if", "it", "should", "be", "transformed", "into", ":", "(", "(", "X", "<", "<", "/l", ">", ">", "Y", ")", "&", "C", ")", "==/", "!", "=", "0", "WARNING", ":", "if", "'", "X", "'", "is", "a", "constant", ",", "the", "fold", "may", "deadlock", "!", "FIXME", ":", "we", "could", "avoid", "passing", "XC", ",", "but", "we", "ca", "n't", "use", "isConstOrConstSplat", "(", ")", "here", "because", "it", "can", "end", "up", "being", "not", "linked", "in", "." ]

[ "X86", "X86", "ISD::SHL" ]

[]

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

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

[ "OR1K" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "getGlobalBaseReg", "(", ")", "==", "0", ")", "return", "false", ";", "const", "ARMTargetMachine", "*", "TM", "=", "static_cast", "<", "const", "ARMTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "if", "(", "TM", "->", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "LLVMContext", "*", "Context", "=", "&", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "unsigned", "ARMPCLabelIndex", "=", "AFI", "->", "createPICLabelUId", "(", ")", ";", "unsigned", "PCAdj", "=", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb", "(", ")", "?", "4", ":", "8", ";", "ARMConstantPoolValue", "*", "CPV", "=", "ARMConstantPoolSymbol", "::", "Create", "(", "*", "Context", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "ARMPCLabelIndex", ",", "PCAdj", ")", ";", "unsigned", "Align", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", "->", "getPrefTypeAlignment", "(", "Type", "::", "getInt32PtrTy", "(", "*", "Context", ")", ")", ";", "unsigned", "Idx", "=", "MF", ".", "getConstantPool", "(", ")", "->", "getConstantPoolIndex", "(", "CPV", ",", "Align", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "unsigned", "TempReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "ARM", "::", "rGPRRegClass", ")", ";", "unsigned", "Opc", "=", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", "?", "ARM", "::", "t2LDRpci", ":", "ARM", "::", "LDRcp", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "TempReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "LDRcp", ")", "MIB", ".", "addImm", "(", "0", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "unsigned", "GlobalBaseReg", "=", "AFI", "->", "getGlobalBaseReg", "(", ")", ";", "Opc", "=", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", "?", "ARM", "::", "tPICADD", ":", "ARM", "::", "PICADD", ";", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ")", ".", "addImm", "(", "ARMPCLabelIndex", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "PICADD", ")", "AddDefaultPred", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "0", "ARM", "ARM", "ARM", "ARM", "4", "8", "ARM", "ARM", "\"_GLOBAL_OFFSET_TABLE_\"", "ARM", "ARM::rGPRRegClass", "ARM", "ARM::t2LDRpci", "ARM::LDRcp", "ARM::LDRcp", "0", "ARM", "ARM::tPICADD", "ARM::PICADD", "ARM", "ARM::PICADD" ]

[]

[ "<s>", "int", "rs6000_loop_align", "(", "rtx", "label", ")", "{", "basic_block", "bb", ";", "int", "ninsns", ";", "if", "(", "!", "can_override_loop_align", ")", "return", "align_loops_log", ";", "bb", "=", "BLOCK_FOR_INSN", "(", "label", ")", ";", "ninsns", "=", "num_loop_insns", "(", "bb", "->", "loop_father", ")", ";", "if", "(", "ninsns", ">", "4", "&&", "ninsns", "<=", "8", "&&", "(", "rs6000_cpu", "==", "PROCESSOR_POWER4", "||", "rs6000_cpu", "==", "PROCESSOR_POWER5", "||", "rs6000_cpu", "==", "PROCESSOR_POWER6", "||", "rs6000_cpu", "==", "PROCESSOR_POWER7", "||", "rs6000_cpu", "==", "PROCESSOR_POWER8", ")", ")", "return", "5", ";", "else", "return", "align_loops_log", ";", "}", "</s>" ]

[ "Implement", "LOOP_ALIGN", "." ]

[ "rs6000", "4", "8", "5" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSILowerControlFlowPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Result", "=", "Match_Success", ";", "for", "(", "auto", "Variant", ":", "getMatchedVariants", "(", ")", ")", "{", "uint64_t", "EI", ";", "auto", "R", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "EI", ",", "MatchingInlineAsm", ",", "Variant", ")", ";", "if", "(", "(", "R", "==", "Match_Success", ")", "||", "(", "R", "==", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MnemonicFail", "&&", "Result", "!=", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", ")", "{", "Result", "=", "R", ";", "ErrorInfo", "=", "EI", ";", "}", "if", "(", "R", "==", "Match_Success", ")", "break", ";", "}", "switch", "(", "Result", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "!", "validateInstruction", "(", "Inst", ",", "IDLoc", ")", ")", "{", "return", "true", ";", "}", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "{", "uint64_t", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "AMDGPUMnemonicSpellCheck", "(", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_PreferE32", ":", "return", "Error", "(", "IDLoc", ",", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "AMDGPU", "AMDGPU", "\"instruction not supported on this GPU\"", "AMDGPU", "AMDGPU", "0", "\"invalid instruction\"", "AMDGPU", "0", "0ULL", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_file_start", "(", "void", ")", "{", "rs6000_gen_section_name", "(", "&", "xcoff_bss_section_name", ",", "main_input_filename", ",", "\".bss_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_private_data_section_name", ",", "main_input_filename", ",", "\".rw_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_private_rodata_section_name", ",", "main_input_filename", ",", "\".rop_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_read_only_section_name", ",", "main_input_filename", ",", "\".ro_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_tls_data_section_name", ",", "main_input_filename", ",", "\".tls_\"", ")", ";", "fputs", "(", "\"\\t.file\\t\"", ",", "asm_out_file", ")", ";", "output_quoted_string", "(", "asm_out_file", ",", "main_input_filename", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "if", "(", "write_symbols", "!=", "NO_DEBUG", ")", "switch_to_section", "(", "private_data_section", ")", ";", "switch_to_section", "(", "toc_section", ")", ";", "switch_to_section", "(", "text_section", ")", ";", "if", "(", "profile_flag", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.extern %s\\n\"", ",", "RS6000_MCOUNT", ")", ";", "rs6000_file_start", "(", ")", ";", "}", "</s>" ]

[ "Output", "at", "beginning", "of", "assembler", "file", ".", "Initialize", "the", "section", "names", "for", "the", "RS/6000", "at", "this", "point", ".", "Specify", "filename", ",", "including", "full", "path", ",", "to", "assembler", ".", "We", "want", "to", "go", "into", "the", "TOC", "section", "so", "at", "least", "one", ".toc", "will", "be", "emitted", ".", "Also", ",", "in", "order", "to", "output", "proper", ".bs/.es", "pairs", ",", "we", "need", "at", "least", "one", "static", "[", "RW", "]", "section", "emitted", ".", "Finally", ",", "declare", "mcount", "when", "profiling", "to", "make", "the", "assembler", "happy", "." ]

[ "rs6000", "\".bss_\"", "\".rw_\"", "\".rop_\"", "\".ro_\"", "\".tls_\"", "\"\\t.file\\t\"", "\"\\t.extern %s\\n\"" ]

[]

[ "<s>", "int", "SystemZFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "int64_t", "Offset", "=", "(", "MFFrame", ".", "getObjectOffset", "(", "FI", ")", "+", "MFFrame", ".", "getOffsetAdjustment", "(", ")", ")", ";", "Offset", "-=", "getOffsetOfLocalArea", "(", ")", ";", "Offset", "+=", "getAllocatedStackSize", "(", "MF", ")", ";", "return", "Offset", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::R31", "PPC::R1", "PPC::X31", "PPC::X1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetWindows", "(", ")", ")", "return", "CSR_Win_AArch64_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "CSR_AArch64_AAVPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_AArch64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_AArch64_CXX_TLS_Darwin_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "return", "CSR_Darwin_AArch64_AAPCS_SaveList", ";", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

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

[ "Does", "the", "system", "support", "unaligned", "memory", "access", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "PPCAIXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "const", "bool", "Result", "=", "PPCAsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "auto", "setCsectAlignment", "=", "[", "this", "]", "(", "const", "GlobalObject", "*", "GO", ")", "{", "if", "(", "GO", "->", "isDeclarationForLinker", "(", ")", ")", "return", ";", "SectionKind", "GOKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GO", ",", "TM", ")", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GO", ",", "GOKind", ",", "TM", ")", ")", ";", "Align", "GOAlign", "=", "getGVAlignment", "(", "GO", ",", "GO", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "if", "(", "GOAlign", ">", "Csect", "->", "getAlignment", "(", ")", ")", "Csect", "->", "setAlignment", "(", "GOAlign", ")", ";", "}", ";", "for", "(", "const", "auto", "&", "G", ":", "M", ".", "globals", "(", ")", ")", "{", "if", "(", "isSpecialLLVMGlobalArrayToSkip", "(", "&", "G", ")", ")", "continue", ";", "if", "(", "isSpecialLLVMGlobalArrayForStaticInit", "(", "&", "G", ")", ")", "{", "if", "(", "FormatIndicatorAndUniqueModId", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "UniqueModuleId", "=", "getUniqueModuleId", "(", "&", "M", ")", ";", "if", "(", "UniqueModuleId", ".", "compare", "(", "\"\"", ")", "!=", "0", ")", "FormatIndicatorAndUniqueModId", "=", "\"clang_\"", "+", "UniqueModuleId", ".", "substr", "(", "1", ")", ";", "else", "FormatIndicatorAndUniqueModId", "=", "\"clangPidTime_\"", "+", "llvm", "::", "itostr", "(", "sys", "::", "Process", "::", "getProcessId", "(", ")", ")", "+", "\"_\"", "+", "llvm", "::", "itostr", "(", "time", "(", "nullptr", ")", ")", ";", "}", "emitSpecialLLVMGlobal", "(", "&", "G", ")", ";", "continue", ";", "}", "setCsectAlignment", "(", "&", "G", ")", ";", "}", "for", "(", "const", "auto", "&", "F", ":", "M", ")", "setCsectAlignment", "(", "&", "F", ")", ";", "for", "(", "const", "auto", "&", "Alias", ":", "M", ".", "aliases", "(", ")", ")", "{", "const", "GlobalObject", "*", "Base", "=", "Alias", ".", "getBaseObject", "(", ")", ";", "if", "(", "!", "Base", ")", "report_fatal_error", "(", "\"alias without a base object is not yet supported on AIX\"", ")", ";", "GOAliasMap", "[", "Base", "]", ".", "push_back", "(", "&", "Alias", ")", ";", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "\"\"", "0", "\"clang_\"", "1", "\"clangPidTime_\"", "\"_\"", "\"alias without a base object is not yet supported on AIX\"" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "void", "m32c_override_options", "(", "void", ")", "{", "if", "(", "target_memregs_set", ")", "{", "if", "(", "target_memregs", "<", "0", "||", "target_memregs", ">", "16", ")", "error", "(", "\"invalid target memregs value '%d'\"", ",", "target_memregs", ")", ";", "}", "else", "target_memregs", "=", "\"16\"", ";", "}", "</s>" ]

[ "Implements", "OVERRIDE_OPTIONS", ".", "We", "limit", "memregs", "to", "0", "..", "16", ",", "and", "provide", "a", "default", "." ]

[ "m32c", "0", "16", "\"invalid target memregs value '%d'\"", "\"16\"" ]

[]

[ "<s>", "EVT", "BlackfinTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "Blackfin", "MVT::i32" ]

[]

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

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

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

[]

[ "<s>", "int", "iq2000_initial_elimination_offset", "(", "int", "from", ",", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "int", "offset", ";", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "(", "from", ")", "==", "FRAME_POINTER_REGNUM", ")", "(", "offset", ")", "=", "0", ";", "else", "if", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", ")", "(", "offset", ")", "=", "(", "cfun", "->", "machine", "->", "total_size", ")", ";", "else", "if", "(", "(", "from", ")", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", "{", "if", "(", "leaf_function_p", "(", ")", ")", "(", "offset", ")", "=", "0", ";", "else", "(", "offset", ")", "=", "cfun", "->", "machine", "->", "gp_sp_offset", "+", "(", "(", "UNITS_PER_WORD", "-", "(", "POINTER_SIZE", "/", "BITS_PER_UNIT", ")", ")", "*", "(", "BYTES_BIG_ENDIAN", "!=", "0", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "offset", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", ".", "FROM", "is", "either", "the", "frame", "pointer", ",", "argument", "pointer", ",", "or", "return", "address", "pointer", ".", "TO", "is", "either", "the", "stack", "pointer", "or", "hard", "frame", "pointer", "." ]

[ "iq2000", "0", "0", "0" ]

[]

[ "<s>", "int", "hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "enum", "reg_class", "rclass", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "if", "(", "mode", "==", "CCmode", ")", "return", "0", ";", "if", "(", "mode", "==", "V2HImode", ")", "return", "D_REGNO_P", "(", "regno", ")", ";", "if", "(", "rclass", "==", "CCREGS", ")", "return", "mode", "==", "BImode", ";", "if", "(", "mode", "==", "PDImode", "||", "mode", "==", "V2PDImode", ")", "return", "regno", "==", "REG_A0", "||", "regno", "==", "REG_A1", ";", "if", "(", "mode", "==", "DImode", ")", "return", "regno", "<", "REG_M3", ";", "if", "(", "mode", "==", "SImode", "&&", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "PROLOGUE_REGS", "]", ",", "regno", ")", ")", "return", "1", ";", "return", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "MOST_REGS", "]", ",", "regno", ")", ";", "}", "</s>" ]

[ "Value", "is", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

[ "bfin", "0", "1" ]

[]

[ "<s>", "void", "finishLayout", "(", "MCAssembler", "const", "&", "Asm", ",", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "for", "(", "auto", "I", ":", "Layout", ".", "getSectionOrder", "(", ")", ")", "{", "auto", "&", "Fragments", "=", "I", "->", "getFragmentList", "(", ")", ";", "for", "(", "auto", "&", "J", ":", "Fragments", ")", "{", "switch", "(", "J", ".", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "auto", "Size", "=", "Asm", ".", "computeFragmentSize", "(", "Layout", ",", "J", ")", ";", "for", "(", "auto", "K", "=", "J", ".", "getIterator", "(", ")", ";", "K", "!=", "Fragments", ".", "begin", "(", ")", "&&", "Size", ">=", "HEXAGON_PACKET_SIZE", ";", ")", "{", "--", "K", ";", "switch", "(", "K", "->", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "Size", "=", "0", ";", "break", ";", "}", "case", "MCFragment", "::", "FT_Relaxable", ":", "{", "MCContext", "&", "Context", "=", "Asm", ".", "getContext", "(", ")", ";", "auto", "&", "RF", "=", "cast", "<", "MCRelaxableFragment", ">", "(", "*", "K", ")", ";", "auto", "&", "Inst", "=", "const_cast", "<", "MCInst", "&", ">", "(", "RF", ".", "getInst", "(", ")", ")", ";", "while", "(", "Size", ">", "0", "&&", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Inst", ")", "<", "MaxPacketSize", ")", "{", "MCInst", "*", "Nop", "=", "new", "(", "Context", ")", "MCInst", ";", "Nop", "->", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Nop", ")", ")", ";", "Size", "-=", "4", ";", "if", "(", "!", "HexagonMCChecker", "(", "Context", ",", "*", "MCII", ",", "*", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ",", "*", "Context", ".", "getRegisterInfo", "(", ")", ",", "false", ")", ".", "check", "(", ")", ")", "{", "Inst", ".", "erase", "(", "Inst", ".", "end", "(", ")", "-", "1", ")", ";", "Size", "=", "0", ";", "}", "}", "bool", "Error", "=", "HexagonMCShuffle", "(", "Context", ",", "true", ",", "*", "MCII", ",", "*", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ")", ";", "(", "void", ")", "Error", ";", "ReplaceInstruction", "(", "Asm", ".", "getEmitter", "(", ")", ",", "RF", ",", "Inst", ")", ";", "Layout", ".", "invalidateFragmentsFrom", "(", "&", "RF", ")", ";", "Size", "=", "0", ";", "break", ";", "}", "}", "}", "}", "}", "}", "}", "}", "</s>" ]

[ "Give", "backend", "an", "opportunity", "to", "finish", "layout", "after", "relaxation", "." ]

[ "Hexagon", "0", "0", "Hexagon", "Hexagon::A2_nop", "4", "Hexagon", "1", "0", "Hexagon", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addPreserved", "(", "\"stack-protector\"", ")", ";", "AU", ".", "addPreserved", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "\"stack-protector\"" ]

[]

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

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

[ "FISC", "FISC", "ISD::OutputArg", "16", "FISC", "8", "1", "0", "\"Can only return in registers!\"", "1", "0", "FISCISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "X86ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "X86Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "X86FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "rip_relative_addr_p", "(", "struct", "ix86_address", "*", "parts", ")", "{", "rtx", "base", ",", "index", ",", "disp", ";", "base", "=", "parts", "->", "base", ";", "index", "=", "parts", "->", "index", ";", "disp", "=", "parts", "->", "disp", ";", "if", "(", "disp", "&&", "!", "base", "&&", "!", "index", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "rtx", "symbol", "=", "disp", ";", "if", "(", "GET_CODE", "(", "disp", ")", "==", "CONST", ")", "symbol", "=", "XEXP", "(", "disp", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "symbol", ",", "1", ")", ")", ")", "symbol", "=", "XEXP", "(", "symbol", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "symbol", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", "==", "0", ")", "||", "(", "GET_CODE", "(", "symbol", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "symbol", ",", "1", ")", "==", "UNSPEC_GOTPCREL", "||", "XINT", "(", "symbol", ",", "1", ")", "==", "UNSPEC_PCREL", "||", "XINT", "(", "symbol", ",", "1", ")", "==", "UNSPEC_GOTNTPOFF", ")", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "x86", "address", "PARTS", "is", "a", "pc-relative", "address", "." ]

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

[]

[ "<s>", "const", "MipsInstrInfo", "*", "getInstrInfo", "(", ")", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "const", "char", "*", "detect_caches_intel", "(", "bool", "xeon_mp", ",", "unsigned", "max_level", ",", "unsigned", "max_ext_level", ",", "unsigned", "*", "l2sizekb", ")", "{", "struct", "cache_desc", "level1", "=", "{", "0", ",", "0", ",", "0", "}", ",", "level2", "=", "{", "0", ",", "0", ",", "0", "}", ",", "level3", "=", "{", "0", ",", "0", ",", "0", "}", ";", "if", "(", "max_level", ">=", "4", ")", "detect_caches_cpuid4", "(", "&", "level1", ",", "&", "level2", ",", "&", "level3", ")", ";", "else", "if", "(", "max_level", ">=", "2", ")", "detect_caches_cpuid2", "(", "xeon_mp", ",", "&", "level1", ",", "&", "level2", ")", ";", "else", "return", "\"\"", ";", "if", "(", "level1", ".", "sizekb", "==", "0", ")", "return", "\"\"", ";", "if", "(", "level3", ".", "sizekb", ")", "level2", "=", "level3", ";", "if", "(", "level2", ".", "sizekb", "==", "0", "&&", "max_ext_level", ">=", "0x80000006", ")", "detect_l2_cache", "(", "&", "level2", ")", ";", "*", "l2sizekb", "=", "level2", ".", "sizekb", ";", "return", "describe_cache", "(", "level1", ",", "level2", ")", ";", "}", "</s>" ]

[ "Returns", "the", "description", "of", "caches", "for", "an", "Intel", "processor", "." ]

[ "i386", "0", "0", "0", "0", "0", "0", "0", "0", "0", "4", "2", "\"\"", "0", "\"\"", "0", "0x80000006" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "Cond", ".", "clear", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "FirstUncondOrIndirectBr", "=", "MBB", ".", "end", "(", ")", ";", "int", "NumTerminators", "=", "0", ";", "for", "(", "auto", "J", "=", "I", ".", "getReverse", "(", ")", ";", "J", "!=", "MBB", ".", "rend", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "J", ")", ";", "J", "++", ")", "{", "NumTerminators", "++", ";", "if", "(", "J", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "||", "J", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "{", "FirstUncondOrIndirectBr", "=", "J", ".", "getReverse", "(", ")", ";", "}", "}", "if", "(", "AllowModify", "&&", "FirstUncondOrIndirectBr", "!=", "MBB", ".", "end", "(", ")", ")", "{", "while", "(", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "!=", "MBB", ".", "end", "(", ")", ")", "{", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "->", "eraseFromParent", "(", ")", ";", "NumTerminators", "--", ";", "}", "I", "=", "FirstUncondOrIndirectBr", ";", "}", "if", "(", "I", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "NumTerminators", ">", "2", ")", "return", "true", ";", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "I", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "2", "&&", "std", "::", "prev", "(", "I", ")", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "std", "::", "prev", "(", "I", ")", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "mmix_override_options", "(", "void", ")", "{", "if", "(", "flag_pic", ")", "{", "warning", "(", "0", ",", "\"-f%s not supported: ignored\"", ",", "(", "flag_pic", ">", "1", ")", "?", "\"PIC\"", ":", "\"pic\"", ")", ";", "flag_pic", "=", "0", ";", "}", "}", "</s>" ]

[ "OVERRIDE_OPTIONS", "." ]

[ "mmix", "0", "\"-f%s not supported: ignored\"", "1", "\"PIC\"", "\"pic\"", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MF", ".", "setAlignment", "(", "8", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "EmitFunctionHeader", "(", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "const", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "ConfigSection", ")", ";", "const", "AMDGPUSubtarget", "&", "STM", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "SIProgramInfo", "KernelInfo", ";", "if", "(", "STM", ".", "isAmdHsaOS", "(", ")", ")", "{", "getSIProgramInfo", "(", "KernelInfo", ",", "MF", ")", ";", "EmitAmdKernelCodeT", "(", "MF", ",", "KernelInfo", ")", ";", "OutStreamer", ".", "EmitCodeAlignment", "(", "2", "<<", "(", "MF", ".", "getAlignment", "(", ")", "-", "1", ")", ")", ";", "}", "else", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "getSIProgramInfo", "(", "KernelInfo", ",", "MF", ")", ";", "EmitProgramInfoSI", "(", "MF", ",", "KernelInfo", ")", ";", "}", "else", "{", "EmitProgramInfoR600", "(", "MF", ")", ";", "}", "DisasmLines", ".", "clear", "(", ")", ";", "HexLines", ".", "clear", "(", ")", ";", "DisasmLineMaxLen", "=", "0", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "EmitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "const", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.csdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "CommentSection", ")", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "OutStreamer", ".", "emitRawComment", "(", "\" Kernel info:\"", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" codeLenInByte = \"", "+", "Twine", "(", "KernelInfo", ".", "CodeLen", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" NumSgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumSGPR", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" NumVgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumVGPR", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" FloatMode: \"", "+", "Twine", "(", "KernelInfo", ".", "FloatMode", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" IeeeMode: \"", "+", "Twine", "(", "KernelInfo", ".", "IEEEMode", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" ScratchSize: \"", "+", "Twine", "(", "KernelInfo", ".", "ScratchSize", ")", ",", "false", ")", ";", "}", "else", "{", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "Twine", "(", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "+", "Twine", "(", "MFI", "->", "StackSize", ")", ")", ")", ";", "}", "}", "if", "(", "STM", ".", "dumpCode", "(", ")", "&&", "DisasmEnabled", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "Context", ".", "getELFSection", "(", "\".AMDGPU.disasm\"", ",", "ELF", "::", "SHT_NOTE", ",", "0", ")", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "DisasmLines", ".", "size", "(", ")", ";", "++", "i", ")", "{", "std", "::", "string", "Comment", "(", "DisasmLineMaxLen", "-", "DisasmLines", "[", "i", "]", ".", "size", "(", ")", ",", "' '", ")", ";", "Comment", "+=", "\" ; \"", "+", "HexLines", "[", "i", "]", "+", "\"\\n\"", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "DisasmLines", "[", "i", "]", ")", ")", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "Comment", ")", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "8", "\".AMDGPU.config\"", "0", "SI", "SI", "2", "1", "SI", "SI", "0", "\".AMDGPU.csdata\"", "0", "\" Kernel info:\"", "\" codeLenInByte = \"", "\" NumSgprs: \"", "\" NumVgprs: \"", "\" FloatMode: \"", "\" IeeeMode: \"", "\" ScratchSize: \"", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "\".AMDGPU.disasm\"", "0", "0", "\" ; \"", "\"\\n\"" ]

[]

[ "<s>", "Candidate", "(", "MachineInstr", "*", "mi", ",", "unsigned", "reg", ",", "unsigned", "subreg", ",", "unsigned", "freebanks", ",", "unsigned", "weight", ")", ":", "MI", "(", "mi", ")", ",", "Reg", "(", "reg", ")", ",", "SubReg", "(", "subreg", ")", ",", "FreeBanks", "(", "freebanks", ")", ",", "Weight", "(", "weight", ")", "{", "}", "</s>" ]

[ "Describes", "the", "region", "of", "code", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createRISCVISelDag", "(", "getRISCVTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "void", "ARMELFStreamer", "::", "Reset", "(", ")", "{", "ExTab", "=", "NULL", ";", "FnStart", "=", "NULL", ";", "Personality", "=", "NULL", ";", "PersonalityIndex", "=", "NUM_PERSONALITY_INDEX", ";", "FPReg", "=", "ARM", "::", "SP", ";", "FPOffset", "=", "0", ";", "SPOffset", "=", "0", ";", "PendingOffset", "=", "0", ";", "UsedFP", "=", "false", ";", "CantUnwind", "=", "false", ";", "Opcodes", ".", "clear", "(", ")", ";", "UnwindOpAsm", ".", "Reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "PULP_HWLOOPS_NAME", ";", "}", "</s>" ]

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

[ "RISCV" ]

[]

[ "<s>", "int", "frv_emit_cond_move", "(", "rtx", "dest", ",", "rtx", "test_rtx", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "rtx", "set", ";", "rtx", "clobber_cc", ";", "rtx", "test2", ";", "rtx", "cr_reg", ";", "rtx", "if_rtx", ";", "enum", "rtx_code", "test", "=", "GET_CODE", "(", "test_rtx", ")", ";", "rtx", "cc_reg", "=", "frv_emit_comparison", "(", "test", ",", "XEXP", "(", "test_rtx", ",", "0", ")", ",", "XEXP", "(", "test_rtx", ",", "1", ")", ")", ";", "machine_mode", "cc_mode", "=", "GET_MODE", "(", "cc_reg", ")", ";", "if", "(", "GET_CODE", "(", "src1", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "src2", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "value1", "=", "INTVAL", "(", "src1", ")", ";", "HOST_WIDE_INT", "value2", "=", "INTVAL", "(", "src2", ")", ";", "if", "(", "value1", "==", "0", "||", "value2", "==", "0", ")", ";", "else", "if", "(", "IN_RANGE", "(", "value1", ",", "-", "2048", ",", "2047", ")", "&&", "IN_RANGE", "(", "value2", "-", "value1", ",", "-", "2048", ",", "2047", ")", ")", ";", "else", "{", "src1", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src1", ")", ";", "src2", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src2", ")", ";", "}", "}", "else", "{", "if", "(", "GET_CODE", "(", "src1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src1", ")", "!=", "0", ")", "src1", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src1", ")", ";", "if", "(", "GET_CODE", "(", "src2", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src2", ")", "!=", "0", ")", "src2", "=", "force_reg", "(", "GET_MODE", "(", "dest", ")", ",", "src2", ")", ";", "}", "test2", "=", "gen_rtx_fmt_ee", "(", "test", ",", "cc_mode", ",", "cc_reg", ",", "const0_rtx", ")", ";", "if_rtx", "=", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dest", ")", ",", "test2", ",", "src1", ",", "src2", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "if_rtx", ")", ";", "cr_reg", "=", "(", "(", "TARGET_ALLOC_CC", ")", "?", "gen_reg_rtx", "(", "CC_CCRmode", ")", ":", "gen_rtx_REG", "(", "CC_CCRmode", ",", "(", "cc_mode", "==", "CC_FPmode", ")", "?", "FCR_FIRST", ":", "ICR_FIRST", ")", ")", ";", "clobber_cc", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "cr_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber_cc", ")", ")", ")", ";", "return", "TRUE", ";", "}", "</s>" ]

[ "Emit", "the", "code", "for", "a", "conditional", "move", ",", "return", "TRUE", "if", "we", "could", "do", "the", "move", "." ]

[ "frv", "0", "1", "0", "0", "2048", "2047", "2048", "2047", "0", "0", "2" ]

[]

[ "<s>", "static", "tree", "mips_build_builtin_va_list", "(", "void", ")", "{", "if", "(", "EABI_FLOAT_VARARGS_P", ")", "{", "tree", "f_ovfl", ",", "f_gtop", ",", "f_ftop", ",", "f_goff", ",", "f_foff", ",", "f_res", ",", "record", ";", "tree", "array", ",", "index", ";", "record", "=", "lang_hooks", ".", "types", ".", "make_type", "(", "RECORD_TYPE", ")", ";", "f_ovfl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__overflow_argptr\"", ")", ",", "ptr_type_node", ")", ";", "f_gtop", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__gpr_top\"", ")", ",", "ptr_type_node", ")", ";", "f_ftop", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__fpr_top\"", ")", ",", "ptr_type_node", ")", ";", "f_goff", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__gpr_offset\"", ")", ",", "unsigned_char_type_node", ")", ";", "f_foff", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__fpr_offset\"", ")", ",", "unsigned_char_type_node", ")", ";", "index", "=", "build_int_cst", "(", "NULL_TREE", ",", "GET_MODE_SIZE", "(", "ptr_mode", ")", "-", "2", "-", "1", ")", ";", "array", "=", "build_array_type", "(", "unsigned_char_type_node", ",", "build_index_type", "(", "index", ")", ")", ";", "f_res", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__reserved\"", ")", ",", "array", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_ovfl", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_gtop", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ftop", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_goff", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_foff", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_res", ")", "=", "record", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_ovfl", ";", "DECL_CHAIN", "(", "f_ovfl", ")", "=", "f_gtop", ";", "DECL_CHAIN", "(", "f_gtop", ")", "=", "f_ftop", ";", "DECL_CHAIN", "(", "f_ftop", ")", "=", "f_goff", ";", "DECL_CHAIN", "(", "f_goff", ")", "=", "f_foff", ";", "DECL_CHAIN", "(", "f_foff", ")", "=", "f_res", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "else", "return", "ptr_type_node", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", ".", "We", "keep", "3", "pointers", ",", "and", "two", "offsets", ".", "Two", "pointers", "are", "to", "the", "overflow", "area", ",", "which", "starts", "at", "the", "CFA", ".", "One", "of", "these", "is", "constant", ",", "for", "addressing", "into", "the", "GPR", "save", "area", "below", "it", ".", "The", "other", "is", "advanced", "up", "the", "stack", "through", "the", "overflow", "region", ".", "The", "third", "pointer", "is", "to", "the", "GPR", "save", "area", ".", "Since", "the", "FPR", "save", "area", "is", "just", "below", "it", ",", "we", "can", "address", "FPR", "slots", "off", "this", "pointer", ".", "We", "also", "keep", "two", "one-byte", "offsets", ",", "which", "are", "to", "be", "subtracted", "from", "the", "constant", "pointers", "to", "yield", "addresses", "in", "the", "GPR", "and", "FPR", "save", "areas", ".", "These", "are", "downcounted", "as", "float", "or", "non-float", "arguments", "are", "used", ",", "and", "when", "they", "get", "to", "zero", ",", "the", "argument", "must", "be", "obtained", "from", "the", "overflow", "region", ".", "If", "!", "EABI_FLOAT_VARARGS_P", ",", "then", "no", "FPR", "save", "area", "exists", ",", "and", "a", "single", "pointer", "is", "enough", ".", "It", "'s", "started", "at", "the", "GPR", "save", "area", ",", "and", "is", "advanced", ",", "period", ".", "Note", "that", "the", "GPR", "save", "area", "is", "not", "constant", "size", ",", "due", "to", "optimization", "in", "the", "prologue", ".", "Hence", ",", "we", "ca", "n't", "use", "a", "design", "with", "two", "pointers", "and", "two", "offsets", ",", "although", "we", "could", "have", "designed", "this", "with", "two", "pointers", "and", "three", "offsets", "." ]

[ "mips", "\"__overflow_argptr\"", "\"__gpr_top\"", "\"__fpr_top\"", "\"__gpr_offset\"", "\"__fpr_offset\"", "2", "1", "\"__reserved\"" ]

[]

[ "<s>", "bool", "mips_dangerous_for_la25_p", "(", "rtx", "x", ")", "{", "return", "(", "!", "TARGET_EXPLICIT_RELOCS", "&&", "TARGET_USE_GOT", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "mips_global_symbol_p", "(", "x", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "should", "not", "be", "moved", "directly", "into", "register", "$", "25", ".", "We", "need", "this", "because", "many", "versions", "of", "GAS", "will", "treat", "``", "la", "$", "25", ",", "foo", "''", "as", "part", "of", "a", "call", "sequence", "and", "so", "allow", "a", "global", "``", "foo", "''", "to", "be", "lazily", "bound", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "AArch64_MC", "::", "isQForm", "(", "const", "MCInst", "&", "MI", ",", "const", "MCInstrInfo", "*", "MCII", ")", "{", "const", "auto", "&", "FPR128", "=", "AArch64MCRegisterClasses", "[", "AArch64", "::", "FPR128RegClassID", "]", ";", "return", "llvm", "::", "any_of", "(", "MI", ",", "[", "&", "]", "(", "const", "MCOperand", "&", "Op", ")", "{", "return", "Op", ".", "isReg", "(", ")", "&&", "FPR128", ".", "contains", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "in", "Q", "form", "(", "128", "bit", "operands", ")" ]

[ "AArch64", "AArch64", "AArch64", "AArch64::FPR128RegClassID" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "KnownOne", ".", "getBitWidth", "(", ")", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "BitWidth", ",", "0", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARMISD", "::", "ADDC", ":", "case", "ARMISD", "::", "ADDE", ":", "case", "ARMISD", "::", "SUBC", ":", "case", "ARMISD", "::", "SUBE", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", "break", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "1", ")", ";", "break", ";", "case", "ARMISD", "::", "CMOV", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "1", ")", ";", "if", "(", "KnownZero", "==", "0", "&&", "KnownOne", "==", "0", ")", "return", ";", "APInt", "KnownZeroRHS", ",", "KnownOneRHS", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZeroRHS", ",", "KnownOneRHS", ",", "Depth", "+", "1", ")", ";", "KnownZero", "&=", "KnownZeroRHS", ";", "KnownOne", "&=", "KnownOneRHS", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "arm_ldaex", ":", "case", "Intrinsic", "::", "arm_ldrex", ":", "{", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "ARM", "ARM", "0", "ARMISD::ADDC", "ARMISD::ADDE", "ARMISD::SUBC", "ARMISD::SUBE", "0", "1", "ARMISD::CMOV", "0", "1", "0", "0", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex" ]

[]

[ "<s>", "void", "VideoCore4InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "MEM32_ST_LI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "VideoCore4", "VideoCore4", "VideoCore4::MEM32_ST_LI", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "PPCHazardRecognizer970", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"PPC hazards don't support scoreboard lookahead\"", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isDebugInstr", "(", ")", ")", "return", "NoHazard", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "PPCII", "::", "PPC970_Unit", "InstrType", "=", "GetInstrType", "(", "Opcode", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_Pseudo", ")", "return", "NoHazard", ";", "if", "(", "NumIssued", "!=", "0", "&&", "(", "isFirst", "||", "isSingle", ")", ")", "return", "Hazard", ";", "if", "(", "isCracked", "&&", "NumIssued", ">", "2", ")", "return", "Hazard", ";", "switch", "(", "InstrType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown instruction type!\"", ")", ";", "case", "PPCII", "::", "PPC970_FXU", ":", "case", "PPCII", "::", "PPC970_LSU", ":", "case", "PPCII", "::", "PPC970_FPU", ":", "case", "PPCII", "::", "PPC970_VALU", ":", "case", "PPCII", "::", "PPC970_VPERM", ":", "if", "(", "NumIssued", "==", "4", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_CRU", ":", "if", "(", "NumIssued", ">=", "2", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_BRU", ":", "break", ";", "}", "if", "(", "HasCTRSet", "&&", "Opcode", "==", "PPC", "::", "BCTRL", ")", "return", "NoopHazard", ";", "if", "(", "isLoad", "&&", "NumStores", "&&", "!", "MI", "->", "memoperands_empty", "(", ")", ")", "{", "MachineMemOperand", "*", "MO", "=", "*", "MI", "->", "memoperands_begin", "(", ")", ";", "if", "(", "isLoadOfStoredAddress", "(", "MO", "->", "getSize", "(", ")", ",", "MO", "->", "getOffset", "(", ")", ",", "MO", "->", "getValue", "(", ")", ")", ")", "return", "NoopHazard", ";", "}", "return", "NoHazard", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "\"PPC hazards don't support scoreboard lookahead\"", "PPCII::PPC970_Unit", "PPCII::PPC970_Pseudo", "0", "2", "\"Unknown instruction type!\"", "PPCII::PPC970_FXU", "PPCII::PPC970_LSU", "PPCII::PPC970_FPU", "PPCII::PPC970_VALU", "PPCII::PPC970_VPERM", "4", "PPCII::PPC970_CRU", "2", "PPCII::PPC970_BRU", "PPC::BCTRL" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "getGlobalBaseReg", "(", ")", "==", "0", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "STI", ".", "isThumb1Only", "(", ")", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "LLVMContext", "*", "Context", "=", "&", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "unsigned", "ARMPCLabelIndex", "=", "AFI", "->", "createPICLabelUId", "(", ")", ";", "unsigned", "PCAdj", "=", "STI", ".", "isThumb", "(", ")", "?", "4", ":", "8", ";", "ARMConstantPoolValue", "*", "CPV", "=", "ARMConstantPoolSymbol", "::", "Create", "(", "*", "Context", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "ARMPCLabelIndex", ",", "PCAdj", ")", ";", "unsigned", "Align", "=", "MF", ".", "getDataLayout", "(", ")", ".", "getPrefTypeAlignment", "(", "Type", "::", "getInt32PtrTy", "(", "*", "Context", ")", ")", ";", "unsigned", "Idx", "=", "MF", ".", "getConstantPool", "(", ")", "->", "getConstantPoolIndex", "(", "CPV", ",", "Align", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "unsigned", "TempReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "ARM", "::", "rGPRRegClass", ")", ";", "unsigned", "Opc", "=", "STI", ".", "isThumb2", "(", ")", "?", "ARM", "::", "t2LDRpci", ":", "ARM", "::", "LDRcp", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "TempReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "LDRcp", ")", "MIB", ".", "addImm", "(", "0", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "unsigned", "GlobalBaseReg", "=", "AFI", "->", "getGlobalBaseReg", "(", ")", ";", "Opc", "=", "STI", ".", "isThumb2", "(", ")", "?", "ARM", "::", "tPICADD", ":", "ARM", "::", "PICADD", ";", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ")", ".", "addImm", "(", "ARMPCLabelIndex", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "PICADD", ")", "AddDefaultPred", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "0", "ARM", "ARM", "ARM", "4", "8", "ARM", "ARM", "\"_GLOBAL_OFFSET_TABLE_\"", "ARM", "ARM::rGPRRegClass", "ARM::t2LDRpci", "ARM::LDRcp", "ARM::LDRcp", "0", "ARM::tPICADD", "ARM::PICADD", "ARM", "ARM::PICADD" ]

[]

[ "<s>", "virtual", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

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

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32", ":", "break", ";", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v16i8", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v8i16", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4i32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4f32", ":", "{", "assert", "(", "MFI", "->", "isVRegStackified", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return: $pop\"", "+", "Twine", "(", "MFI", "->", "getWARegStackId", "(", "MFI", "->", "getWAReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ")", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "}", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_VOID", ":", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "WebAssembly::ARGUMENT_v16i8", "WebAssembly::ARGUMENT_v8i16", "WebAssembly::ARGUMENT_v4i32", "WebAssembly::ARGUMENT_v4f32", "WebAssembly::FALLTHROUGH_RETURN_I32", "WebAssembly::FALLTHROUGH_RETURN_I64", "WebAssembly::FALLTHROUGH_RETURN_F32", "WebAssembly::FALLTHROUGH_RETURN_F64", "WebAssembly::FALLTHROUGH_RETURN_v16i8", "WebAssembly::FALLTHROUGH_RETURN_v8i16", "WebAssembly::FALLTHROUGH_RETURN_v4i32", "WebAssembly::FALLTHROUGH_RETURN_v4f32", "0", "\"fallthrough-return: $pop\"", "0", "WebAssembly::FALLTHROUGH_RETURN_VOID", "\"fallthrough-return\"", "WebAssembly" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "TPCOperand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "int", "RegClassNo", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ")", "{", "auto", "Res", "=", "std", "::", "make_unique", "<", "TPCOperand", ">", "(", "OpKind", "::", "Reg", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Reg", ".", "Num", "=", "RegNo", ";", "Res", "->", "Reg", ".", "Class", "=", "RegClassNo", ";", "return", "Res", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "const", "char", "*", "mips_output_sync", "(", "void", ")", "{", "mips_start_ll_sc_sync_block", "(", ")", ";", "output_asm_insn", "(", "\"sync\"", ",", "0", ")", ";", "mips_end_ll_sc_sync_block", "(", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "and/or", "return", "the", "asm", "template", "for", "a", "sync", "instruction", "." ]

[ "mips", "\"sync\"", "0", "\"\"" ]

[]

[ "<s>", "static", "inline", "unsigned", "long", "ia64_rse_is_rnat_slot", "(", "unsigned", "long", "*", "addr", ")", "{", "return", "ia64_rse_slot_num", "(", "addr", ")", "==", "0x3f", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "ADDR", "is", "the", "address", "of", "an", "RNAT", "slot", "." ]

[ "ia64", "0x3f" ]

[]

[ "<s>", "bool", "isTarget64BitILP32", "(", ")", "const", "{", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUX32", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "ILP32", "programming", "model", "(", "x32", "ABI", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "rtx", "expand", "(", "function_expander", "&", "e", ")", "const", "override", "{", "return", "e", ".", "use_exact_insn", "(", "CODE_FOR_aarch64_wrffr", ")", ";", "}", "</s>" ]

[ "Expand", "the", "call", "and", "return", "its", "lhs", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "NVPTXTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Constraint", ".", "length", "(", ")", ">", "1", ")", "return", ";", "else", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

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

[]

[ "<s>", "static", "void", "sparc_emit_set_const64_longway", "(", "rtx", "op0", ",", "rtx", "temp", ",", "unsigned", "HOST_WIDE_INT", "high_bits", ",", "unsigned", "HOST_WIDE_INT", "low_bits", ")", "{", "rtx", "sub_temp", "=", "op0", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "sub_temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "(", "high_bits", "&", "0xfffffc00", ")", "!=", "0", ")", "{", "emit_insn", "(", "gen_safe_HIGH64", "(", "temp", ",", "high_bits", ")", ")", ";", "if", "(", "(", "high_bits", "&", "~", "0xfffffc00", ")", "!=", "0", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "sub_temp", ",", "gen_safe_OR64", "(", "temp", ",", "(", "high_bits", "&", "0x3ff", ")", ")", ")", ")", ";", "else", "sub_temp", "=", "temp", ";", "}", "else", "{", "emit_insn", "(", "gen_safe_SET64", "(", "temp", ",", "high_bits", ")", ")", ";", "sub_temp", "=", "temp", ";", "}", "if", "(", "can_create_pseudo_p", "(", ")", ")", "{", "rtx", "temp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "temp3", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "temp4", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp4", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "32", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_safe_HIGH64", "(", "temp2", ",", "low_bits", ")", ")", ";", "if", "(", "(", "low_bits", "&", "~", "0xfffffc00", ")", "!=", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp3", ",", "gen_safe_OR64", "(", "temp2", ",", "(", "low_bits", "&", "0x3ff", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_PLUS", "(", "DImode", ",", "temp4", ",", "temp3", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_PLUS", "(", "DImode", ",", "temp4", ",", "temp2", ")", ")", ")", ";", "}", "}", "else", "{", "rtx", "low1", "=", "GEN_INT", "(", "(", "low_bits", ">>", "(", "32", "-", "12", ")", ")", "&", "0xfff", ")", ";", "rtx", "low2", "=", "GEN_INT", "(", "(", "low_bits", ">>", "(", "32", "-", "12", "-", "12", ")", ")", "&", "0xfff", ")", ";", "rtx", "low3", "=", "GEN_INT", "(", "(", "low_bits", ">>", "(", "32", "-", "12", "-", "12", "-", "8", ")", ")", "&", "0x0ff", ")", ";", "int", "to_shift", "=", "12", ";", "if", "(", "low1", "!=", "const0_rtx", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "to_shift", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_IOR", "(", "DImode", ",", "op0", ",", "low1", ")", ")", ")", ";", "sub_temp", "=", "op0", ";", "to_shift", "=", "12", ";", "}", "else", "{", "to_shift", "+=", "12", ";", "}", "if", "(", "low2", "!=", "const0_rtx", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "to_shift", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_IOR", "(", "DImode", ",", "op0", ",", "low2", ")", ")", ")", ";", "sub_temp", "=", "op0", ";", "to_shift", "=", "8", ";", "}", "else", "{", "to_shift", "+=", "8", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "sub_temp", ",", "GEN_INT", "(", "to_shift", ")", ")", ")", ")", ";", "if", "(", "low3", "!=", "const0_rtx", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_IOR", "(", "DImode", ",", "op0", ",", "low3", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Full", "64-bit", "constant", "decomposition", ".", "Even", "though", "this", "is", "the", "'worst", "'", "case", ",", "we", "still", "optimize", "a", "few", "things", "away", "." ]

[ "sparc", "0xfffffc00", "0", "0xfffffc00", "0", "0x3ff", "32", "0xfffffc00", "0", "0x3ff", "32", "12", "0xfff", "32", "12", "12", "0xfff", "32", "12", "12", "8", "0x0ff", "12", "12", "12", "8", "8" ]

[]

[ "<s>", "int", "RISCVTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "bool", "Takes12BitImm", "=", "false", ";", "unsigned", "ImmArgIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "GetElementPtr", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "Mul", ":", "Takes12BitImm", "=", "true", ";", "break", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "Takes12BitImm", "=", "true", ";", "ImmArgIdx", "=", "1", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Takes12BitImm", ")", "{", "if", "(", "Instruction", "::", "isCommutative", "(", "Opcode", ")", "||", "Idx", "==", "ImmArgIdx", ")", "{", "if", "(", "Imm", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "getTLI", "(", ")", "->", "isLegalAddImmediate", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "return", "TTI", "::", "TCC_Free", ";", "}", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "return", "TTI", "::", "TCC_Free", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "0U", "1", "64" ]

[]

[ "<s>", "void", "XtensaFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "false", "&&", "\"XtensaFrameLowering::emitEpilogue not implemented\"", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"XtensaFrameLowering::emitEpilogue not implemented\"" ]

[]

[ "<s>", "static", "bool", "is_store_insn1", "(", "rtx", "pat", ",", "rtx", "*", "str_mem", ")", "{", "if", "(", "!", "pat", "||", "pat", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "if", "(", "REG_P", "(", "SET_SRC", "(", "pat", ")", ")", "||", "SUBREG_P", "(", "SET_SRC", "(", "pat", ")", ")", ")", "return", "find_mem_ref", "(", "SET_DEST", "(", "pat", ")", ",", "str_mem", ")", ";", "else", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "is_store_insn1", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ",", "str_mem", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Determine", "if", "PAT", "is", "a", "PATTERN", "of", "a", "store", "insn", "." ]

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

[]

[ "<s>", "static", "tree", "va_list_skip_additions", "(", "tree", "lhs", ")", "{", "tree", "rhs", ",", "stmt", ";", "if", "(", "TREE_CODE", "(", "lhs", ")", "!=", "SSA_NAME", ")", "return", "lhs", ";", "for", "(", ";", ";", ")", "{", "stmt", "=", "SSA_NAME_DEF_STMT", "(", "lhs", ")", ";", "if", "(", "TREE_CODE", "(", "stmt", ")", "==", "PHI_NODE", ")", "return", "stmt", ";", "if", "(", "TREE_CODE", "(", "stmt", ")", "!=", "MODIFY_EXPR", "||", "TREE_OPERAND", "(", "stmt", ",", "0", ")", "!=", "lhs", ")", "return", "lhs", ";", "rhs", "=", "TREE_OPERAND", "(", "stmt", ",", "1", ")", ";", "if", "(", "TREE_CODE", "(", "rhs", ")", "==", "WITH_SIZE_EXPR", ")", "rhs", "=", "TREE_OPERAND", "(", "rhs", ",", "0", ")", ";", "if", "(", "(", "TREE_CODE", "(", "rhs", ")", "!=", "NOP_EXPR", "&&", "TREE_CODE", "(", "rhs", ")", "!=", "CONVERT_EXPR", "&&", "(", "TREE_CODE", "(", "rhs", ")", "!=", "PLUS_EXPR", "||", "TREE_CODE", "(", "TREE_OPERAND", "(", "rhs", ",", "1", ")", ")", "!=", "INTEGER_CST", "||", "!", "host_integerp", "(", "TREE_OPERAND", "(", "rhs", ",", "1", ")", ",", "1", ")", ")", ")", "||", "TREE_CODE", "(", "TREE_OPERAND", "(", "rhs", ",", "0", ")", ")", "!=", "SSA_NAME", ")", "return", "rhs", ";", "lhs", "=", "TREE_OPERAND", "(", "rhs", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "alpha_stdarg_optimize_hook", ".", "Skip", "over", "casts", "and", "constant", "additions", "." ]

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

[]

[ "<s>", "int", "direct_return", "(", "void", ")", "{", "if", "(", "reload_completed", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "info", "->", "first_gp_reg_save", "==", "32", "&&", "info", "->", "first_fp_reg_save", "==", "64", "&&", "info", "->", "first_altivec_reg_save", "==", "LAST_ALTIVEC_REGNO", "+", "1", "&&", "!", "info", "->", "lr_save_p", "&&", "!", "info", "->", "cr_save_p", "&&", "info", "->", "vrsave_size", "==", "0", "&&", "!", "info", "->", "push_p", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "." ]

[ "powerpcspe", "32", "64", "1", "0", "1", "0" ]

[]

[ "<s>", "inline", "static", "rtx_insn", "*", "emit_set_insn", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "return", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x", ",", "y", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "insn", "that", "'s", "a", "simple", "single-set", ".", "Both", "the", "operands", "must", "be", "known", "to", "be", "valid", "." ]

[ "arm" ]

[]

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

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

[ "Z80", "Z80" ]

[]

[ "<s>", "static", "void", "rs6000_file_start", "(", "void", ")", "{", "char", "buffer", "[", "80", "]", ";", "const", "char", "*", "start", "=", "buffer", ";", "FILE", "*", "file", "=", "asm_out_file", ";", "rs6000_default_cpu", "=", "TARGET_CPU_DEFAULT", ";", "default_file_start", "(", ")", ";", "if", "(", "flag_verbose_asm", ")", "{", "sprintf", "(", "buffer", ",", "\"\\n%s rs6000/powerpc options:\"", ",", "ASM_COMMENT_START", ")", ";", "if", "(", "rs6000_default_cpu", "!=", "0", "&&", "rs6000_default_cpu", "[", "0", "]", "!=", "'\\0'", ")", "{", "fprintf", "(", "file", ",", "\"%s --with-cpu=%s\"", ",", "start", ",", "rs6000_default_cpu", ")", ";", "start", "=", "\"\"", ";", "}", "if", "(", "OPTION_SET_P", "(", "rs6000_cpu_index", ")", ")", "{", "fprintf", "(", "file", ",", "\"%s -mcpu=%s\"", ",", "start", ",", "processor_target_table", "[", "rs6000_cpu_index", "]", ".", "name", ")", ";", "start", "=", "\"\"", ";", "}", "if", "(", "OPTION_SET_P", "(", "rs6000_tune_index", ")", ")", "{", "fprintf", "(", "file", ",", "\"%s -mtune=%s\"", ",", "start", ",", "processor_target_table", "[", "rs6000_tune_index", "]", ".", "name", ")", ";", "start", "=", "\"\"", ";", "}", "if", "(", "PPC405_ERRATUM77", ")", "{", "fprintf", "(", "file", ",", "\"%s PPC405CR_ERRATUM77\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "}", "switch", "(", "rs6000_sdata", ")", "{", "case", "SDATA_NONE", ":", "fprintf", "(", "file", ",", "\"%s -msdata=none\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "case", "SDATA_DATA", ":", "fprintf", "(", "file", ",", "\"%s -msdata=data\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "case", "SDATA_SYSV", ":", "fprintf", "(", "file", ",", "\"%s -msdata=sysv\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "case", "SDATA_EABI", ":", "fprintf", "(", "file", ",", "\"%s -msdata=eabi\"", ",", "start", ")", ";", "start", "=", "\"\"", ";", "break", ";", "}", "if", "(", "rs6000_sdata", "&&", "g_switch_value", ")", "{", "fprintf", "(", "file", ",", "\"%s -G %d\"", ",", "start", ",", "g_switch_value", ")", ";", "start", "=", "\"\"", ";", "}", "if", "(", "*", "start", "==", "'\\0'", ")", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "rs6000_machine", "=", "rs6000_machine_from_flags", "(", ")", ";", "emit_asm_machine", "(", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "fprintf", "(", "file", ",", "\"\\t.abiversion 2\\n\"", ")", ";", "}", "</s>" ]

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

[ "rs6000", "80", "\"\\n%s rs6000/powerpc options:\"", "0", "0", "\"%s --with-cpu=%s\"", "\"\"", "\"%s -mcpu=%s\"", "\"\"", "\"%s -mtune=%s\"", "\"\"", "\"%s PPC405CR_ERRATUM77\"", "\"\"", "\"%s -msdata=none\"", "\"\"", "\"%s -msdata=data\"", "\"\"", "\"%s -msdata=sysv\"", "\"\"", "\"%s -msdata=eabi\"", "\"\"", "\"%s -G %d\"", "\"\"", "\"\\t.abiversion 2\\n\"" ]

[]

[ "<s>", "static", "void", "riscv_option_override", "(", "void", ")", "{", "const", "struct", "riscv_cpu_info", "*", "cpu", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "flag_pcc_struct_return", "=", "0", ";", "if", "(", "flag_pic", ")", "g_switch_value", "=", "0", ";", "if", "(", "TARGET_MUL", "&&", "(", "target_flags_explicit", "&", "MASK_DIV", ")", "==", "0", ")", "target_flags", "|=", "MASK_DIV", ";", "else", "if", "(", "!", "TARGET_MUL", "&&", "TARGET_DIV", ")", "error", "(", "\"-mdiv requires -march to subsume the %<M%> extension\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "(", "target_flags_explicit", "&", "MASK_FDIV", ")", "==", "0", ")", "target_flags", "|=", "MASK_FDIV", ";", "cpu", "=", "riscv_parse_cpu", "(", "riscv_tune_string", "?", "riscv_tune_string", ":", "RISCV_TUNE_STRING_DEFAULT", ")", ";", "tune_info", "=", "optimize_size", "?", "&", "optimize_size_tune_info", ":", "cpu", "->", "tune_info", ";", "if", "(", "riscv_branch_cost", "==", "0", ")", "riscv_branch_cost", "=", "tune_info", "->", "branch_cost", ";", "init_machine_status", "=", "&", "riscv_init_machine_status", ";", "if", "(", "flag_pic", ")", "riscv_cmodel", "=", "CM_PIC", ";", "if", "(", "(", "target_flags_explicit", "&", "MASK_EXPLICIT_RELOCS", ")", "==", "0", ")", "if", "(", "riscv_cmodel", "==", "CM_MEDLOW", ")", "target_flags", "|=", "MASK_EXPLICIT_RELOCS", ";", "if", "(", "UNITS_PER_FP_ARG", ">", "(", "TARGET_HARD_FLOAT", "?", "UNITS_PER_FP_REG", ":", "0", ")", ")", "error", "(", "\"requested ABI requires -march to subsume the %qc extension\"", ",", "UNITS_PER_FP_ARG", ">", "8", "?", "'Q'", ":", "(", "UNITS_PER_FP_ARG", ">", "4", "?", "'D'", ":", "'F'", ")", ")", ";", "if", "(", "BITS_PER_WORD", "!=", "POINTER_SIZE", ")", "error", "(", "\"ABI requires -march=rv%d\"", ",", "POINTER_SIZE", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "riscv", "0", "0", "0", "\"-mdiv requires -march to subsume the %<M%> extension\"", "0", "0", "0", "0", "\"requested ABI requires -march to subsume the %qc extension\"", "8", "4", "\"ABI requires -march=rv%d\"" ]

[]

[ "<s>", "bool", "ix86_force_load_from_GOT_p", "(", "rtx", "x", ")", "{", "return", "(", "(", "TARGET_64BIT", "||", "(", "!", "flag_pic", "&&", "HAVE_AS_IX86_GOT32X", ")", ")", "&&", "!", "TARGET_PECOFF", "&&", "!", "TARGET_MACHO", "&&", "(", "!", "flag_pic", "||", "this_is_asm_operands", ")", "&&", "ix86_cmodel", "!=", "CM_LARGE", "&&", "ix86_cmodel", "!=", "CM_LARGE_PIC", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "x", ")", "&&", "(", "!", "flag_plt", "||", "(", "SYMBOL_REF_DECL", "(", "x", ")", "&&", "lookup_attribute", "(", "\"noplt\"", ",", "DECL_ATTRIBUTES", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ")", ")", ")", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "function", "symbol", "operand", "X", "should", "be", "loaded", "from", "GOT", ".", "NB", ":", "In", "32-bit", "mode", ",", "only", "non-PIC", "is", "allowed", "in", "inline", "assembly", "statements", ",", "since", "a", "PIC", "register", "could", "not", "be", "available", "at", "the", "call", "site", "." ]

[ "i386", "\"noplt\"" ]

[]

[ "<s>", "const", "MipsFrameLowering", "*", "MipsFrameLowering", "::", "create", "(", "MipsTargetMachine", "&", "TM", ",", "const", "MipsSubtarget", "&", "ST", ")", "{", "if", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "inMips16Mode", "(", ")", ")", "return", "llvm", "::", "createMips16FrameLowering", "(", "ST", ")", ";", "return", "llvm", "::", "createMipsSEFrameLowering", "(", "ST", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "mips_seq_time", "(", "struct", "mips_sim", "*", "state", ",", "rtx_insn", "*", "seq", ")", "{", "mips_sim_reset", "(", "state", ")", ";", "for", "(", "rtx_insn", "*", "insn", "=", "seq", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "mips_sim_wait_insn", "(", "state", ",", "insn", ")", ";", "mips_sim_issue_insn", "(", "state", ",", "insn", ")", ";", "}", "return", "state", "->", "time", ";", "}", "</s>" ]

[ "Use", "simulator", "state", "STATE", "to", "calculate", "the", "execution", "time", "of", "instruction", "sequence", "SEQ", "." ]

[ "mips" ]

[]

[ "<s>", "static", "gen_func_t", "get_spec_load_gen_function", "(", "ds_t", "ts", ",", "int", "mode_no", ")", "{", "static", "gen_func_t", "gen_ld_", "[", "]", "=", "{", "gen_movbi", ",", "gen_movqi_internal", ",", "gen_movhi_internal", ",", "gen_movsi_internal", ",", "gen_movdi_internal", ",", "gen_movsf_internal", ",", "gen_movdf_internal", ",", "gen_movxf_internal", ",", "gen_movti_internal", ",", "gen_zero_extendqidi2", ",", "gen_zero_extendhidi2", ",", "gen_zero_extendsidi2", ",", "}", ";", "static", "gen_func_t", "gen_ld_a", "[", "]", "=", "{", "gen_movbi_advanced", ",", "gen_movqi_advanced", ",", "gen_movhi_advanced", ",", "gen_movsi_advanced", ",", "gen_movdi_advanced", ",", "gen_movsf_advanced", ",", "gen_movdf_advanced", ",", "gen_movxf_advanced", ",", "gen_movti_advanced", ",", "gen_zero_extendqidi2_advanced", ",", "gen_zero_extendhidi2_advanced", ",", "gen_zero_extendsidi2_advanced", ",", "}", ";", "static", "gen_func_t", "gen_ld_s", "[", "]", "=", "{", "gen_movbi_speculative", ",", "gen_movqi_speculative", ",", "gen_movhi_speculative", ",", "gen_movsi_speculative", ",", "gen_movdi_speculative", ",", "gen_movsf_speculative", ",", "gen_movdf_speculative", ",", "gen_movxf_speculative", ",", "gen_movti_speculative", ",", "gen_zero_extendqidi2_speculative", ",", "gen_zero_extendhidi2_speculative", ",", "gen_zero_extendsidi2_speculative", ",", "}", ";", "static", "gen_func_t", "gen_ld_sa", "[", "]", "=", "{", "gen_movbi_speculative_advanced", ",", "gen_movqi_speculative_advanced", ",", "gen_movhi_speculative_advanced", ",", "gen_movsi_speculative_advanced", ",", "gen_movdi_speculative_advanced", ",", "gen_movsf_speculative_advanced", ",", "gen_movdf_speculative_advanced", ",", "gen_movxf_speculative_advanced", ",", "gen_movti_speculative_advanced", ",", "gen_zero_extendqidi2_speculative_advanced", ",", "gen_zero_extendhidi2_speculative_advanced", ",", "gen_zero_extendsidi2_speculative_advanced", ",", "}", ";", "static", "gen_func_t", "gen_ld_s_a", "[", "]", "=", "{", "gen_movbi_speculative_a", ",", "gen_movqi_speculative_a", ",", "gen_movhi_speculative_a", ",", "gen_movsi_speculative_a", ",", "gen_movdi_speculative_a", ",", "gen_movsf_speculative_a", ",", "gen_movdf_speculative_a", ",", "gen_movxf_speculative_a", ",", "gen_movti_speculative_a", ",", "gen_zero_extendqidi2_speculative_a", ",", "gen_zero_extendhidi2_speculative_a", ",", "gen_zero_extendsidi2_speculative_a", ",", "}", ";", "gen_func_t", "*", "gen_ld", ";", "if", "(", "ts", "&", "BEGIN_DATA", ")", "{", "if", "(", "ts", "&", "BEGIN_CONTROL", ")", "gen_ld", "=", "gen_ld_sa", ";", "else", "gen_ld", "=", "gen_ld_a", ";", "}", "else", "if", "(", "ts", "&", "BEGIN_CONTROL", ")", "{", "if", "(", "(", "spec_info", "->", "flags", "&", "SEL_SCHED_SPEC_DONT_CHECK_CONTROL", ")", "||", "ia64_needs_block_p", "(", "ts", ")", ")", "gen_ld", "=", "gen_ld_s", ";", "else", "gen_ld", "=", "gen_ld_s_a", ";", "}", "else", "if", "(", "ts", "==", "0", ")", "gen_ld", "=", "gen_ld_", ";", "else", "gcc_unreachable", "(", ")", ";", "return", "gen_ld", "[", "mode_no", "]", ";", "}", "</s>" ]

[ "Return", "a", "function", "that", "will", "generate", "a", "load", "of", "mode", "MODE_NO", "with", "speculation", "types", "TS", "." ]

[ "ia64", "0" ]

[]

[ "<s>", "void", "ARMHazardRecognizer", "::", "RecedeCycle", "(", ")", "{", "llvm_unreachable", "(", "\"reverse ARM hazard checking unsupported\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"reverse ARM hazard checking unsupported\"" ]

[]

[ "<s>", "static", "bool", "avr_decl_maybe_lds_p", "(", "tree", "node", ")", "{", "if", "(", "!", "node", "||", "TREE_CODE", "(", "node", ")", "!=", "VAR_DECL", "||", "DECL_SECTION_NAME", "(", "node", ")", "!=", "NULL", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "node", ")", ")", "return", "false", ";", "do", "node", "=", "TREE_TYPE", "(", "node", ")", ";", "while", "(", "ARRAY_TYPE", "==", "TREE_CODE", "(", "node", ")", ")", ";", "return", "(", "node", "!=", "error_mark_node", "&&", "!", "TYPE_READONLY", "(", "node", ")", ")", ";", "}", "</s>" ]

[ "A", "helper", "for", "the", "next", "function", ".", "NODE", "is", "a", "decl", "that", "is", "associated", "with", "a", "symbol", ".", "Return", "TRUE", "if", "the", "respective", "object", "may", "be", "accessed", "by", "LDS", ".", "There", "might", "still", "be", "other", "reasons", "for", "why", "LDS", "is", "not", "appropriate", ".", "This", "function", "is", "only", "appropriate", "for", "AVR_TINY", "." ]

[ "avr" ]

[]

[ "<s>", "TargetLoweringBase", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "unsigned", "Size", "=", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", "!=", "128", "||", "isOpSuitableForLDPSTP", "(", "SI", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "Expand", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "rs6000_sched_finish", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ")", "{", "int", "n_groups", ";", "if", "(", "sched_verbose", ")", "fprintf", "(", "dump", ",", "\"=== Finishing schedule.\\n\"", ")", ";", "if", "(", "reload_completed", "&&", "rs6000_sched_groups", ")", "{", "if", "(", "rs6000_sched_insert_nops", "==", "sched_finish_none", ")", "return", ";", "if", "(", "rs6000_sched_insert_nops", "==", "sched_finish_pad_groups", ")", "n_groups", "=", "pad_groups", "(", "dump", ",", "sched_verbose", ",", "current_sched_info", "->", "prev_head", ",", "current_sched_info", "->", "next_tail", ")", ";", "else", "n_groups", "=", "redefine_groups", "(", "dump", ",", "sched_verbose", ",", "current_sched_info", "->", "prev_head", ",", "current_sched_info", "->", "next_tail", ")", ";", "if", "(", "sched_verbose", ">=", "6", ")", "{", "fprintf", "(", "dump", ",", "\"ngroups = %d\\n\"", ",", "n_groups", ")", ";", "print_rtl", "(", "dump", ",", "current_sched_info", "->", "prev_head", ")", ";", "fprintf", "(", "dump", ",", "\"Done finish_sched\\n\"", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "following", "function", "is", "called", "at", "the", "end", "of", "scheduling", "BB", ".", "After", "reload", ",", "it", "inserts", "nops", "at", "insn", "group", "bundling", "." ]

[ "rs6000", "\"=== Finishing schedule.\\n\"", "6", "\"ngroups = %d\\n\"", "\"Done finish_sched\\n\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"reloc_pcrel_4byte\"", ",", "0", ",", "4", "*", "8", "}", ",", "{", "\"reloc_pcrel_1byte\"", ",", "0", ",", "1", "*", "8", "}", ",", "{", "\"reloc_riprel_4byte\"", ",", "0", ",", "4", "*", "8", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCCodeEmitter", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "X86", "\"reloc_pcrel_4byte\"", "0", "4", "8", "\"reloc_pcrel_1byte\"", "0", "1", "8", "\"reloc_riprel_4byte\"", "0", "4", "8", "\"Invalid kind!\"" ]

[]

[ "<s>", "int", "csky_compute_pushpop_length", "(", "rtx", "*", "operands", ")", "{", "rtx", "parallel_op", "=", "operands", "[", "2", "]", ";", "unsigned", "indx", "=", "XVECLEN", "(", "parallel_op", ",", "0", ")", "-", "1", ";", "unsigned", "first_indx", "=", "0", ";", "unsigned", "regno", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "regno", ">", "CSKY_LR_REGNUM", ")", "return", "4", ";", "for", "(", ";", "indx", ">", "first_indx", ";", "indx", "--", ")", "{", "regno", "=", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "parallel_op", ",", "0", ",", "indx", ")", ",", "0", ")", ")", ";", "if", "(", "regno", ">", "CSKY_LR_REGNUM", ")", "return", "4", ";", "}", "return", "2", ";", "}", "</s>" ]

[ "Compute", "the", "attribute", "``", "length", "''", "of", "push", "or", "pop", "insn", ",", "according", "to", "the", "registers", "it", "uses", "." ]

[ "csky", "2", "0", "1", "0", "1", "4", "0", "0", "4", "2" ]

[]

[ "<s>", "bool", "easy_altivec_constant", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "step", ",", "copies", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "else", "if", "(", "mode", "!=", "GET_MODE", "(", "op", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "V2DFmode", ")", "return", "zero_constant", "(", "op", ",", "mode", ")", ";", "else", "if", "(", "mode", "==", "V2DImode", ")", "{", "if", "(", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", "!=", "CONST_INT", "||", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "if", "(", "zero_constant", "(", "op", ",", "mode", ")", ")", "return", "true", ";", "if", "(", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", "==", "-", "1", "&&", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "1", ")", ")", "==", "-", "1", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "mode", "==", "V1TImode", ")", "return", "false", ";", "step", "=", "GET_MODE_NUNITS", "(", "mode", ")", "/", "4", ";", "copies", "=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "of", "the", "given", "MODE", "and", "can", "be", "synthesized", "with", "a", "vspltisb", ",", "vspltish", "or", "vspltisw", "." ]

[ "rs6000", "0", "1", "0", "1", "1", "1", "4", "1", "1", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "void", "lm32_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"(%s+0)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "arg0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "arg1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "arg0", ")", "==", "REG", "&&", "CONSTANT_P", "(", "arg1", ")", ")", "{", "if", "(", "GET_CODE", "(", "arg1", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "\"(%s+%ld)\"", ",", "reg_names", "[", "REGNO", "(", "arg0", ")", "]", ",", "INTVAL", "(", "arg1", ")", ")", ";", "else", "{", "fprintf", "(", "file", ",", "\"(%s+\"", ",", "reg_names", "[", "REGNO", "(", "arg0", ")", "]", ")", ";", "output_addr_const", "(", "file", ",", "arg1", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "arg0", ")", "&&", "CONSTANT_P", "(", "arg1", ")", ")", "output_addr_const", "(", "file", ",", "addr", ")", ";", "else", "fatal_insn", "(", "\"bad operand\"", ",", "addr", ")", ";", "}", "break", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_SMALL_P", "(", "addr", ")", ")", "{", "fprintf", "(", "file", ",", "\"gp(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "else", "fatal_insn", "(", "\"can't use non gp relative absolute address\"", ",", "addr", ")", ";", "break", ";", "default", ":", "fatal_insn", "(", "\"invalid addressing mode\"", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "A", "C", "compound", "statement", "to", "output", "to", "stdio", "stream", "STREAM", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "that", "is", "a", "memory", "reference", "whose", "address", "is", "ADDR", ".", "ADDR", "is", "an", "RTL", "expression", ".", "On", "some", "machines", ",", "the", "syntax", "for", "a", "symbolic", "address", "depends", "on", "the", "section", "that", "the", "address", "refers", "to", ".", "On", "these", "machines", ",", "define", "the", "macro", "`", "ENCODE_SECTION_INFO", "'", "to", "store", "the", "information", "into", "the", "`", "symbol_ref", "'", ",", "and", "then", "check", "for", "it", "here", "." ]

[ "lm32", "\"(%s+0)\"", "0", "0", "1", "\"(%s+%ld)\"", "\"(%s+\"", "\")\"", "\"bad operand\"", "\"gp(\"", "\")\"", "\"can't use non gp relative absolute address\"", "\"invalid addressing mode\"" ]

[]

[ "<s>", "void", "SystemZMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "uint64_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Size", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "getSize", "(", ")", ";", "unsigned", "ShiftValue", "=", "(", "Size", "*", "8", ")", "-", "8", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "Size", ";", "++", "I", ")", "{", "OS", "<<", "uint8_t", "(", "Bits", ">>", "ShiftValue", ")", ";", "ShiftValue", "-=", "8", ";", "}", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "SystemZ", "SystemZ", "8", "8", "0", "8" ]

[]

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

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

[ "OpenRISC" ]

[]

[ "<s>", "bool", "HexagonGenMux", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "MF", ")", "Changed", "|=", "genMuxInBlock", "(", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "mayBeEmittedAsTailCall", "(", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "getTargetMachine", "(", ")", ".", "Options", ".", "DisableTailCalls", ")", "return", "false", ";", "CallSite", "CS", "(", "CI", ")", ";", "CallingConv", "::", "ID", "CalleeCC", "=", "CS", ".", "getCallingConv", "(", ")", ";", "if", "(", "!", "IsTailCallConvention", "(", "CalleeCC", ")", "&&", "CalleeCC", "!=", "CallingConv", "::", "C", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isDuplexPair", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ")", "const", "{", "HexagonII", "::", "SubInstructionGroup", "MIaG", "=", "getDuplexCandidateGroup", "(", "MIa", ")", ";", "HexagonII", "::", "SubInstructionGroup", "MIbG", "=", "getDuplexCandidateGroup", "(", "MIb", ")", ";", "return", "(", "isDuplexPairMatch", "(", "MIaG", ",", "MIbG", ")", "||", "isDuplexPairMatch", "(", "MIbG", ",", "MIaG", ")", ")", ";", "}", "</s>" ]

[ "Symmetrical", ".", "See", "if", "these", "two", "instructions", "are", "fit", "for", "duplex", "pair", "." ]

[ "Hexagon", "Hexagon", "HexagonII::SubInstructionGroup", "HexagonII::SubInstructionGroup" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "HexagonInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "HexagonII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "MO_PCREL", ",", "\"hexagon-pcrel\"", "}", ",", "{", "MO_GOT", ",", "\"hexagon-got\"", "}", ",", "{", "MO_LO16", ",", "\"hexagon-lo16\"", "}", ",", "{", "MO_HI16", ",", "\"hexagon-hi16\"", "}", ",", "{", "MO_GPREL", ",", "\"hexagon-gprel\"", "}", ",", "{", "MO_GDGOT", ",", "\"hexagon-gdgot\"", "}", ",", "{", "MO_GDPLT", ",", "\"hexagon-gdplt\"", "}", ",", "{", "MO_IE", ",", "\"hexagon-ie\"", "}", ",", "{", "MO_IEGOT", ",", "\"hexagon-iegot\"", "}", ",", "{", "MO_TPREL", ",", "\"hexagon-tprel\"", "}", "}", ";", "return", "makeArrayRef", "(", "Flags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\"hexagon-pcrel\"", "\"hexagon-got\"", "\"hexagon-lo16\"", "\"hexagon-hi16\"", "\"hexagon-gprel\"", "\"hexagon-gdgot\"", "\"hexagon-gdplt\"", "\"hexagon-ie\"", "\"hexagon-iegot\"", "\"hexagon-tprel\"" ]

[]

[ "<s>", "rtx_code", "m68k_find_flags_value", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "if", "(", "flags_compare_op0", "!=", "NULL_RTX", ")", "{", "if", "(", "rtx_equal_p", "(", "op0", ",", "flags_compare_op0", ")", "&&", "rtx_equal_p", "(", "op1", ",", "flags_compare_op1", ")", ")", "return", "code", ";", "if", "(", "rtx_equal_p", "(", "op0", ",", "flags_compare_op1", ")", "&&", "rtx_equal_p", "(", "op1", ",", "flags_compare_op0", ")", ")", "return", "swap_condition", "(", "code", ")", ";", "return", "UNKNOWN", ";", "}", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "op1", "!=", "CONST0_RTX", "(", "mode", ")", ")", "return", "UNKNOWN", ";", "gcc_assert", "(", "code", "!=", "LTU", "&&", "code", "!=", "GEU", ")", ";", "if", "(", "flags_valid", "==", "FLAGS_VALID_NOOV", "&&", "(", "code", "==", "GT", "||", "code", "==", "LE", ")", ")", "return", "UNKNOWN", ";", "if", "(", "rtx_equal_p", "(", "flags_operand1", ",", "op0", ")", "||", "rtx_equal_p", "(", "flags_operand2", ",", "op0", ")", ")", "return", "(", "FLOAT_MODE_P", "(", "mode", ")", "?", "code", ":", "code", "==", "GE", "?", "PLUS", ":", "code", "==", "LT", "?", "MINUS", ":", "code", ")", ";", "if", "(", "code", "!=", "GE", "&&", "code", "!=", "LT", ")", "return", "UNKNOWN", ";", "if", "(", "mode", "==", "SImode", "&&", "flags_operand1", "!=", "NULL_RTX", "&&", "GET_MODE", "(", "flags_operand1", ")", "==", "DImode", "&&", "REG_P", "(", "flags_operand1", ")", "&&", "REG_P", "(", "op0", ")", "&&", "hard_regno_nregs", "(", "REGNO", "(", "flags_operand1", ")", ",", "DImode", ")", "==", "2", "&&", "REGNO", "(", "flags_operand1", ")", "==", "REGNO", "(", "op0", ")", ")", "return", "code", "==", "GE", "?", "PLUS", ":", "MINUS", ";", "if", "(", "mode", "==", "SImode", "&&", "flags_operand2", "!=", "NULL_RTX", "&&", "GET_MODE", "(", "flags_operand2", ")", "==", "DImode", "&&", "REG_P", "(", "flags_operand2", ")", "&&", "REG_P", "(", "op0", ")", "&&", "hard_regno_nregs", "(", "REGNO", "(", "flags_operand2", ")", ",", "DImode", ")", "==", "2", "&&", "REGNO", "(", "flags_operand2", ")", "==", "REGNO", "(", "op0", ")", ")", "return", "code", "==", "GE", "?", "PLUS", ":", "MINUS", ";", "return", "UNKNOWN", ";", "}", "</s>" ]

[ "Return", "a", "code", "other", "than", "UNKNOWN", "if", "we", "can", "elide", "a", "CODE", "comparison", "of", "OP0", "with", "OP1", "." ]

[ "m68k", "2", "2" ]

[]

[ "<s>", "static", "int", "ix86_comp_type_attributes", "(", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "unsigned", "int", "ccvt1", ",", "ccvt2", ";", "if", "(", "TREE_CODE", "(", "type1", ")", "!=", "FUNCTION_TYPE", "&&", "TREE_CODE", "(", "type1", ")", "!=", "METHOD_TYPE", ")", "return", "1", ";", "ccvt1", "=", "ix86_get_callcvt", "(", "type1", ")", ";", "ccvt2", "=", "ix86_get_callcvt", "(", "type2", ")", ";", "if", "(", "ccvt1", "!=", "ccvt2", ")", "return", "0", ";", "if", "(", "ix86_function_regparm", "(", "type1", ",", "NULL", ")", "!=", "ix86_function_regparm", "(", "type2", ",", "NULL", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "0", "if", "the", "attributes", "for", "two", "types", "are", "incompatible", ",", "1", "if", "they", "are", "compatible", ",", "and", "2", "if", "they", "are", "nearly", "compatible", "(", "which", "causes", "a", "warning", "to", "be", "generated", ")", "." ]

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

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "VEISD", "::", "NAME", ":", "\\", "return", "\"VEISD::\"", "#", "NAME", ";", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_LONGJMP", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_SETJMP", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_SETUP_DISPATCH", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "GETSTACKTOP", ")", "TARGET_NODE_CASE", "(", "GETTLSADDR", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "MEMBARRIER", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "TS1AM", ")", "TARGET_NODE_CASE", "(", "VEC_BROADCAST", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "VE", "VE", "VEISD::NAME", "\"VEISD::\"", "VEISD::NodeType", "VEISD::FIRST_NUMBER", "VE" ]

[]

[ "<s>", "const", "char", "*", "SPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "SPUISD", "::", "RET_FLAG", ":", "return", "\"SPUISD::RET_FLAG\"", ";", "case", "SPUISD", "::", "Hi", ":", "return", "\"SPUISD::Hi\"", ";", "case", "SPUISD", "::", "Lo", ":", "return", "\"SPUISD::Lo\"", ";", "case", "SPUISD", "::", "PCRelAddr", ":", "return", "\"SPUISD::PCRelAddr\"", ";", "case", "SPUISD", "::", "AFormAddr", ":", "return", "\"SPUISD::AFormAddr\"", ";", "case", "SPUISD", "::", "IndirectAddr", ":", "return", "\"SPUISD::IndirectAddr\"", ";", "case", "SPUISD", "::", "LDRESULT", ":", "return", "\"SPUISD::LDRESULT\"", ";", "case", "SPUISD", "::", "CALL", ":", "return", "\"SPUISD::CALL\"", ";", "case", "SPUISD", "::", "SHUFB", ":", "return", "\"SPUISD::SHUFB\"", ";", "case", "SPUISD", "::", "SHUFFLE_MASK", ":", "return", "\"SPUISD::SHUFFLE_MASK\"", ";", "case", "SPUISD", "::", "CNTB", ":", "return", "\"SPUISD::CNTB\"", ";", "case", "SPUISD", "::", "PREFSLOT2VEC", ":", "return", "\"SPUISD::PREFSLOT2VEC\"", ";", "case", "SPUISD", "::", "VEC2PREFSLOT", ":", "return", "\"SPUISD::VEC2PREFSLOT\"", ";", "case", "SPUISD", "::", "SHL_BITS", ":", "return", "\"SPUISD::SHL_BITS\"", ";", "case", "SPUISD", "::", "SHL_BYTES", ":", "return", "\"SPUISD::SHL_BYTES\"", ";", "case", "SPUISD", "::", "VEC_ROTL", ":", "return", "\"SPUISD::VEC_ROTL\"", ";", "case", "SPUISD", "::", "VEC_ROTR", ":", "return", "\"SPUISD::VEC_ROTR\"", ";", "case", "SPUISD", "::", "ROTBYTES_LEFT", ":", "return", "\"SPUISD::ROTBYTES_LEFT\"", ";", "case", "SPUISD", "::", "ROTBYTES_LEFT_BITS", ":", "return", "\"SPUISD::ROTBYTES_LEFT_BITS\"", ";", "case", "SPUISD", "::", "SELECT_MASK", ":", "return", "\"SPUISD::SELECT_MASK\"", ";", "case", "SPUISD", "::", "SELB", ":", "return", "\"SPUISD::SELB\"", ";", "case", "SPUISD", "::", "ADD64_MARKER", ":", "return", "\"SPUISD::ADD64_MARKER\"", ";", "case", "SPUISD", "::", "SUB64_MARKER", ":", "return", "\"SPUISD::SUB64_MARKER\"", ";", "case", "SPUISD", "::", "MUL64_MARKER", ":", "return", "\"SPUISD::MUL64_MARKER\"", ";", "}", "}", "</s>" ]

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

[ "CellSPU", "SPU", "0", "SPUISD::RET_FLAG", "\"SPUISD::RET_FLAG\"", "SPUISD::Hi", "\"SPUISD::Hi\"", "SPUISD::Lo", "\"SPUISD::Lo\"", "SPUISD::PCRelAddr", "\"SPUISD::PCRelAddr\"", "SPUISD::AFormAddr", "\"SPUISD::AFormAddr\"", "SPUISD::IndirectAddr", "\"SPUISD::IndirectAddr\"", "SPUISD::LDRESULT", "\"SPUISD::LDRESULT\"", "SPUISD::CALL", "\"SPUISD::CALL\"", "SPUISD::SHUFB", "\"SPUISD::SHUFB\"", "SPUISD::SHUFFLE_MASK", "\"SPUISD::SHUFFLE_MASK\"", "SPUISD::CNTB", "\"SPUISD::CNTB\"", "SPUISD::PREFSLOT2VEC", "\"SPUISD::PREFSLOT2VEC\"", "SPUISD::VEC2PREFSLOT", "\"SPUISD::VEC2PREFSLOT\"", "SPUISD::SHL_BITS", "\"SPUISD::SHL_BITS\"", "SPUISD::SHL_BYTES", "\"SPUISD::SHL_BYTES\"", "SPUISD::VEC_ROTL", "\"SPUISD::VEC_ROTL\"", "SPUISD::VEC_ROTR", "\"SPUISD::VEC_ROTR\"", "SPUISD::ROTBYTES_LEFT", "\"SPUISD::ROTBYTES_LEFT\"", "SPUISD::ROTBYTES_LEFT_BITS", "\"SPUISD::ROTBYTES_LEFT_BITS\"", "SPUISD::SELECT_MASK", "\"SPUISD::SELECT_MASK\"", "SPUISD::SELB", "\"SPUISD::SELB\"", "SPUISD::ADD64_MARKER", "\"SPUISD::ADD64_MARKER\"", "SPUISD::SUB64_MARKER", "\"SPUISD::SUB64_MARKER\"", "SPUISD::MUL64_MARKER", "\"SPUISD::MUL64_MARKER\"" ]

[]

[ "<s>", "bool", "aarch64_offset_9bit_signed_unscaled_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "poly_int64", "offset", ")", "{", "HOST_WIDE_INT", "const_offset", ";", "return", "(", "offset", ".", "is_constant", "(", "&", "const_offset", ")", "&&", "IN_RANGE", "(", "const_offset", ",", "-", "256", ",", "255", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "a", "signed", "9-bit", "value", "." ]

[ "aarch64", "256", "255" ]

[]

[ "<s>", "bool", "R600Packetizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "R600Subtarget", "&", "ST", "=", "Fn", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "const", "R600InstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "R600PacketizerList", "Packetizer", "(", "Fn", ",", "ST", ",", "MLI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "->", "getInstrItins", "(", ")", ")", ";", "if", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "->", "getInstrItins", "(", ")", "->", "isEmpty", "(", ")", ")", "return", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "::", "iterator", "End", "=", "MBB", "->", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "if", "(", "MI", "->", "isKill", "(", ")", "||", "MI", "->", "getOpcode", "(", ")", "==", "R600", "::", "IMPLICIT_DEF", "||", "(", "MI", "->", "getOpcode", "(", ")", "==", "R600", "::", "CF_ALU", "&&", "!", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "DeleteMI", "=", "MI", ";", "++", "MI", ";", "MBB", "->", "erase", "(", "DeleteMI", ")", ";", "End", "=", "MBB", "->", "end", "(", ")", ";", "continue", ";", "}", "++", "MI", ";", "}", "}", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "RemainingCount", "=", "MBB", "->", "size", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ";", "RegionEnd", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", "--", "I", ",", "--", "RemainingCount", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "*", "std", "::", "prev", "(", "I", ")", ",", "&", "*", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "I", "=", "MBB", "->", "begin", "(", ")", ";", "if", "(", "I", "==", "RegionEnd", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "--", "RemainingCount", ";", "continue", ";", "}", "if", "(", "I", "==", "std", "::", "prev", "(", "RegionEnd", ")", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "&", "*", "MBB", ",", "&", "*", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "R600", "R600", "\"Empty DFA table!\"", "R600::IMPLICIT_DEF", "R600::CF_ALU", "8" ]

[]

[ "<s>", "bool", "aarch64_expand_cpymem", "(", "rtx", "*", "operands", ")", "{", "int", "n", ",", "mode_bits", ";", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "base", ";", "machine_mode", "cur_mode", "=", "BLKmode", ",", "next_mode", ";", "bool", "speed_p", "=", "!", "optimize_function_for_size_p", "(", "cfun", ")", ";", "int", "max_num_moves", "=", "(", "speed_p", "?", "16", ":", "AARCH64_CALL_RATIO", ")", "/", "2", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "(", "(", "n", "/", "16", ")", "+", "(", "n", "%", "16", "?", "2", ":", "0", ")", ")", ">", "max_num_moves", ")", "return", "false", ";", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "dst", ",", "0", ")", ")", ";", "dst", "=", "adjust_automodify_address", "(", "dst", ",", "VOIDmode", ",", "base", ",", "0", ")", ";", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "0", ")", ")", ";", "src", "=", "adjust_automodify_address", "(", "src", ",", "VOIDmode", ",", "base", ",", "0", ")", ";", "n", "=", "n", "*", "BITS_PER_UNIT", ";", "const", "int", "copy_limit", "=", "GET_MODE_BITSIZE", "(", "TImode", ")", ";", "while", "(", "n", ">", "0", ")", "{", "opt_scalar_int_mode", "mode_iter", ";", "FOR_EACH_MODE_IN_CLASS", "(", "mode_iter", ",", "MODE_INT", ")", "if", "(", "GET_MODE_BITSIZE", "(", "mode_iter", ".", "require", "(", ")", ")", "<=", "MIN", "(", "n", ",", "copy_limit", ")", ")", "cur_mode", "=", "mode_iter", ".", "require", "(", ")", ";", "gcc_assert", "(", "cur_mode", "!=", "BLKmode", ")", ";", "mode_bits", "=", "GET_MODE_BITSIZE", "(", "cur_mode", ")", ".", "to_constant", "(", ")", ";", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "cur_mode", ")", ";", "n", "-=", "mode_bits", ";", "if", "(", "n", ">", "0", "&&", "n", "<=", "8", "*", "BITS_PER_UNIT", ")", "{", "next_mode", "=", "smallest_mode_for_size", "(", "n", ",", "MODE_INT", ")", ";", "int", "n_bits", "=", "GET_MODE_BITSIZE", "(", "next_mode", ")", ".", "to_constant", "(", ")", ";", "src", "=", "aarch64_move_pointer", "(", "src", ",", "(", "n", "-", "n_bits", ")", "/", "BITS_PER_UNIT", ")", ";", "dst", "=", "aarch64_move_pointer", "(", "dst", ",", "(", "n", "-", "n_bits", ")", "/", "BITS_PER_UNIT", ")", ";", "n", "=", "n_bits", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "cpymem", ",", "as", "if", "from", "a", "__builtin_memcpy", ".", "Return", "true", "if", "we", "succeed", ",", "otherwise", "return", "false", "." ]

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

[]

[ "<s>", "void", "rvexRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "unsigned", "FrameReg", ";", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "int64_t", "Offset", ";", "Offset", "=", "spOffset", "+", "(", "int64_t", ")", "stackSize", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "if", "(", "!", "MI", ".", "isDebugValue", "(", ")", "&&", "!", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "{", "assert", "(", "\"(!MI.isDebugValue() && !isInt<16>(Offset))\"", ")", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "1", "0", "1", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "16", "\"(!MI.isDebugValue() && !isInt<16>(Offset))\"", "1" ]

[]

[ "<s>", "MSP430Subtarget", "::", "MSP430Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "MSP430GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "AMDGPUOperand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "const", "MCRegisterInfo", "*", "TRI", ",", "bool", "ForceVOP3", ")", "{", "auto", "Op", "=", "llvm", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "TRI", "=", "TRI", ";", "Op", "->", "Reg", ".", "Modifiers", "=", "-", "1", ";", "Op", "->", "Reg", ".", "IsForcedVOP3", "=", "ForceVOP3", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyDebugFixup", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Debug Fixup **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "struct", "StackElem", "{", "unsigned", "Reg", ";", "MachineInstr", "*", "DebugValue", ";", "}", ";", "std", "::", "vector", "<", "StackElem", ">", "Stack", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MII", "=", "MBB", ".", "begin", "(", ")", ";", "MII", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "auto", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", ".", "isValid", "(", ")", "&&", "MFI", ".", "isVRegStackified", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "for", "(", "auto", "&", "Elem", ":", "reverse", "(", "Stack", ")", ")", "{", "if", "(", "MO", ".", "getReg", "(", ")", "==", "Elem", ".", "Reg", ")", "{", "auto", "Depth", "=", "static_cast", "<", "unsigned", ">", "(", "&", "Elem", "-", "&", "Stack", "[", "0", "]", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Debug Value VReg \"", "<<", "MO", ".", "getReg", "(", ")", "<<", "\" -> Stack Relative \"", "<<", "Depth", "<<", "\"\\n\"", ")", ";", "MO", ".", "ChangeToTargetIndex", "(", "WebAssembly", "::", "TI_OPERAND_STACK", ",", "Depth", ")", ";", "Elem", ".", "DebugValue", "=", "&", "MI", ";", "break", ";", "}", "}", "}", "}", "else", "{", "for", "(", "MachineOperand", "&", "MO", ":", "reverse", "(", "MI", ".", "explicit_uses", "(", ")", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MFI", ".", "isVRegStackified", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "auto", "Prev", "=", "Stack", ".", "back", "(", ")", ";", "Stack", ".", "pop_back", "(", ")", ";", "assert", "(", "Prev", ".", "Reg", "==", "MO", ".", "getReg", "(", ")", "&&", "\"WebAssemblyDebugFixup: Pop: Register not matched!\"", ")", ";", "if", "(", "Prev", ".", "DebugValue", "&&", "!", "MI", ".", "isTerminator", "(", ")", ")", "{", "BuildMI", "(", "*", "Prev", ".", "DebugValue", "->", "getParent", "(", ")", ",", "std", "::", "next", "(", "MII", ")", ",", "Prev", ".", "DebugValue", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "WebAssembly", "::", "DBG_VALUE", ")", ",", "false", ",", "Register", "(", ")", ",", "Prev", ".", "DebugValue", "->", "getOperand", "(", "2", ")", ".", "getMetadata", "(", ")", ",", "Prev", ".", "DebugValue", "->", "getOperand", "(", "3", ")", ".", "getMetadata", "(", ")", ")", ";", "}", "}", "}", "for", "(", "MachineOperand", "&", "MO", ":", "MI", ".", "defs", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MFI", ".", "isVRegStackified", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "Stack", ".", "push_back", "(", "{", "MO", ".", "getReg", "(", ")", ",", "nullptr", "}", ")", ";", "}", "}", "}", "}", "assert", "(", "Stack", ".", "empty", "(", ")", "&&", "\"WebAssemblyDebugFixup: Stack not empty at end of basic block!\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Debug Fixup **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly", "0", "0", "\"Debug Value VReg \"", "\" -> Stack Relative \"", "\"\\n\"", "WebAssembly::TI_OPERAND_STACK", "\"WebAssemblyDebugFixup: Pop: Register not matched!\"", "WebAssembly::DBG_VALUE", "2", "3", "\"WebAssemblyDebugFixup: Stack not empty at end of basic block!\"" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "\"0(\"", "\")\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SIRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "ST", ".", "hasGFX90AInsts", "(", ")", "?", "CSR_AMDGPU_HighRegs_With_AGPRs_SaveList", ":", "CSR_AMDGPU_HighRegs_SaveList", ";", "case", "CallingConv", "::", "AMDGPU_Gfx", ":", "return", "ST", ".", "hasGFX90AInsts", "(", ")", "?", "CSR_AMDGPU_SI_Gfx_With_AGPRs_SaveList", ":", "CSR_AMDGPU_SI_Gfx_SaveList", ";", "default", ":", "{", "static", "const", "MCPhysReg", "NoCalleeSavedReg", "=", "AMDGPU", "::", "NoRegister", ";", "return", "&", "NoCalleeSavedReg", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU", "SI", "SI", "AMDGPU::NoRegister" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", "&&", "\"X86-64 PIC uses RIP relative addressing\"", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "X86FI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MBBI", "!=", "FirstMBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "PC", "=", "RegInfo", ".", "createVirtualRegister", "(", "X86", "::", "GR32RegisterClass", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOVPC32r", ")", ",", "PC", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", "&&", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "{", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "X86", "::", "GR32RegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "ADD32ri", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "PC", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "}", "else", "{", "GlobalBaseReg", "=", "PC", ";", "}", "X86FI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"X86-64 PIC uses RIP relative addressing\"", "X86", "X86", "X86", "X86", "0", "X86::GR32RegisterClass", "X86::MOVPC32r", "0", "X86", "X86::GR32RegisterClass", "X86::ADD32ri", "\"_GLOBAL_OFFSET_TABLE_\"", "X86" ]

[]

[ "<s>", "static", "bool", "mova_p", "(", "rtx_insn", "*", "insn", ")", "{", "return", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "1", ")", "==", "UNSPEC_MOVA", "&&", "GET_CODE", "(", "MOVA_LABELREF", "(", "insn", ")", ")", "==", "LABEL_REF", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "insn", "is", "a", "mova", "insn", "." ]

[ "sh", "1" ]

[]

[ "<s>", "unsigned", "PPCTTI", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "return", "TargetTransformInfo", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "ix86_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "default_decimal_float_supported_p", "(", ")", ";", "else", "if", "(", "mode", "==", "TFmode", ")", "return", "true", ";", "else", "if", "(", "(", "mode", "==", "HFmode", "||", "mode", "==", "BFmode", ")", "&&", "TARGET_SSE2", ")", "return", "true", ";", "else", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "scalar_mode_supported_p", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "avr_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "bool", "big_offset_p", "=", "false", ";", "x", "=", "oldx", ";", "if", "(", "GET_CODE", "(", "oldx", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "oldx", ",", "0", ")", ")", ")", "{", "if", "(", "REG_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "{", "int", "offs", "=", "INTVAL", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ";", "if", "(", "frame_pointer_rtx", "!=", "XEXP", "(", "oldx", ",", "0", ")", "&&", "offs", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "{", "big_offset_p", "=", "true", ";", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "}", "}", "}", "if", "(", "avr_log", ".", "legitimize_address", ")", "{", "avr_edump", "(", "\"\\n%?: mode=%m\\n %r\\n\"", ",", "mode", ",", "oldx", ")", ";", "if", "(", "x", "!=", "oldx", ")", "avr_edump", "(", "\" %s --> %r\\n\"", ",", "big_offset_p", "?", "\"(big offset)\"", ":", "\"\"", ",", "x", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Attempts", "to", "replace", "X", "with", "a", "valid", "memory", "address", "for", "an", "operand", "of", "mode", "MODE" ]

[ "avr", "0", "1", "1", "1", "0", "\"\\n%?: mode=%m\\n %r\\n\"", "\" %s --> %r\\n\"", "\"(big offset)\"", "\"\"" ]

[]

[ "<s>", "void", "VLIWMachineScheduler", "::", "schedule", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Converging Scheduling VLIW BB#\"", "<<", "BB", "->", "getNumber", "(", ")", "<<", "\" \"", "<<", "BB", "->", "getName", "(", ")", "<<", "\" in_func \"", "<<", "BB", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" at loop depth \"", "<<", "MLI", ".", "getLoopDepth", "(", "BB", ")", "<<", "\" \\n\"", ")", ";", "buildDAGWithRegPressure", "(", ")", ";", "postprocessDAG", "(", ")", ";", "DEBUG", "(", "unsigned", "maxH", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ">", "maxH", ")", "maxH", "=", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Height \"", "<<", "maxH", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "unsigned", "maxD", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ">", "maxD", ")", "maxD", "=", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Depth \"", "<<", "maxD", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "initQueues", "(", ")", ";", "bool", "IsTopNode", "=", "false", ";", "while", "(", "SUnit", "*", "SU", "=", "SchedImpl", "->", "pickNode", "(", "IsTopNode", ")", ")", "{", "if", "(", "!", "checkSchedLimit", "(", ")", ")", "break", ";", "scheduleMI", "(", "SU", ",", "IsTopNode", ")", ";", "updateQueues", "(", "SU", ",", "IsTopNode", ")", ";", "}", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "placeDebugValues", "(", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Hexagon", "\"********** MI Converging Scheduling VLIW BB#\"", "\" \"", "\" in_func \"", "\" at loop depth \"", "\" \\n\"", "0", "0", "\"Max Height \"", "\"\\n\"", "0", "0", "\"Max Depth \"", "\"\\n\"", "0", "\"Nonempty unscheduled zone.\"" ]

[]

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

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "unsigned", "HexagonGenInsert", "::", "distance", "(", "MachineBasicBlock", "::", "const_iterator", "FromI", ",", "MachineBasicBlock", "::", "const_iterator", "ToI", ",", "const", "UnsignedMap", "&", "RPO", ",", "PairMapType", "&", "M", ")", "const", "{", "const", "MachineBasicBlock", "*", "FB", "=", "FromI", "->", "getParent", "(", ")", ",", "*", "TB", "=", "ToI", "->", "getParent", "(", ")", ";", "if", "(", "FB", "==", "TB", ")", "return", "std", "::", "distance", "(", "FromI", ",", "ToI", ")", ";", "unsigned", "D1", "=", "std", "::", "distance", "(", "TB", "->", "begin", "(", ")", ",", "ToI", ")", ";", "unsigned", "D2", "=", "distance", "(", "FB", ",", "TB", ",", "RPO", ",", "M", ")", ";", "unsigned", "D3", "=", "std", "::", "distance", "(", "FromI", ",", "FB", "->", "end", "(", ")", ")", ";", "return", "D1", "+", "D2", "+", "D3", ";", "}", "</s>" ]

[ "Return", "the", "distance", "from", "this", "index", "to", "the", "given", "one", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "bool", "isMicroMips", "=", "Subtarget", ".", "inMicroMipsMode", "(", ")", ";", "unsigned", "Opc", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "expandRetRA", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "ERet", ":", "expandERet", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFHI16_MM", ":", "Mips", "::", "MFHI", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFLO16_MM", ":", "Mips", "::", "MFLO", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFHI64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFLO64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO", ",", "Mips", "::", "MTHI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI64", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO64", ",", "Mips", "::", "MTHI64", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI_DSP", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO_DSP", ",", "Mips", "::", "MTHI_DSP", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D32_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D32_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_W", ",", "Mips", "::", "MTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64_64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64_64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "expandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::RetRA", "Mips::ERet", "Mips::PseudoMFHI", "Mips", "Mips::MFHI16_MM", "Mips::MFHI", "Mips::PseudoMFLO", "Mips", "Mips::MFLO16_MM", "Mips::MFLO", "Mips::PseudoMFHI64", "Mips::MFHI64", "Mips::PseudoMFLO64", "Mips::MFLO64", "Mips::PseudoMTLOHI", "Mips::MTLO", "Mips::MTHI", "Mips::PseudoMTLOHI64", "Mips::MTLO64", "Mips::MTHI64", "Mips::PseudoMTLOHI_DSP", "Mips::MTLO_DSP", "Mips::MTHI_DSP", "Mips::PseudoCVT_S_W", "Mips::CVT_S_W", "Mips::MTC1", "Mips::PseudoCVT_D32_W", "Mips::CVT_D32_W", "Mips::MTC1", "Mips::PseudoCVT_S_L", "Mips::CVT_S_L", "Mips::DMTC1", "Mips::PseudoCVT_D64_W", "Mips::CVT_D64_W", "Mips::MTC1", "Mips::PseudoCVT_D64_L", "Mips::CVT_D64_L", "Mips::DMTC1", "Mips::BuildPairF64", "Mips::BuildPairF64_64", "Mips::ExtractElementF64", "Mips::ExtractElementF64_64", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "bool", "AMDGPUAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "OW", "->", "WriteZeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "R600" ]

[]