Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "bool", "TL45InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "reverse_iterator", "I", "=", "MBB", ".", "rbegin", "(", ")", ",", "REnd", "=", "MBB", ".", "rend", "(", ")", ";", "while", "(", "I", "!=", "REnd", "&&", "I", "->", "isDebugInstr", "(", ")", ")", "++", "I", ";", "if", "(", "I", "==", "REnd", "||", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "return", "false", ";", "}", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "BranchInstrs", ";", "MachineInstr", "*", "LastInst", "=", "&", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "BranchInstrs", ".", "push_back", "(", "LastInst", ")", ";", "if", "(", "!", "getAnalyzableBrOpc", "(", "LastOpc", ")", ")", "return", "true", ";", "unsigned", "SecondLastOpc", "=", "<NUM_LIT>", ";", "MachineInstr", "*", "SecondLastInst", "=", "nullptr", ";", "++", "I", ";", "while", "(", "I", "!=", "REnd", "&&", "I", "->", "isDebugInstr", "(", ")", ")", "++", "I", ";", "if", "(", "I", "!=", "REnd", ")", "{", "SecondLastInst", "=", "&", "*", "I", ";", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "isUnpredicatedTerminator", "(", "*", "SecondLastInst", ")", "&&", "!", "getAnalyzableBrOpc", "(", "SecondLastOpc", ")", ")", "return", "true", ";", "}", "if", "(", "!", "SecondLastOpc", "||", "!", "getAnalyzableBrOpc", "(", "SecondLastOpc", ")", ")", "{", "if", "(", "LastInst", "->", "isUnconditionalBranch", "(", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "AnalyzeCondBr", "(", "LastInst", ",", "LastOpc", ",", "TBB", ",", "Cond", ",", "I", ")", ";", "return", "false", ";", "}", "if", "(", "++", "I", "!=", "REnd", "&&", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "true", ";", "BranchInstrs", ".", "insert", "(", "BranchInstrs", ".", "begin", "(", ")", ",", "SecondLastInst", ")", ";", "if", "(", "SecondLastInst", "->", "isUnconditionalBranch", "(", ")", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "return", "true", ";", "}", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "LastInst", "->", "eraseFromParent", "(", ")", ";", "BranchInstrs", ".", "pop_back", "(", ")", ";", "return", "false", ";", "}", "if", "(", "!", "LastInst", "->", "isUnconditionalBranch", "(", ")", ")", "return", "true", ";", "AnalyzeCondBr", "(", "SecondLastInst", ",", "SecondLastOpc", ",", "TBB", ",", "Cond", ",", "I", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}" ]

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

[ "}" ]

[ "const", "InstrItineraryData", "*", "Itin", "=", "DAG", "->", "getSchedModel", "(", ")", "->", "getInstrItineraries", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "DAG", "->", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "delete", "Top", ".", "HazardRec", ";", "delete", "Bot", ".", "HazardRec", ";", "Top", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Bot", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "delete", "Top", ".", "ResourceModel", ";", "delete", "Bot", ".", "ResourceModel", ";", "Top", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "Bot", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "const", "std", "::", "vector", "<", "unsigned", ">", "&", "MaxPressure", "=", "DAG", "->", "getRegPressure", "(", ")", ".", "MaxSetPressure", ";", "HighPressureSets", ".", "assign", "(", "MaxPressure", ".", "size", "(", ")", ",", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MaxPressure", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Limit", "=", "DAG", "->", "getRegClassInfo", "(", ")", "->", "getRegPressureSetLimit", "(", "i", ")", ";", "HighPressureSets", "[", "i", "]", "=", "(", "(", "float", ")", "MaxPressure", "[", "i", "]", ">", "(", "(", "float", ")", "Limit", "*", "RPThreshold", ")", ")", ";" ]

[ "}" ]

[ "if", "(", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";" ]

[ ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "GPF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fma", ":", "GPF", "(", "match_operand", ":", "GPF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "GPF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "GPF", "(", "match_operand", ":", "GPF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vu32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "class", "Enc_a90628", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Qv4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qv4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vu32", ";" ]

[ ":" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "invalid fixup kind!", "<STR_LIT>", ")", ";", "case", "FK_PCRel_1", ":", "case", "FK_SecRel_1", ":", "case", "FK_Data_1", ":", "return", "<NUM_LIT>", ";", "case", "FK_PCRel_2", ":", "case", "FK_SecRel_2", ":", "case", "FK_Data_2", ":", "return", "<NUM_LIT>", ";", "case", "FK_PCRel_4" ]

[ "AMDGPUPreLegalizerCombinerHelper", "PreLegalizerHelper", "(", "B", ",", "Helper", ")", ";" ]

[ "bool", "AMDGPUPreLegalizerCombinerInfo", "::", "combine", "(", "GISelChangeObserver", "&", "Observer", ",", "MachineInstr", "&", "MI", ",", "MachineIRBuilder", "&", "B", ")", "const", "{", "AMDGPUCombinerHelper", "Helper", "(", "Observer", ",", "B", ",", "KB", ",", "MDT", ")", ";" ]

[ "if", "(", "MaxPrivateElementSize", "==", "<NUM_LIT>", ")", "MaxPrivateElementSize", "=", "<NUM_LIT>", ";" ]

[ "FlatForGlobal", "=", "true", ";", "}", "if", "(", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "FP64FP16Denormals", "=", "false", ";", "FP32Denormals", "=", "false", ";", "}" ]

[ "}" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "DiagnosticType", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "v", "=", "v", ">>", "<NUM_LIT>", ";", "v", "=", "v", ">>", "<NUM_LIT>", ";", "rx_print_integer", "(", "file", ",", "v", ")", ";", "<FIXE>" ]

[ "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "op", ")", "+", "(", "WORDS_BIG_ENDIAN", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "]", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "#", "<STR_LIT>", ")", ";", "<BUGS>", "rx_print_integer", "(", "file", ",", "INTVAL", "(", "op", ")", ">>", "<NUM_LIT>", ")", ";", "<BUGE>", "}", "else", "{" ]

[ "LegacyInfo", ".", "setAction", "(", "{", "G_UNMERGE_VALUES", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";" ]

[ "auto", "&", "LegacyInfo", "=", "getLegacyLegalizerInfo", "(", ")", ";", "for", "(", "unsigned", "BinOp", ":", "{", "G_ADD", ",", "G_SUB", "}", ")", "for", "(", "auto", "Ty", ":", "{", "v32s8", ",", "v16s16", ",", "v8s32", ",", "v4s64", "}", ")", "LegacyInfo", ".", "setAction", "(", "{", "BinOp", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "for", "(", "auto", "Ty", ":", "{", "v16s16", ",", "v8s32", "}", ")", "LegacyInfo", ".", "setAction", "(", "{", "G_MUL", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "for", "(", "const", "auto", "&", "Ty", ":", "{", "v64s8", ",", "v32s16", ",", "v16s32", ",", "v8s64", "}", ")", "{", "LegacyInfo", ".", "setAction", "(", "{", "G_CONCAT_VECTORS", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "LegacyInfo", ".", "setAction", "(", "{", "G_UNMERGE_VALUES", ",", "<NUM_LIT>", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "}", "for", "(", "const", "auto", "&", "Ty", ":", "{", "v32s8", ",", "v16s16", ",", "v8s32", ",", "v4s64", "}", ")", "{", "LegacyInfo", ".", "setAction", "(", "{", "G_CONCAT_VECTORS", ",", "<NUM_LIT>", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";" ]

[ "<FIXS>", "MachineOperand", "::", "CreateReg", "(", "PredReg", ",", "false", ")", "}", "}", ";", "<FIXE>", "<FIXS>", "return", "MachineOperand", "::", "CreateReg", "(", "CCReg", ",", "false", ")", ";", "<FIXE>" ]

[ "static", "inline", "std", "::", "array", "MachineOperand", ",", "<NUM_LIT>", ">", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", "Pred", ",", "unsigned", "PredReg", "=", "<NUM_LIT>", ")", "{", "return", "{", "{", "MachineOperand", "::", "CreateImm", "(", "static_cast", "int64_t", ">", "(", "Pred", ")", ")", ",", "<BUGS>", "MachineOperand", "::", "CreateReg", "(", "PredReg", ",", "<NUM_LIT>", ")", "}", "}", ";", "<BUGE>", "}", "static", "inline", "MachineOperand", "condCodeOp", "(", "unsigned", "CCReg", "=", "<NUM_LIT>", ")", "{", "<BUGS>", "return", "MachineOperand", "::", "CreateReg", "(", "CCReg", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "}" ]

[ "}" ]

[ "def", "PPCRegSPE4RCAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", ";" ]

[ "bool", "DeadCodeElimination", "::", "isDead", "(", "unsigned", "R", ")", "const", "{", "for", "(", "auto", "I", "=", "MRI", ".", "use_begin", "(", "R", ")", ",", "E", "=", "MRI", ".", "use_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "UseI", "=", "I", "->", "getParent", "(", ")", ";", "if", "(", "UseI", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "UseI", "->", "isPHI", "(", ")", ")", "{", "assert", "(", "!", "UseI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", ")", ";", "Register", "DR", "=", "UseI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "DR", "==", "R", ")", "continue", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";" ]

[ "return", "true", ";" ]

[ "const", "SDep", "&", "Dep", "=", "SUJ", "->", "Succs", "[", "i", "]", ";", "if", "(", "Dep", ".", "getSUnit", "(", ")", "!=", "SUI", ")", "continue", ";", "if", "(", "Dep", ".", "getKind", "(", ")", "==", "SDep", "::", "Anti", ")", "continue", ";", "if", "(", "Dep", ".", "getKind", "(", ")", "==", "SDep", "::", "Output", ")", "if", "(", "MII", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "MIJ", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "continue", ";", "return", "false", ";", "}", "}", "bool", "ARDef", "=", "TII", "->", "definesAddressRegister", "(", "MII", ")", "||", "TII", "->", "definesAddressRegister", "(", "MIJ", ")", ";", "bool", "ARUse", "=", "TII", "->", "usesAddressRegister", "(", "MII", ")", "||", "TII", "->", "usesAddressRegister", "(", "MIJ", ")", ";", "if", "(", "ARDef", "&&", "ARUse", ")", "return", "false", ";" ]

[ ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_getexppd256_mask", "(", "(", "_", "_", "v4df", ")", "_", "_", "A", ",", "(", "_", "_", "v4df", ")", "_", "mm256_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8" ]

[ "<FIXS>", "NewP", "=", "(", "P", "==", "CmpInst", "::", "ICMP_SLT", ")", "?", "CmpInst", "::", "ICMP_SLE", ":", "CmpInst", "::", "ICMP_SGT", ";", "<FIXE>" ]

[ "if", "(", "(", "Size", "==", "<NUM_LIT>", "&&", "static_cast", "int64_t", ">", "(", "C", ")", "==", "INT64_MIN", ")", "||", "(", "Size", "==", "<NUM_LIT>", "&&", "static_cast", "int32_t", ">", "(", "C", ")", "==", "INT32_MIN", ")", ")", "return", "nullptr", ";", "<BUGS>", "P", "=", "(", "P", "==", "CmpInst", "::", "ICMP_SLT", ")", "?", "CmpInst", "::", "ICMP_SLE", ":", "CmpInst", "::", "ICMP_SGT", ";", "<BUGE>", "C", "-=", "<NUM_LIT>", ";", "break", ";", "case", "CmpInst", "::", "ICMP_ULT", ":" ]

[ "emit_insn", "(", "gen_mve_vshlq_s", "<", "mode", ">", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "neg", ")", ")" ]

[ "if", "(", "s_register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ")", ")", "{", "rtx", "neg", "=", "gen_reg_rtx", "(", "<", "MODE", ">", "mode", ")", "emit_insn", "(", "gen_neg", "<", "mode", ">", "<NUM_LIT>", "(", "neg", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "globalize_label", "(", "stream", ",", "name", ")", ";" ]

[ "void", "mips_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "if", "(", "TARGET_EMBEDDED_DATA", "&&", "TARGET_UNINIT_CONST_IN_RODATA", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "decl", ")", "&&", "(", "DECL_INITIAL", "(", "decl", ")", "==", "<NUM_LIT>", "||", "DECL_INITIAL", "(", "decl", ")", "==", "error_mark_node", ")", ")", "{", "if", "(", "TREE_PUBLIC", "(", "decl", ")", "&&", "DECL_NAME", "(", "decl", ")", ")", "targetm", ".", "asm_out", "." ]

[ "}" ]

[ "if", "(", "TypeQual", ".", "contains", "(", "<STR_LIT>", "pipe", "<STR_LIT>", ")", ")", "return", "<STR_LIT>", "pipe", "<STR_LIT>", ";", "return", "StringSwitch", "<", "StringRef", ">", "(", "BaseTypeName", ")", ".", "Case", "(", "<STR_LIT>", "image1d_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image1d_array_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image1d_buffer_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_depth_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_msaa_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_msaa_depth_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_depth_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_msaa_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image2d_msaa_depth_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "image3d_t", "<STR_LIT>", ",", "<STR_LIT>", "image", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sampler_t", "<STR_LIT>", ",", "<STR_LIT>", "sampler", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "queue_t", "<STR_LIT>", ",", "<STR_LIT>", "queue", "<STR_LIT>", ")", ".", "Default", "(", "isa", "<", "PointerType", ">", "(", "Ty", ")", "?", "(", "Ty", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "?", "<STR_LIT>", "dynamic_shared_pointer", "<STR_LIT>", ":", "<STR_LIT>", "global_buffer", "<STR_LIT>", ")", ":", "<STR_LIT>", "by_value", "<STR_LIT>", ")", ";" ]

[ ",", "SDTIntUnaryOp", ",", "[", "]", ">", ";" ]

[ "def", "TLCS900rra", ":", "SDNode", "<", "<STR_LIT>" ]

[ "<FIXS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureAVX512", "]", "&&", "<FIXE>" ]

[ "}", "<BUGS>", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "X86", "::", "FeatureAVX512", "&&", "<BUGE>", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LCurly", ")", ")", "return", "ParseRoundingModeOp", "(", "Start", ",", "End", ")", ";" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "const", "AMDGPUSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ",", "STI", ",", "*", "this", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "STI", ".", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "*", "MI", ",", "Err", ")", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "<STR_LIT>", "Illegal instruction detected: ", "<STR_LIT>", "+", "Err", ")", ";", "MI", "->", "print", "(", "errs", "(", ")", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "++", "MI", "->", "getIterator", "(", ")", ";", "while", "(", "I", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "EmitInstruction", "(", "&", "*", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "{", "if", "(", "isVerbose", "(", ")", ")", "{", "SmallVector", "<", "char", ",", "<NUM_LIT>", ">", "BBStr", ";", "raw_svector_ostream", "Str", "(", "BBStr", ")", ";", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "MBB", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ";", "Expr", "->", "print", "(", "Str", ",", "MAI", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "<STR_LIT>", " mask branch ", "<STR_LIT>", "+", "BBStr", ")", ";", "}", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ")", "{", "if", "(", "isVerbose", "(", ")", ")", "OutStreamer", "->", "emitRawComment", "(", "<STR_LIT>", " return to shader part epilog", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "WAVE_BARRIER", ")", "{", "if", "(", "isVerbose", "(", ")", ")", "OutStreamer", "->", "emitRawComment", "(", "<STR_LIT>", " wave barrier", "<STR_LIT>", ")", ";", "return", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "if", "(", "STI", ".", "dumpCode", "(", ")", ")", "{", "DisasmLines", ".", "resize", "(", "DisasmLines", ".", "size", "(", ")", "+", "<NUM_LIT>", ")", ";", "std", "::", "string", "&", "DisasmLine", "=", "DisasmLines", ".", "back", "(", ")", ";", "raw_string_ostream", "DisasmStream", "(", "DisasmLine", ")", ";", "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "STI", ".", "getInstrInfo", "(", ")", ",", "*", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ",", "STI", ")", ";", "SmallVector", "<", "MCFixup", ",", "<NUM_LIT>", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "<NUM_LIT>", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "auto", "&", "ObjStreamer", "=", "static_cast", "<", "MCObjectStreamer", "&", ">", "(", "*", "OutStreamer", ")", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "encodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "MF", "->", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "<NUM_LIT>", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", ".", "back", "(", ")", ";", "raw_string_ostream", "HexStream", "(", "HexLine", ")", ";", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "CodeBytes", ".", "size", "(", ")", ";", "i", "+=", "<NUM_LIT>", ")", "{", "unsigned", "int", "CodeDWord", "=", "*", "(", "unsigned", "int", "*", ")", "&", "CodeBytes", "[", "i", "]", ";", "HexStream", "<<", "format", "(", "<STR_LIT>", "%s%08X", "<STR_LIT>", ",", "(", "i", ">", "<NUM_LIT>", "?", "<STR_LIT>", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", ",", "CodeDWord", ")", ";", "}", "DisasmStream", ".", "flush", "(", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLine", ".", "size", "(", ")", ")", ";", "}", "}", "}" ]

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

[ ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "not", ":", "SI", "(", "xor", ":", "SI", "(", "match_operand" ]

[ "<STR_LIT>", ")", ")" ]

[ "(", "eq_attr", "<STR_LIT>" ]

[ "}" ]

[ "const", "BPFSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";" ]

[ "return", "false", ";" ]

[ "default", ":", "return", "false", ";", "case", "ISD", "::", "ADD", ":", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2ADDrr", ":", "ARM", "::", "ADDrr", ";", "break", ";", "case", "ISD", "::", "OR", ":", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2ORRrr", ":", "ARM", "::", "ORRrr", ";", "break", ";", "case", "ISD", "::", "SUB", ":", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2SUBrr", ":", "ARM", "::", "SUBrr", ";", "break", ";", "}", "unsigned", "SrcReg1", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "SrcReg1", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "SrcReg2", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "SrcReg2", "==", "<NUM_LIT>", ")" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "return", "<STR_LIT>", "<FIXE>", "<FIXS>", "return", "<STR_LIT>", "}", "<FIXE>" ]

[ "[", "(", "set", "(", "pc", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")", ")" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_reservation", "<STR_LIT>" ]

[ "}" ]

[ "unsigned", "NumArgs", "=", "Args", ".", "size", "(", ")", ";", "Function", "::", "const_arg_iterator", "CurOrigArg", "=", "Args", ".", "begin", "(", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumArgs", ";", "++", "i", ",", "++", "CurOrigArg", ")", "{", "MVT", "ValVT", "=", "MVT", "::", "getVT", "(", "CurOrigArg", "->", "getType", "(", ")", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "bool", "Res", "=", "AssignFn", "(", "i", ",", "ValVT", ",", "ValVT", ",", "CCValAssign", "::", "Full", ",", "ISD", "::", "ArgFlagsTy", "(", ")", ",", "CCInfo", ")", ";", "assert", "(", "!", "Res", "&&", "<STR_LIT>", "Call operand has unhandled type", "<STR_LIT>", ")", ";", "(", "void", ")", "Res", ";", "}", "assert", "(", "ArgLocs", ".", "size", "(", ")", "==", "Args", ".", "size", "(", ")", "&&", "<STR_LIT>", "We have a different number of location and args?!", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Not yet implemented", "<STR_LIT>", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "TargetOpcode", "::", "COPY", ",", "VRegs", "[", "i", "]", ",", "VA", ".", "getLocReg", "(", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "ZExt", ":", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Not yet implemented", "<STR_LIT>", ")", ";", "break", ";", "}", "}", "return", "true", ";" ]

[ "r", ";" ]

[ "}", "else", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", ".L__stack_usage+1", "<STR_LIT>", ")", ";", "cfun", "->", "machine", "->", "use_L__stack_usage", "=", "<NUM_LIT>", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "r", ")", ";", "r", "=", "gen_frame_mem", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "r", ")", ")", ";", "r", "=", "gen_rtx_ROTATE", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ";", "return" ]

[ "if", "(", "auto", "USatVal", "=", "detectUSatPattern", "(", "In", ",", "VT", ",", "DAG", ",", "DL", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "USatVal", ")", ";" ]

[ "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "In", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "auto", "SSatVal", "=", "detectSSatPattern", "(", "In", ",", "VT", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "SSatVal", ")", ";" ]

[ "LaneSrcs", "[", "Lane", "]", "[", "<NUM_LIT>", "]", "=", "M", "/", "LaneSize", ";" ]

[ "else", "return", "SDValue", "(", ")", ";", "Srcs", "[", "Src", "]", "=", "LaneSrc", ";", "InLaneMask", "[", "i", "]", "=", "(", "M", "%", "LaneSize", ")", "+", "Src", "*", "Size", ";", "}", "if", "(", "Srcs", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", ")", "continue", ";", "LaneSrcs", "[", "Lane", "]", "[", "<NUM_LIT>", "]", "=", "Srcs", "[", "<NUM_LIT>", "]", ";", "LaneSrcs", "[", "Lane", "]", "[", "<NUM_LIT>", "]", "=", "Srcs", "[", "<NUM_LIT>", "]", ";", "auto", "MatchMasks", "=", "[", "]", "(", "ArrayRef", "<", "int", ">", "M1", ",", "ArrayRef", "<", "int", ">", "M2", ")", "{", "assert", "(", "M1", ".", "size", "(", ")", "==", "M2", ".", "size", "(", ")", "&&", "<STR_LIT>", "Unexpected mask size", "<STR_LIT>", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "M1", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "M1", "[", "i", "]", ">=", "<NUM_LIT>", "&&", "M2", "[", "i", "]", ">=", "<NUM_LIT>", "&&", "M1", "[", "i", "]", "!=", "M2", "[", "i", "]", ")", "return", "false", ";", "return", "true", ";", "}", ";", "auto", "MergeMasks", "=", "[", "]", "(", "ArrayRef", "<", "int", ">", "Mask", ",", "MutableArrayRef", "<", "int", ">", "MergedMask", ")", "{", "assert", "(", "Mask", ".", "size", "(", ")", "==", "MergedMask", ".", "size", "(", ")", "&&", "<STR_LIT>", "Unexpected mask size", "<STR_LIT>", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "MergedMask", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "M", "=", "Mask", "[", "i", "]", ";", "if", "(", "M", "<", "<NUM_LIT>", ")", "continue", ";", "assert", "(", "(", "MergedMask", "[", "i", "]", "<", "<NUM_LIT>", "||", "MergedMask", "[", "i", "]", "==", "M", ")", "&&", "<STR_LIT>", "Unexpected mask element", "<STR_LIT>", ")", ";", "MergedMask", "[", "i", "]", "=", "M", ";", "}", "}", ";", "if", "(", "MatchMasks", "(", "InLaneMask", ",", "RepeatMask", ")", ")", "{", "MergeMasks", "(", "InLaneMask", ",", "RepeatMask", ")", ";", "continue", ";", "}", "std", "::", "swap", "(", "LaneSrcs", "[", "Lane", "]", "[", "<NUM_LIT>", "]", ",", "LaneSrcs", "[", "Lane", "]", "[", "<NUM_LIT>", "]", ")", ";", "ShuffleVectorSDNode", "::", "commuteMask", "(", "InLaneMask", ")", ";", "if", "(", "MatchMasks", "(", "InLaneMask", ",", "RepeatMask", ")", ")", "{", "MergeMasks", "(", "InLaneMask", ",", "RepeatMask", ")", ";", "continue", ";", "}", "return", "SDValue", "(", ")", ";", "}", "for", "(", "int", "Lane", "=", "<NUM_LIT>", ";", "Lane", "!=", "NumLanes", ";", "++", "Lane", ")", "{", "if", "(", "LaneSrcs", "[", "Lane", "]", "[", "<NUM_LIT>", "]", ">=", "<NUM_LIT>", ")", "continue", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "!=", "LaneSize", ";", "++", "i", ")", "{", "int", "M", "=", "Mask", "[", "(", "Lane", "*", "LaneSize", ")", "+", "i", "]", ";", "if", "(", "M", "<", "<NUM_LIT>", ")", "continue", ";", "if", "(", "RepeatMask", "[", "i", "]", "<", "<NUM_LIT>", ")", "RepeatMask", "[", "i", "]", "=", "M", "%", "LaneSize", ";", "if", "(", "RepeatMask", "[", "i", "]", "<", "Size", ")", "{", "if", "(", "RepeatMask", "[", "i", "]", "!=", "M", "%", "LaneSize", ")", "return", "SDValue", "(", ")", ";" ]

[ "return", "Res", ";" ]

[ "SIScheduleBlocks", "Blocks", "=", "BlockCreator", ".", "getBlocks", "(", "BlockVariant", ")", ";", "SIScheduleBlockScheduler", "Scheduler", "(", "DAG", ",", "ScheduleVariant", ",", "Blocks", ")", ";", "std", "::", "vector", "<", "SIScheduleBlock", "*", ">", "ScheduledBlocks", ";", "struct", "SIScheduleBlockResult", "Res", ";", "ScheduledBlocks", "=", "Scheduler", ".", "getBlocks", "(", ")", ";", "for", "(", "unsigned", "b", "=", "<NUM_LIT>", ";", "b", "<", "ScheduledBlocks", ".", "size", "(", ")", ";", "++", "b", ")", "{", "SIScheduleBlock", "*", "Block", "=", "ScheduledBlocks", "[", "b", "]", ";", "std", "::", "vector", "<", "SUnit", "*", ">", "SUs", "=", "Block", "->", "getScheduledUnits", "(", ")", ";", "for", "(", "SUnit", "*", "SU", ":", "SUs", ")", "Res", ".", "SUs", ".", "push_back", "(", "SU", "->", "NodeNum", ")", ";", "}", "Res", ".", "MaxSGPRUsage", "=", "Scheduler", ".", "getSGPRUsage", "(", ")", ";", "Res", ".", "MaxVGPRUsage", "=", "Scheduler", ".", "getVGPRUsage", "(", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_alignr_epi8", "(", "_", "_", "m256i", "_", "_", "W", ",", "_", "_", "mmask32", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m256i", "_", "_", "B", ",", "const", "int", "_", "_", "N", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_palignr256_mask", "(", "(", "_", "_", "v4di", ")", "_", "_", "A", ",", "(", "_", "_", "v4di", ")", "_", "_", "B", ",", "_", "_", "N", "*", "<NUM_LIT>", ",", "(", "_", "_", "v4di", ")", "_", "_", "W", ",", "(", "_", "_", "mmask32", ")", "_", "_", "U", ")", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "if", "(", "IsVFPPushPop", ")", "{", "RegsNeeded", "=", "NumBytes", "/", "<NUM_LIT>", ";", "RegClass", "=", "&", "ARM", "::", "DPRRegClass", ";", "}", "else", "{", "RegsNeeded", "=", "NumBytes", "/", "<NUM_LIT>", ";", "RegClass", "=", "&", "ARM", "::", "GPRRegClass", ";", "}", "SmallVector", "<", "MachineOperand", ",", "<NUM_LIT>", ">", "RegList", ";", "unsigned", "FirstRegEnc", "=", "-", "<NUM_LIT>", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "for", "(", "int", "i", "=", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "i", ">=", "RegListIdx", ";", "--", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "RegList", ".", "push_back", "(", "MO", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "!", "MO", ".", "isImplicit", "(", ")", "&&", "TRI", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", "<", "FirstRegEnc", ")", "FirstRegEnc", "=", "TRI", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "const", "MCPhysReg", "*", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "int", "CurRegEnc", "=", "FirstRegEnc", "-", "<NUM_LIT>", ";", "CurRegEnc", ">=", "<NUM_LIT>", "&&", "RegsNeeded", ";", "--", "CurRegEnc", ")", "{", "unsigned", "CurReg", "=", "RegClass", "->", "getRegister", "(", "CurRegEnc", ")", ";", "if", "(", "IsT1PushPop", "&&", "CurRegEnc", ">", "TRI", "->", "getEncodingValue", "(", "ARM", "::", "R7", ")", ")", "continue", ";", "if", "(", "!", "IsPop", ")", "{", "RegList", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "CurReg", ",", "false", ",", "false", ",", "false", ",", "false", ",", "true", ")", ")", ";", "--", "RegsNeeded", ";", "continue", ";", "}", "if", "(", "isCalleeSavedRegister", "(", "CurReg", ",", "CSRegs", ")", "||", "MI", "->", "getParent", "(", ")", "->", "computeRegisterLiveness", "(", "TRI", ",", "CurReg", ",", "MI", ")", "!=", "MachineBasicBlock", "::", "LQR_Dead", ")", "{", "if", "(", "IsVFPPushPop", ")", "return", "false", ";", "else", "continue", ";", "}", "RegList", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "CurReg", ",", "true", ",", "false", ",", "false", ",", "true", ")", ")", ";", "--", "RegsNeeded", ";", "}", "if", "(", "RegsNeeded", ">", "<NUM_LIT>", ")", "return", "false", ";", "for", "(", "int", "i", "=", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "i", ">=", "RegListIdx", ";", "--", "i", ")", "MI", "->", "RemoveOperand", "(", "i", ")", ";", "MachineInstrBuilder", "MIB", "(", "MF", ",", "&", "*", "MI", ")", ";", "for", "(", "int", "i", "=", "RegList", ".", "size", "(", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "--", "i", ")", "MIB", ".", "add", "(", "RegList", "[", "i", "]", ")", ";", "return", "true" ]

[ "}" ]

[ "vpminq_s32", "(", "int32x4_t", "a", ",", "int32x4_t", "b", ")", "{", "return", "_", "_", "builtin_aarch64_sminpv4si", "(", "a", ",", "b", ")", ";" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr" ]

[ "void", "X86AsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "bool", "Is16BitMode", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ";", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ",", "Is16BitMode", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "<NUM_LIT>", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "report_fatal_error", "(", "<STR_LIT>", "unexpected instruction to relax: ", "<STR_LIT>", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "Inst", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "static", "unsigned", "s390_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "struct", "loop", "*", "loop", ")", "{", "basic_block", "*", "bbs", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "unsigned", "mem_count", "=", "<NUM_LIT>", ";", "if", "(", "s390_tune", "<", "PROCESSOR_2097_Z10", ")", "return", "nunroll", ";", "if", "(", "unroll_only_small_loops", ")", "{", "const", "unsigned", "int", "small_threshold", "=", "<NUM_LIT>", ";", "if", "(", "loop", "->", "ninsns", ">", "small_threshold", ")", "return", "<NUM_LIT>", ";", "const", "unsigned", "int", "max_insns", "=", "optimize", ">=", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "nunroll", "=", "MIN", "(", "nunroll", ",", "max_insns", "/", "loop", "->", "ninsns", ")", ";", "}", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "subrtx_iterator", "::", "array_type", "array", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", "!=", "-", "<NUM_LIT>", ")", "{", "rtx", "set", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", "&&", "loop", "->", "ninsns", "<=", "BLOCK_MEM_OPS_LOOP_INSNS", "&&", "(", "(", "set", "=", "single_set", "(", "insn", ")", ")", "!=", "NULL_RTX", ")", "&&", "(", "(", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "BLKmode", "&&", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "BLKmode", "||", "SET_SRC", "(", "set", ")", "==", "const0_rtx", ")", ")", "||", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "COMPARE", "&&", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "<NUM_LIT>", ")", ")", "==", "BLKmode", "&&", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "<NUM_LIT>", ")", ")", "==", "BLKmode", ")", ")", ")", "{", "free", "(", "bbs", ")", ";", "return", "<NUM_LIT>", ";", "}", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", ")", "mem_count", "+=", "<NUM_LIT>", ";", "}", "free", "(", "bbs", ")", ";", "if", "(", "mem_count", "==", "<NUM_LIT>", ")", "return", "nunroll", ";", "switch", "(", "loop_depth", "(", "loop", ")", ")", "{", "case", "<NUM_LIT>", ":", "return", "MIN", "(", "nunroll", ",", "<NUM_LIT>", "/", "mem_count", ")", ";", "case", "<NUM_LIT>", ":", "return", "MIN", "(", "nunroll", ",", "<NUM_LIT>", "/", "mem_count", ")", ";", "default", ":", "return", "MIN", "(", "nunroll", ",", "<NUM_LIT>", "/", "mem_count", ")", ";", "}", "}" ]

[ "This", "target", "hook", "implementation", "for", "TARGET_LOOP_UNROLL_ADJUST", "calculates", "a", "new", "number", "struct", "loop", "*", "loop", "should", "be", "unrolled", "if", "tuned", "for", "cpus", "with", "a", "built-in", "stride", "prefetcher", ".", "The", "loop", "is", "analyzed", "for", "memory", "accesses", "by", "calling", "check_dpu", "for", "each", "rtx", "of", "the", "loop", ".", "Depending", "on", "the", "loop_depth", "and", "the", "amount", "of", "memory", "accesses", "a", "new", "number", "<", "=nunroll", "is", "returned", "to", "improve", "the", "behaviour", "of", "the", "hardware", "prefetch", "unit", "." ]

[ "<STR_LIT>", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::" ]

[ ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "FMODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "FMODE", "(", "match_operand", ":", "FMODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "FMODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "def", "SKXWriteResGroup220", ":", "SchedWriteRes", "<", "[", "SKXPort5", ",", "SKXPort6", ",", "SKXPort0156", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "neon_uimm4_bare", ",", "asmop", ">", "{" ]

[ "def", "_B", ":", "NeonI_STN_Lane", "<", "r", ",", "<NUM_LIT>", ",", "op0", ",", "!", "cast", "<", "RegisterOperand", ">", "(", "List", "#", "<STR_LIT>", ")", "," ]

[ "}" ]

[ "void", "X86COFFMachineModuleInfo", "::", "addExternalFunction", "(", "const", "StringRef", "&", "Name", ")", "{", "CygMingStubs", ".", "insert", "(", "Name", ")", ";" ]

[ "<FIXS>", "(", "match_operand", ":", "VAXint", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_mode_attr", "iprefx", "[", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "cc0", ")", "<BUGS>", "(", "match_operand", ":", "VAXint", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "raw_svector_ostream", "(", "Name", ")", "<<", "DL", "->", "getPrivateGlobalPrefix", "(", ")", "<<", "<STR_LIT>", "SJLJEH", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", ";", "return", "OutContext", ".", "GetOrCreateSymbol", "(", "Name", ")", ";" ]

[ "back", "(", ")", ";" ]

[ "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "TM", ".", "getInstrInfo", "(", ")", ",", "*", "TM", ".", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ")", ";", "SmallVector", "<", "MCFixup", ",", "<NUM_LIT>", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "<NUM_LIT>", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "MCObjectStreamer", "&", "ObjStreamer", "=", "(", "MCObjectStreamer", "&", ")", "OutStreamer", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "EncodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "TM", ".", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "CodeStream", ".", "flush", "(", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "<NUM_LIT>", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", "." ]

[ "<FIXS>", "const", "Register", "DstReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "Register", "Op1Reg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "Register", "Op2Reg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_UREM", ")", "&&", "<STR_LIT>", "unexpected instruction", "<STR_LIT>", ")", ";", "<BUGS>", "const", "unsigned", "DstReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "unsigned", "Op1Reg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "unsigned", "Op2Reg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGE>", "const", "LLT", "RegTy", "=", "MRI", ".", "getType", "(", "DstReg", ")", ";", "assert", "(", "RegTy", "==", "MRI", ".", "getType", "(", "Op1Reg", ")", "&&", "RegTy", "==", "MRI", ".", "getType", "(", "Op2Reg", ")", "&&" ]

[ "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "return", "AArch64_AM", ":", ":", "isSVEMaskOfIdenticalElements", "<", "int16_t", ">", "(", "Val", ")", ";" ]

[ "let", "MCOperandPredicate", "=", "[", "{", "if", "(", "!", "MCOp", ".", "isImm", "(", ")", ")", "return", "false", ";", "int64_t", "Val", "=", "AArch64_AM", ":", ":", "decodeLogicalImmediate", "(", "MCOp", ".", "getImm", "(", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "SDValue", "S", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "MemAddr", ",", "LocPI", ")", ";", "<FIXE>" ]

[ "}", "else", "{", "MachinePointerInfo", "LocPI", "=", "MachinePointerInfo", "::", "getStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "LocMemOffset", ")", ";", "<BUGS>", "SDValue", "S", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "MemAddr", ",", "LocPI", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "MemOpChains", ".", "push_back", "(", "S", ")", ";", "}", "continue", ";" ]

[ "<STR_LIT>", ")", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>" ]

[ "match_code", "<STR_LIT>", ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "and", "(" ]

[ "}" ]

[ "assert", "(", "isConstantPoolImm", "(", ")", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "return", "Imm", ".", "Val", ";" ]

[ "<NUM_LIT>", ";" ]

[ "static", "void", "emit_save_or_restore_local_in_regs", "(", "rtx", "base", ",", "int", "offset", ",", "sorr_act_t", "action", ")", "{", "if", "(", "offset", "<", "-", "<NUM_LIT>", "||", "offset", "+", "<NUM_LIT>", "*", "UNITS_PER_WORD", ">", "<NUM_LIT>", ")", "{", "base", "=", "emit_adjust_base_to_offset", "(", "base", ",", "offset", ")", ";", "offset", "=" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "gen_int_mode", "(", "-", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "SImode", ")" ]

[ "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", ")", "(", "cond_exec", "(", "ne", ":", "CC", "(", "reg", ":", "CC", "CC_REGNUM", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "{" ]

[ "TII", ".", "loadRegFromStack", "(", "MBB", ",", "I", ",", "VR1", ",", "FI", ",", "RC", ",", "&", "RegInfo", ",", "RegSize", ")", ";" ]

[ "Register", "Dst", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "FI", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "Register", "Lo", "=", "RegInfo", ".", "getSubReg", "(", "Dst", ",", "Mips", "::", "sub_lo", ")", ";", "Register", "Hi", "=", "RegInfo", ".", "getSubReg", "(", "Dst", ",", "Mips", "::", "sub_hi", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ";", "TII", ".", "loadRegFromStack", "(", "MBB", ",", "I", ",", "VR0", ",", "FI", ",", "RC", ",", "&", "RegInfo", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "Desc", ",", "Lo", ")", ".", "addReg", "(", "VR0", ",", "RegState", "::", "Kill", ")", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "_", "_", "arm_vrev64q_s16", "(", "int16x8_t", "_", "_", "a", ")", "{", "return", "_", "_", "builtin_mve_vrev64q_sv8hi", "(", "_", "_", "a", ")", ";" ]

[ "}" ]

[ "if", "(", "Offset", "<", "<NUM_LIT>", ")", "{", "O", "<<", "<STR_LIT>", "-0x", "<STR_LIT>", ";", "O", ".", "write_hex", "(", "-", "Offset", ")", ";", "}", "else", "{", "O", "<<", "<STR_LIT>", "+0x", "<STR_LIT>", ";", "O", ".", "write_hex", "(", "Offset", ")", ";" ]

[ "lib_path", "=", "locate_lib", "(", "name", ")", ";" ]

[ "char", "*", "lib_path", ";", "if", "(", "strcmp", "(", "name", ",", "<STR_LIT>", "c", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "NULL", ";", "if", "(", "strcmp", "(", "name", ",", "<STR_LIT>", "m", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "NULL", ";" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=" ]

[ ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ";" ]

[ "foreach", "U", "=", "<NUM_LIT>", "-", "<NUM_LIT>", "in", "{", "defvar", "Suffix", "=", "!", "if", "(", "U", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ";", "defvar", "S", "=", "!", "if", "(", "U" ]

[ "eraseFromParent", "(", ")", ";" ]

[ "FunctionType", "*", "ResumeFTy", "=", "FunctionType", "::", "get", "(", "IRB", ".", "getVoidTy", "(", ")", ",", "IRB", ".", "getInt8PtrTy", "(", ")", ",", "false", ")", ";", "ResumeF", "=", "getEmscriptenFunction", "(", "ResumeFTy", ",", "<STR_LIT>", "__resumeException", "<STR_LIT>", ",", "&", "M", ")", ";", "FunctionType", "*", "EHTypeIDTy", "=", "FunctionType", "::", "get", "(", "IRB", ".", "getInt32Ty", "(", ")", ",", "IRB", ".", "getInt8PtrTy", "(", ")", ",", "false", ")", ";", "EHTypeIDF", "=", "getEmscriptenFunction", "(", "EHTypeIDTy", ",", "<STR_LIT>", "llvm_eh_typeid_for", "<STR_LIT>", ",", "&", "M", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "isDeclaration", "(", ")", ")", "continue", ";", "Changed", "|=", "runEHOnFunction", "(", "F", ")", ";", "}", "}", "if", "(", "DoSjLj", ")", "{", "Changed", "=", "true", ";", "if", "(", "LongjmpF", ")", "{", "EmLongjmpJmpbufF", "=", "getEmscriptenFunction", "(", "LongjmpF", "->", "getFunctionType", "(", ")", ",", "<STR_LIT>", "emscripten_longjmp_jmpbuf", "<STR_LIT>", ",", "&", "M", ")", ";", "LongjmpF", "->", "replaceAllUsesWith", "(", "EmLongjmpJmpbufF", ")", ";", "}", "if", "(", "SetjmpF", ")", "{", "FunctionType", "*", "SetjmpFTy", "=", "SetjmpF", "->", "getFunctionType", "(", ")", ";", "FunctionType", "*", "FTy", "=", "FunctionType", "::", "get", "(", "Type", "::", "getInt32PtrTy", "(", "C", ")", ",", "{", "SetjmpFTy", "->", "getParamType", "(", "<NUM_LIT>", ")", ",", "IRB", ".", "getInt32Ty", "(", ")", ",", "Type", "::", "getInt32PtrTy", "(", "C", ")", ",", "IRB", ".", "getInt32Ty", "(", ")", "}", ",", "false", ")", ";", "SaveSetjmpF", "=", "getEmscriptenFunction", "(", "FTy", ",", "<STR_LIT>", "saveSetjmp", "<STR_LIT>", ",", "&", "M", ")", ";", "FTy", "=", "FunctionType", "::", "get", "(", "IRB", ".", "getInt32Ty", "(", ")", ",", "{", "IRB", ".", "getInt32Ty", "(", ")", ",", "Type", "::", "getInt32PtrTy", "(", "C", ")", ",", "IRB", ".", "getInt32Ty", "(", ")", "}", ",", "false", ")", ";", "TestSetjmpF", "=", "getEmscriptenFunction", "(", "FTy", ",", "<STR_LIT>", "testSetjmp", "<STR_LIT>", ",", "&", "M", ")", ";", "FTy", "=", "FunctionType", "::", "get", "(", "IRB", ".", "getVoidTy", "(", ")", ",", "{", "IRB", ".", "getInt32Ty", "(", ")", ",", "IRB", ".", "getInt32Ty", "(", ")", "}", ",", "false", ")", ";", "EmLongjmpF", "=", "getEmscriptenFunction", "(", "FTy", ",", "<STR_LIT>", "emscripten_longjmp", "<STR_LIT>", ",", "&", "M", ")", ";", "SmallPtrSet", "<", "Function", "*", ",", "<NUM_LIT>", ">", "SetjmpUsers", ";", "for", "(", "User", "*", "U", ":", "SetjmpF", "->", "users", "(", ")", ")", "{", "auto", "*", "UI", "=", "cast", "<", "Instruction", ">", "(", "U", ")", ";", "SetjmpUsers", ".", "insert", "(", "UI", "->", "getFunction", "(", ")", ")", ";", "}", "for", "(", "Function", "*", "F", ":", "SetjmpUsers", ")", "runSjLjOnFunction", "(", "*", "F", ")", ";", "}", "}", "if", "(", "!", "Changed", ")", "{", "if", "(", "ResumeF", ")", "ResumeF", "->", "eraseFromParent", "(", ")", ";", "if", "(", "EHTypeIDF", ")", "EHTypeIDF", "->" ]

[ "}" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "_", "_", "mmask64", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_avg_epu8", "(", "_", "_", "m512i", "_", "_", "A", ",", "_", "_", "m512i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pavgb512_mask", "(", "(", "_", "_", "v64qi", ")", "_", "_", "A", ",", "(", "_", "_", "v64qi", ")", "_", "_", "B", ",", "(", "_", "_", "v64qi", ")", "_", "mm512_setzero_si512", "(", ")", ",", "(" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>" ]

[ "}" ]

[ "int", "c4x_U_constraint", "(", "rtx", "op", ")", "{", "return", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ";" ]

[ "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{" ]

[ "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands" ]

[ "}" ]

[ "if", "(", "TARGET_E500_DOUBLE", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "mode", "==", "TImode", "||", "mode", "==", "DDmode", "||", "mode", "==", "TDmode", "||", "mode", "==", "PTImode", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DFmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TFmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "TFmode", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "PTImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DDmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TDmode", ")", ")", "return", "true", ";", "}", "if", "(", "TARGET_SPE", "&&", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "mode", "==", "SImode", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "SPE_VECTOR_MODE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "def", "A2_addh_h16_sat_hl", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_bd6011", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3" ]

[ "DI" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":" ]

[ "bool", "n8_consumed_by_ex_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "rtx", "use_rtx", ";", "switch", "(", "get_attr_type", "(", "consumer", ")", ")", "{", "case", "TYPE_ALU", ":", "if", "(", "movd44_even_dep_p", "(", "consumer", ",", "def_reg", ")", ")", "return", "true", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MAC", ":", "use_rtx", "=", "extract_mac_non_acc_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "consumer", ")", ")", "use_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "consumer", ",", "<NUM_LIT>", ")", ")", ";", "else", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_BRANCH", ":", "use_rtx", "=", "extract_branch_condition_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "if", "(", "!", "post_update_insn_p", "(", "consumer", ")", "&&", "!", "immed_offset_p", "(", "extract_mem_rtx", "(", "consumer", ")", ")", ")", "return", "false", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_STORE_MULTIPLE", ":", "use_rtx", "=", "extract_nth_access_rtx", "(", "consumer", ",", "<NUM_LIT>", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ";", "}" ]

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "EX", "." ]

[ "}" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "In", ",", "Matrix", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "}", "SDValue", "NibbleMask", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "In", ",", "NibbleMask", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "VT", ",", "In", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ")", ";", "const", "int", "LoLUT", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "const", "int", "HiLUT", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "LoMaskElts", ",", "HiMaskElts", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumElts", ";", "++", "i", ")", "{", "LoMaskElts", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "LoLUT", "[", "i", "%", "<NUM_LIT>", "]", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "HiMaskElts", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "HiLUT", "[", "i", "%", "<NUM_LIT>", "]", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "}", "SDValue", "LoMask", "=", "DAG", ".", "getBuildVector", "(", "VT", ",", "DL", ",", "LoMaskElts", ")", ";", "SDValue", "HiMask", "=", "DAG", ".", "getBuildVector", "(", "VT", ",", "DL", ",", "HiMaskElts", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "LoMask", ",", "Lo", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "HiMask", ",", "Hi", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "VT", ",", "Lo", ",", "Hi", ")", ";" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "true", ";", "}" ]

[ "bool", "HexagonTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LSBaseSDNode", "*", "LSN", "=", "dyn_cast", "<", "LSBaseSDNode", ">", "(", "N", ")", ";", "if", "(", "!", "LSN", ")", "return", "false", ";", "EVT", "VT", "=", "LSN", "->", "getMemoryVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "bool", "IsLegalType", "=", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", "||", "Subtarget", ".", "isHVXVectorType", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "if", "(", "!", "IsLegalType", ")", "return", "false", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "return", "false", ";", "Base", "=", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Offset", "=", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", ")", "return", "false", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "int32_t", "V", "=", "cast", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "Subtarget", ".", "getInstrInfo", "(", ")", "->", "isValidAutoIncImm", "(", "VT", ",", "V", ")", ";", "}" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "(", ")", ";" ]

[ "FunctionPass", "*", "llvm", "::", "createPPCTOCRegDepsPass", "(", ")", "{", "return", "new", "PPCTOCRegDeps" ]

[ "if", "(", "Constraint", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", "{", "'", "&&", "tolower", "(", "Constraint", "[", "<NUM_LIT>", "]", ")", "==", "'", "s", "'", "&&", "tolower", "(", "Constraint", "[", "<NUM_LIT>", "]", ")", "==", "'", "t", "'", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", "(", "'", "&&", "(", "Constraint", "[", "<NUM_LIT>", "]", ">=", "'", "<NUM_LIT>", "'", "&&", "Constraint", "[", "<NUM_LIT>", "]", "<=", "'", "<NUM_LIT>", "'", ")", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", ")", "'", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", "}", "'", ")", "{" ]

[ "default", ":", "break", ";", "case", "'", "q", "'", ":", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "||", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64RegClass", ")", ";", "break", ";", "}", "case", "'", "Q", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32_ABCDRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16_ABCDRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8_ABCD_LRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64_ABCDRegClass", ")", ";", "break", ";", "case", "'", "r", "'", ":", "case", "'", "l", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", "||", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64RegClass", ")", ";", "case", "'", "R", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8_NOREXRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16_NOREXRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32_NOREXRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64_NOREXRegClass", ")", ";", "case", "'", "f", "'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP80RegClass", ")", ";", "case", "'", "y", "'", ":", "if", "(", "!", "Subtarget", "->", "hasMMX", "(", ")", ")", "break", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR64RegClass", ")", ";", "case", "'", "Y", "'", ":", "if", "(", "!", "Subtarget", "->", "hasSSE2", "(", ")", ")", "break", ";", "case", "'", "x", "'", ":", "if", "(", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", "break", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "i32", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "FR32RegClass", ")", ";", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "i64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "FR64RegClass", ")", ";", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR128RegClass", ")", ";", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v16i16", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR256RegClass", ")", ";", "case", "MVT", "::", "v8f64", ":", "case", "MVT", "::", "v16f32", ":", "case", "MVT", "::", "v16i32", ":", "case", "MVT", "::", "v8i64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "}", "break", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Res", ";", "Res", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "!", "Res", ".", "second", ")", "{" ]

[ "B", ",", "_", "_", "m512h", "_", "_", "C", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_fmadd_pch", "(", "_", "_", "m512h", "_", "_", "A", ",", "_", "_", "m512h", "_", "_" ]

[ "}", "else", "report_fatal_error", "(", "<STR_LIT>", "Can't load this register from stack slot", "<STR_LIT>", ")", ";" ]

[ "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "[", "(", "match_operand", ":", "VSDQ_HSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VSDQ_HSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VSDQ_HSI" ]

[ "bool", "ARMTargetLowering", "::", "isVectorLoadExtDesirable", "(", "SDValue", "ExtVal", ")", "const", "{", "EVT", "VT", "=", "ExtVal", ".", "getValueType", "(", ")", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "ExtVal", "->", "use_empty", "(", ")", "||", "!", "ExtVal", "->", "use_begin", "(", ")", "->", "isOnlyUserOf", "(", "ExtVal", ".", "getNode", "(", ")", ")", ")", "return", "true", ";", "SDNode", "*", "U", "=", "*", "ExtVal", "->", "use_begin", "(", ")", ";", "if", "(", "(", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "||", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "||", "U", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", "false", ";", "return", "true", ";", "}" ]

[ "Return", "true", "if", "folding", "a", "vector", "load", "into", "ExtVal", "(", "a", "sign", ",", "zero", ",", "or", "any", "extend", "node", ")", "is", "profitable", "." ]

[ "BuildMI", "(", "MBB", ",", "MI", ".", "getIterator", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "Dst", ")", ".", "addReg", "(", "Reg", ",", "getUndefRegState", "(", "SrcVec", "->", "isUndef", "(", ")", ")", ")", ";" ]

[ "const", "MachineOperand", "*", "SrcVec", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src", ")", ";", "int", "Offset", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", "->", "getImm", "(", ")", ";", "unsigned", "Reg", ";", "std", "::", "tie", "(", "Reg", ",", "Offset", ")", "=", "computeIndirectRegAndOffset", "(", "SrcVec", "->", "getReg", "(", ")", ",", "Offset", ")", ";", "const", "MachineOperand", "*", "Idx", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "idx", ")", ";", "if", "(", "Idx", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "NoRegister", ")", "{" ]

[ "<STR_LIT>", ")", ")" ]

[ "(", "and", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_test", "<STR_LIT>", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_test" ]

[ "src2", ")", ",", "<STR_LIT>", ">", ";" ]

[ "def", "TFRI64_V2_ext", ":", "ALU64_rr", "<", "(", "outs", "DoubleRegs", ":", "$", "dst", ")", ",", "(", "ins", "s8Ext", ":", "$", "src1", ",", "s8Imm", ":", "$" ]

[ "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "?", "int_size_in_bytes", "(", "type", ")", ">", "<NUM_LIT>", ":", "TYPE_ALIGN", "(", "type", ")", ">", "<NUM_LIT>", "*", "BITS_PER_UNIT", ")", "{" ]

[ "tree", "ptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "tree", "addr", "=", "std_gimplify_va_arg_expr", "(", "valist", ",", "ptrtype", ",", "pre_p", ",", "post_p", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}" ]

[ "return", "<NUM_LIT>", ";" ]

[ "elem", "->", "prev", "=", "data_area_stack", ";", "elem", "->", "data_area", "=", "data_area", ";", "data_area_stack", "=", "elem", ";" ]

[ "false", ";" ]

[ "bool", "isFPCloseToIncomingSP", "(", ")", "const", "override", "{", "return" ]

[ "BI", "CARRY", ")", ")" ]

[ "(", "pc", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":" ]

[ "else", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected ARM constantpool value type!!", "<STR_LIT>", ")", ";" ]

[ "ARMConstantPoolValue", "*", "ACPV", "=", "static_cast", "<", "ARMConstantPoolValue", "*", ">", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "unsigned", "PCLabelId", "=", "AFI", "->", "createPICLabelUId", "(", ")", ";", "ARMConstantPoolValue", "*", "NewCPV", "=", "nullptr", ";", "if", "(", "ACPV", "->", "isGlobalValue", "(", ")", ")", "NewCPV", "=", "ARMConstantPoolConstant", "::", "Create", "(", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getGV", "(", ")", ",", "PCLabelId", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "ACPV", "->", "isExtSymbol", "(", ")", ")", "NewCPV", "=", "ARMConstantPoolSymbol", "::", "Create", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ",", "cast", "<", "ARMConstantPoolSymbol", ">", "(", "ACPV", ")", "->", "getSymbol", "(", ")", ",", "PCLabelId", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "ACPV", "->", "isBlockAddress", "(", ")", ")", "NewCPV", "=", "ARMConstantPoolConstant", "::", "Create", "(", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getBlockAddress", "(", ")", ",", "PCLabelId", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "ACPV", "->", "isLSDA", "(", ")", ")", "NewCPV", "=", "ARMConstantPoolConstant", "::", "Create", "(", "MF", ".", "getFunction", "(", ")", ",", "PCLabelId", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "ACPV", "->", "isMachineBasicBlock", "(", ")", ")", "NewCPV", "=", "ARMConstantPoolMBB", "::", "Create", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ",", "cast", "<", "ARMConstantPoolMBB", ">", "(", "ACPV", ")", "->", "getMBB", "(", ")", ",", "PCLabelId", ",", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "DAG", ".", "getConstant", "(", "X86", "::", "COND_O", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "<FIXE>" ]

[ "SDValue", "SetCC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i8", ",", "<BUGS>", "DAG", ".", "getConstant", "(", "X86", "::", "COND_O", ",", "MVT", "::", "i32", ")", ",", "<BUGE>", "SDValue", "(", "Sum", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "DL", ",", "N", "->", "getVTList", "(", ")", ",", "Sum", ",", "SetCC", ")", ";" ]

[ "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "isSub", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "Ra", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "}" ]

[ "getSymbol", "(", "GV", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "O", ")", ";" ]