Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "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", "=", "<NUM_LIT>", ";", "break", ";", "}", "case", "MCFragment", "::", "FT_Relaxable", ":", "{", "auto", "&", "RF", "=", "cast", "<", "MCRelaxableFragment", ">", "(", "*", "K", ")", ";", "auto", "&", "Inst", "=", "const_cast", "<", "MCInst", "&", ">", "(", "RF", ".", "getInst", "(", ")", ")", ";", "while", "(", "Size", ">", "<NUM_LIT>", "&&", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Inst", ")", "<", "<NUM_LIT>", ")", "{", "MCInst", "*", "Nop", "=", "new", "(", "Asm", ".", "getContext", "(", ")", ")", "MCInst", ";", "Nop", "->", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Nop", ")", ")", ";", "Size", "-=", "<NUM_LIT>", ";", "if", "(", "!", "HexagonMCChecker", "(", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ",", "Inst", ",", "*", "Asm", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ".", "check", "(", ")", ")", "{", "Inst", ".", "erase", "(", "Inst", ".", "end", "(", ")", "-", "<NUM_LIT>", ")", ";", "Size", "=", "<NUM_LIT>", ";", "}", "}", "bool", "Error", "=", "HexagonMCShuffle", "(", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ")", ";", "(", "void", ")", "Error", ";", "ReplaceInstruction", "(", "Asm", ".", "getEmitter", "(", ")", ",", "RF", ",", "Inst", ")", ";", "Layout", ".", "invalidateFragmentsFrom", "(", "&", "RF", ")", ";", "Size", "=", "<NUM_LIT>", ";", "break", ";", "}", "}", "}", "}", "}", "}", "}", "}" ]

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

[ "<STR_LIT>", ";" ]

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sqrt", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "SrcTy", "VPR128", ":", "$", "Rm", ")", ")", ")", ")", ")", ")", ",", "(", "INST", "(", "SUBREG_TO_REG", "(", "i64", "<NUM_LIT>", ")", ",", "VPR64", ":", "$", "src", ",", "sub_64", ")", ",", "VPR128", ":", "$", "Rn", ",", "VPR128", ":", "$", "Rm", ")", ">", ";" ]

[ "class", "NarrowHighHalfPat", "<", "Instruction", "INST", ",", "ValueType", "DstTy", ",", "ValueType", "SrcTy", ",", "SDPatternOperator", "coreop", ">", ":", "Pat", "<", "(", "Neon_combine_2D", "(", "v1i64", "VPR64", ":", "$", "src", ")", ",", "(", "v1i64", "(", "bitconvert", "(", "DstTy", "(", "coreop", "(", "SrcTy", "VPR128", ":", "$", "Rn", ")", "," ]

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

[ "static", "int", "mn10300_memory_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "iclass", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "iclass", ";", "if", "(", "rclass", "==", "FP_REGS", ")", "return", "<NUM_LIT>", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "static", "void", "ix86_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "HOST_WIDE_INT", "bytes", ",", "words", ";", "int", "nregs", ";", "if", "(", "!", "cum", "->", "caller", "&&", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "return", ";", "if", "(", "mode", "==", "BLKmode", ")", "bytes", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "words", "=", "CEIL", "(", "bytes", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "type", ")", "mode", "=", "type_natural_mode", "(", "type", ",", "NULL", ",", "false", ")", ";", "if", "(", "(", "type", "&&", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "||", "POINTER_BOUNDS_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "cum", "->", "bnds_in_bt", ")", "{", "cum", "->", "bnds_in_bt", "--", ";", "return", ";", "}", "if", "(", "cum", "->", "force_bnd_pass", ")", "cum", "->", "force_bnd_pass", "--", ";", "cum", "->", "bnd_regno", "++", ";", "return", ";", "}", "cum", "->", "bnds_in_bt", "=", "<NUM_LIT>", ";", "if", "(", "cum", "->", "force_bnd_pass", ")", "{", "cum", "->", "bnd_regno", "+=", "cum", "->", "force_bnd_pass", ";", "cum", "->", "force_bnd_pass", "=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "enum", "calling_abi", "call_abi", "=", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ";", "if", "(", "call_abi", "==", "MS_ABI", ")", "nregs", "=", "function_arg_advance_ms_64", "(", "cum", ",", "bytes", ",", "words", ")", ";", "else", "nregs", "=", "function_arg_advance_64", "(", "cum", ",", "mode", ",", "type", ",", "words", ",", "named", ")", ";", "}", "else", "nregs", "=", "function_arg_advance_32", "(", "cum", ",", "mode", ",", "type", ",", "bytes", ",", "words", ")", ";", "if", "(", "cum", "->", "stdarg", ")", "cum", "->", "force_bnd_pass", "=", "nregs", ";", "if", "(", "!", "nregs", ")", "cum", "->", "bnds_in_bt", "=", "chkp_type_bounds_count", "(", "type", ")", ";", "}" ]

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

[ "MCSection", "*", "GBZ80TargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "Kind", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "getExplicitSectionGlobal not yet implemented!", "<STR_LIT>", ")", ";", "}" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

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

[ "IRB", ".", "CreateStore", "(", "getAddrSizeInt", "(", "M", ",", "<NUM_LIT>", ")", ",", "ThrewGV", ")", ";", "SmallVector", "<", "Value", "*", ",", "<NUM_LIT>", ">", "Args", ";", "Args", ".", "push_back", "(", "CI", "->", "getCalledOperand", "(", ")", ")", ";", "Args", ".", "append", "(", "CI", "->", "arg_begin", "(", ")", ",", "CI", "->", "arg_end", "(", ")", ")", ";", "CallInst", "*", "NewCall", "=", "IRB", ".", "CreateCall", "(", "getInvokeWrapper", "(", "CI", ")", ",", "Args", ")", ";", "NewCall", "->", "takeName", "(", "CI", ")", ";", "NewCall", "->", "setCallingConv", "(", "CallingConv", "::", "WASM_EmscriptenInvoke", ")", ";", "NewCall", "->", "setDebugLoc", "(", "CI", "->", "getDebugLoc", "(", ")", ")", ";", "SmallVector", "<", "AttributeSet", ",", "<NUM_LIT>", ">", "ArgAttributes", ";", "const", "AttributeList", "&", "InvokeAL", "=", "CI", "->", "getAttributes", "(", ")", ";", "ArgAttributes", ".", "push_back", "(", "AttributeSet" ]

[ "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "LDtocL", ")", ",", "DestReg", ")", ".", "addGlobalAddress", "(", "GV", ")", ".", "addReg", "(", "HighPartReg", ")", ";" ]

[ "unsigned", "PPCFastISel", "::", "PPCMaterializeGV", "(", "const", "GlobalValue", "*", "GV", ",", "MVT", "VT", ")", "{", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Non-address!", "<STR_LIT>", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ";", "unsigned", "DestReg", "=", "createResultReg", "(", "RC", ")", ";", "CodeModel", "::", "Model", "CModel", "=", "TM", ".", "getCodeModel", "(", ")", ";", "if", "(", "GV", "->", "isThreadLocal", "(", ")", ")", "return", "<NUM_LIT>", ";", "PPCFuncInfo", "->", "setUsesTOCBasePtr", "(", ")", ";", "if", "(", "CModel", "==", "CodeModel", "::", "Small", "||", "CModel", "==", "CodeModel", "::", "JITDefault", ")", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "LDtoc", ")", ",", "DestReg", ")", ".", "addGlobalAddress", "(", "GV", ")", ".", "addReg", "(", "PPC", "::", "X2", ")", ";", "else", "{", "unsigned", "HighPartReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "ADDIStocHA", ")", ",", "HighPartReg", ")", ".", "addReg", "(", "PPC", "::", "X2", ")", ".", "addGlobalAddress", "(", "GV", ")", ";", "if", "(", "CModel", "==", "CodeModel", "::", "Large", "||", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", "->", "isFunctionTy", "(", ")", "&&", "!", "GV", "->", "isStrongDefinitionForLinker", "(", ")", ")", "||", "GV", "->", "isDeclaration", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", "||", "GV", "->", "hasAvailableExternallyLinkage", "(", ")", ")", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", "," ]

[ "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "unsigned", "SlotSize", "=", "RegInfo", "->", "getSlotSize", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "<NUM_LIT>", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfo", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "SpillSlotOffset", "-=", "std", "::", "abs", "(", "SpillSlotOffset", ")", "%", "RC", "->", "getAlignment", "(", ")", ";", "SpillSlotOffset", "-=", "RC", "->", "getSize", "(", ")", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", "->", "ensureMaxAlignment", "(", "RC", "->", "getAlignment", "(", ")", ")", ";", "}", "return", "true", ";", "}" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

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

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

[ "<FIXS>", "}", "if", "(", "isTypeLegal", "(", "MVT", "::", "f32", ")", ")", "{", "if", "(", "UseX87", "&&", "(", "getRegClassFor", "(", "MVT", "::", "f32", ")", "==", "&", "X86", "::", "RFP32RegClass", ")", ")", "{", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "}", "else", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "isTypeLegal", "(", "MVT", "::", "f64", ")", ")", "{", "if", "(", "UseX87", "&&", "getRegClassFor", "(", "MVT", "::", "f64", ")", "==", "&", "X86", "::", "RFP64RegClass", ")", "{", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "}", "else", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "FCOS", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSINCOS", ",", "VT", ",", "Expand", ")", ";", "}", "<BUGS>", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "+", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "addLegalFPImmediate", "(", "APFloat", "(", "-", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}" ]

[ "[", "<NUM_LIT>", "]", ")" ]

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "{", "split_di", "(", "operands", ",", "<NUM_LIT>", ",", "operands", "+", "<NUM_LIT>", ",", "operands", "+", "<NUM_LIT>", ")", "if", "(", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands" ]

[ "<FIXS>", "getTargetStreamer", "(", ")", "->", "EmitAMDGPUSymbolType", "(", "<FIXE>" ]

[ "if", "(", "MFI", "->", "isEntryFunction", "(", ")", "&&", "STM", ".", "isAmdCodeObjectV2", "(", "*", "MF", ")", ")", "{", "SmallString", "<NUM_LIT>", ">", "SymbolName", ";", "getNameWithPrefix", "(", "SymbolName", ",", "MF", "->", "getFunction", "(", ")", ")", ",", "<BUGS>", "getTargetStreamer", "(", ")", ".", "EmitAMDGPUSymbolType", "(", "<BUGE>", "SymbolName", ",", "ELF", "::", "STT_AMDGPU_HSA_KERNEL", ")", ";", "}" ]

[ "{", "}", ")", ")", ";" ]

[ "I", "->", "setMetadata", "(", "<STR_LIT>", "amdgpu.uniform", "<STR_LIT>", ",", "MDNode", "::", "get", "(", "I", "->", "getContext", "(", ")", "," ]

[ "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "bool", "SpillVGPRToAGPR", "=", "ST", ".", "hasMAIInsts", "(", ")", "&&", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "&&", "EnableSpillVGPRToAGPR", ";", "if", "(", "SpillVGPRToAGPR", ")", "{", "BitVector", "SpillFIs", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ",", "false", ")", ";", "BitVector", "NonVGPRSpillFIs", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ",", "false", ")", ";", "bool", "SeenDbgInstr", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_early_inc_range", "(", "MBB", ")", ")", "{", "int", "FrameIndex", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "SeenDbgInstr", "=", "true", ";", "if", "(", "TII", "->", "isVGPRSpill", "(", "MI", ")", ")", "{", "unsigned", "FIOp", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "getIndex", "(", ")", ";", "Register", "VReg", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", "->", "getReg", "(", ")", ";", "if", "(", "FuncInfo", "->", "allocateVGPRSpillToAGPR", "(", "MF", ",", "FI", ",", "TRI", "->", "isAGPR", "(", "MRI", ",", "VReg", ")", ")", ")", "{", "RS", "->", "enterBasicBlock", "(", "MBB", ")", ";", "TRI", "->", "eliminateFrameIndex", "(", "MI", ",", "<NUM_LIT>", ",", "FIOp", ",", "RS", ")", ";", "SpillFIs", ".", "set", "(", "FI", ")", ";", "continue", ";", "}", "}", "else", "if", "(", "TII", "->", "isStoreToStackSlot", "(", "MI", ",", "FrameIndex", ")", "||", "TII", "->", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", "if", "(", "!", "MFI", ".", "isFixedObjectIndex", "(", "FrameIndex", ")", ")", "NonVGPRSpillFIs", ".", "set", "(", "FrameIndex", ")", ";", "}", "}", "for", "(", "unsigned", "FI", ":", "SpillFIs", ".", "set_bits", "(", ")", ")", "if", "(", "!", "NonVGPRSpillFIs", ".", "test", "(", "FI", ")", ")", "FuncInfo", "->", "setVGPRToAGPRSpillDead", "(", "FI", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MCPhysReg", "Reg", ":", "FuncInfo", "->", "getVGPRSpillAGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "FuncInfo", "->", "getAGPRSpillVGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MBB", ".", "sortUniqueLiveIns", "(", ")", ";", "if", "(", "!", "SpillFIs", ".", "empty", "(", ")", "&&", "SeenDbgInstr", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "SpillFIs", "[", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", "]", ")", "{", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "ChangeToRegister", "(", "Register", "(", ")", ",", "false", ")", ";", "}", "}", "}", "}", "}", "bool", "HaveSGPRToVMemSpill", "=", "FuncInfo", "->", "removeDeadFrameIndices", "(", "MFI", ",", "true", ")", ";", "assert", "(", "allSGPRSpillsAreDead", "(", "MF", ")", "&&", "<STR_LIT>", "SGPR spill should have been removed in SILowerSGPRSpills", "<STR_LIT>", ")", ";", "if", "(", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "<STR_LIT>", "RegScavenger required if spilling", "<STR_LIT>", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FuncInfo", "->", "getScavengeFI", "(", "MFI", ",", "*", "TRI", ")", ")", ";", "if", "(", "HaveSGPRToVMemSpill", "&&", "allocateScavengingFrameIndexesNearIncomingSP", "(", "MF", ")", ")", "{", "RS", "->", "addScavengingFrameIndex", "(", "MFI", ".", "CreateStackObject", "(", "<NUM_LIT>", ",", "Align", "(", "<NUM_LIT>", ")", ",", "false", ")", ")", ";", "}", "}", "}" ]

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

[ "INTVAL", "(", "op", ")", "<", "=", "<NUM_LIT>", ")" ]

[ "&", "&", "INTVAL", "(", "op", ")", ">", "=", "<NUM_LIT>", "&", "&" ]

[ "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";" ]

[ "MI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR64RegClassID", ",", "Rs", ")", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR64RegClassID", ",", "Rs", ")", ")", ")", ";" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "reg", "}", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HILO", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "HILO", "[", "(", "any_div", ":", "GPR", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_SET_HILO", ")", ")", "]" ]

[ "<STR_LIT>", ")" ]

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

[ "Opc", "=", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", "?", "ARM", "::", "tPICADD", ":", "ARM", "::", "PICADD", ";" ]

[ "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", "(", "<NUM_LIT>", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "unsigned", "GlobalBaseReg", "=", "AFI", "->", "getGlobalBaseReg", "(", ")", ";" ]

[ "<FIXS>", "error", "(", "<STR_LIT>", "%<interrupt_thread%> is available only on fido", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "if", "(", "!", "TARGET_FIDOA", "&&", "!", "strcmp", "(", "IDENTIFIER_POINTER", "(", "name", ")", ",", "<STR_LIT>", "interrupt_thread", "<STR_LIT>", ")", ")", "{", "<BUGS>", "error", "(", "<STR_LIT>", "interrupt_thread is available only on fido", "<STR_LIT>", ")", ";", "<BUGE>", "*", "no_add_attrs", "=", "true", ";", "}" ]

[ "}", "else", "if", "(", "CharMode", "!=", "<STR_LIT>", "ebcdic", "<STR_LIT>", ")", "{" ]

[ "MemberSubId", "=", "StringSwitch", "<", "PPA2MemberSubId", ">", "(", "Language", ")", ".", "Case", "(", "<STR_LIT>", "C", "<STR_LIT>", ",", "PPA2MemberSubId", "::", "C", ")", ".", "Case", "(", "<STR_LIT>", "C++", "<STR_LIT>", ",", "PPA2MemberSubId", "::", "CXX", ")", ".", "Case", "(", "<STR_LIT>", "Swift", "<STR_LIT>", ",", "PPA2MemberSubId", "::", "Swift", ")", ".", "Case", "(", "<STR_LIT>", "Go", "<STR_LIT>", ",", "PPA2MemberSubId", "::", "Go", ")", ".", "Default", "(", "PPA2MemberSubId", "::", "LLVMBasedLang", ")", ";", "}", "OutStreamer", "->", "emitLabel", "(", "PPA2Sym", ")", ";", "OutStreamer", "->", "emitInt8", "(", "static_cast", "<", "uint8_t", ">", "(", "PPA2MemberId", "::", "LE_C_Runtime", ")", ")", ";", "OutStreamer", "->", "emitInt8", "(", "static_cast", "<", "uint8_t", ">", "(", "MemberSubId", ")", ")", ";", "OutStreamer", "->", "emitInt8", "(", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "emitInt8", "(", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "emitAbsoluteSymbolDiff", "(", "CELQSTRT", ",", "PPA2Sym", ",", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "emitInt32", "(", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "emitAbsoluteSymbolDiff", "(", "DateVersionSym", ",", "PPA2Sym", ",", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "emitInt32", "(", "<NUM_LIT>", ")", ";", "uint8_t", "Flgs", "=", "static_cast", "<", "uint8_t", ">", "(", "PPA2Flags", "::", "CompileForBinaryFloatingPoint", ")", ";", "Flgs", "|=", "static_cast", "<", "uint8_t", ">", "(", "PPA2Flags", "::", "CompiledWithXPLink", ")", ";", "if", "(", "auto", "*", "MD", "=", "M", ".", "getModuleFlag", "(", "<STR_LIT>", "zos_le_char_mode", "<STR_LIT>", ")", ")", "{", "const", "StringRef", "&", "CharMode", "=", "cast", "<", "MDString", ">", "(", "MD", ")", "->", "getString", "(", ")", ";", "if", "(", "CharMode", "==", "<STR_LIT>", "ascii", "<STR_LIT>", ")", "{", "Flgs", "|=", "static_cast", "<", "uint8_t", ">", "(", "PPA2Flags", "::", "CompiledUnitASCII", ")", ";" ]

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

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

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

[ "(", "define_reservation" ]

[ "(", "_", "_", "a", ")", ";" ]

[ "return", "(", "int64x1_t", ")", "_", "_", "builtin_neon_vget_lowv2di" ]

[ ")", ";" ]

[ "gcc_assert", "(", "TARGET_OLDABI", ")", ";", "mips_init_cumulative_args", "(", "&", "cum", ",", "NULL", ")", ";", "for", "(", "f", "=", "(", "unsigned", "int", ")", "fp_code", ";", "f", "!=", "<NUM_LIT>", ";", "f", ">>=", "<NUM_LIT>", ")", "{", "machine_mode", "mode", ";", "struct", "mips_arg_info", "info", ";", "if", "(", "(", "f", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "mode", "=", "SFmode", ";", "else", "if", "(", "(", "f", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "mode", "=", "DFmode", ";", "else", "gcc_unreachable", "(", ")", ";", "mips_get_arg_info", "(", "&", "info", ",", "&", "cum", ",", "mode", ",", "NULL", ",", "true" ]

[ "}" ]

[ "if", "(", "MO", ".", "isUse", "(", ")", ")", "Ref", ".", "Use", "=", "true", ";", "else", "if", "(", "MO", ".", "isDef", "(", ")", ")", "Ref", ".", "Def", "=", "true", ";", "}", "}", "}", "}", "return", "Ref", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd32", ";" ]

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

[ "<STR_LIT>", ";" ]

[ "let", "RenderMethod", "=", "<STR_LIT>", "#", "PREFIX", "#" ]

[ "void", "X86AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "X86MCInstLower", "MCInstLowering", "(", "*", "MF", ",", "*", "this", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "llvm_unreachable", "(", "<STR_LIT>", "Should be handled target independently", "<STR_LIT>", ")", ";", "case", "X86", "::", "Int_MemBarrier", ":", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t#MEMBARRIER", "<STR_LIT>", ")", ")", ";", "return", ";", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "OutStreamer", ".", "AddComment", "(", "StringRef", "(", "<STR_LIT>", "eh_return, addr: %", "<STR_LIT>", ")", "+", "X86ATTInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ")", ";", "break", ";", "}", "case", "X86", "::", "TAILJMPr", ":", "case", "X86", "::", "TAILJMPd", ":", "case", "X86", "::", "TAILJMPd64", ":", "OutStreamer", ".", "AddComment", "(", "<STR_LIT>", "TAILCALL", "<STR_LIT>", ")", ";", "break", ";", "case", "X86", "::", "TLS_addr32", ":", "case", "X86", "::", "TLS_addr64", ":", "case", "X86", "::", "TLS_base_addr32", ":", "case", "X86", "::", "TLS_base_addr64", ":", "return", "LowerTlsAddr", "(", "OutStreamer", ",", "MCInstLowering", ",", "*", "MI", ")", ";", "case", "X86", "::", "MOVPC32r", ":", "{", "MCSymbol", "*", "PICBase", "=", "MF", "->", "getPICBaseSymbol", "(", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "CALLpcrel32", ")", ".", "addExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "PICBase", ",", "OutContext", ")", ")", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "PICBase", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "POP32r", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";", "return", ";", "}", "case", "X86", "::", "ADD32ri", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getTargetFlags", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "break", ";", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "CreateTempSymbol", "(", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "DotSym", ")", ";", "MCSymbol", "*", "OpSym", "=", "MCInstLowering", ".", "GetSymbolFromOperand", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "Create", "(", "DotSym", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PICBase", "=", "MCSymbolRefExpr", "::", "Create", "(", "MF", "->", "getPICBaseSymbol", "(", ")", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateSub", "(", "DotExpr", ",", "PICBase", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "MCSymbolRefExpr", "::", "Create", "(", "OpSym", ",", "OutContext", ")", ",", "DotExpr", ",", "OutContext", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "ADD32ri", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addExpr", "(", "DotExpr", ")", ")", ";", "return", ";", "}", "case", "TargetOpcode", "::", "STACKMAP", ":", "return", "LowerSTACKMAP", "(", "OutStreamer", ",", "MCInstLowering", ",", "SM", ",", "*", "MI", ")", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "LowerPATCHPOINT", "(", "OutStreamer", ",", "MCInstLowering", ",", "SM", ",", "*", "MI", ")", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}" ]

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

[ "bool", "AMDGPUUnifyDivergentExitNodes", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "auto", "&", "PDT", "=", "getAnalysis", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ".", "getPostDomTree", "(", ")", ";", "if", "(", "PDT", ".", "getRoots", "(", ")", ".", "size", "(", ")", "<=", "<NUM_LIT>", ")", "return", "false", ";", "DivergenceAnalysis", "&", "DA", "=", "getAnalysis", "<", "DivergenceAnalysis", ">", "(", ")", ";", "SmallVector", "<", "BasicBlock", "*", ",", "<NUM_LIT>", ">", "ReturningBlocks", ";", "SmallVector", "<", "BasicBlock", "*", ",", "<NUM_LIT>", ">", "UnreachableBlocks", ";", "for", "(", "BasicBlock", "*", "BB", ":", "PDT", ".", "getRoots", "(", ")", ")", "{", "if", "(", "isa", "<", "ReturnInst", ">", "(", "BB", "->", "getTerminator", "(", ")", ")", ")", "{", "if", "(", "!", "isUniformlyReached", "(", "DA", ",", "*", "BB", ")", ")", "ReturningBlocks", ".", "push_back", "(", "BB", ")", ";", "}", "else", "if", "(", "isa", "<", "UnreachableInst", ">", "(", "BB", "->", "getTerminator", "(", ")", ")", ")", "{", "if", "(", "!", "isUniformlyReached", "(", "DA", ",", "*", "BB", ")", ")", "UnreachableBlocks", ".", "push_back", "(", "BB", ")", ";", "}", "}", "if", "(", "!", "UnreachableBlocks", ".", "empty", "(", ")", ")", "{", "BasicBlock", "*", "UnreachableBlock", "=", "nullptr", ";", "if", "(", "UnreachableBlocks", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "UnreachableBlock", "=", "UnreachableBlocks", ".", "front", "(", ")", ";", "}", "else", "{", "UnreachableBlock", "=", "BasicBlock", "::", "Create", "(", "F", ".", "getContext", "(", ")", ",", "<STR_LIT>", "UnifiedUnreachableBlock", "<STR_LIT>", ",", "&", "F", ")", ";", "new", "UnreachableInst", "(", "F", ".", "getContext", "(", ")", ",", "UnreachableBlock", ")", ";", "for", "(", "BasicBlock", "*", "BB", ":", "UnreachableBlocks", ")", "{", "BB", "->", "getInstList", "(", ")", ".", "pop_back", "(", ")", ";", "BranchInst", "::", "Create", "(", "UnreachableBlock", ",", "BB", ")", ";", "}", "}", "if", "(", "!", "ReturningBlocks", ".", "empty", "(", ")", ")", "{", "Type", "*", "RetTy", "=", "F", ".", "getReturnType", "(", ")", ";", "Value", "*", "RetVal", "=", "RetTy", "->", "isVoidTy", "(", ")", "?", "nullptr", ":", "UndefValue", "::", "get", "(", "RetTy", ")", ";", "UnreachableBlock", "->", "getInstList", "(", ")", ".", "pop_back", "(", ")", ";", "Function", "*", "UnreachableIntrin", "=", "Intrinsic", "::", "getDeclaration", "(", "F", ".", "getParent", "(", ")", ",", "Intrinsic", "::", "amdgcn_unreachable", ")", ";", "CallInst", "::", "Create", "(", "UnreachableIntrin", ",", "{", "}", ",", "<STR_LIT>", "<STR_LIT>", ",", "UnreachableBlock", ")", ";", "ReturnInst", "::", "Create", "(", "F", ".", "getContext", "(", ")", ",", "RetVal", ",", "UnreachableBlock", ")", ";", "ReturningBlocks", ".", "push_back", "(", "UnreachableBlock", ")", ";", "}", "}", "if", "(", "ReturningBlocks", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "ReturningBlocks", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "return", "false", ";", "const", "TargetTransformInfo", "&", "TTI", "=", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "unifyReturnBlockSet", "(", "F", ",", "ReturningBlocks", ",", "TTI", ",", "<STR_LIT>", "UnifiedReturnBlock", "<STR_LIT>", ")", ";", "return", "true", ";", "}" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "<FIXS>", "return", "NumBits1", "==", "<NUM_LIT>", "&&", "NumBits2", "==", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "if", "(", "VT1", ".", "isVector", "(", ")", "||", "VT2", ".", "isVector", "(", ")", "||", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "<FIXE>", "<FIXS>", "return", "NumBits1", "==", "<NUM_LIT>", "&&", "NumBits2", "==", "<NUM_LIT>", ";", "<FIXE>" ]

[ "return", "false", ";", "unsigned", "NumBits1", "=", "Ty1", "->", "getPrimitiveSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "Ty2", "->", "getPrimitiveSizeInBits", "(", ")", ";", "<BUGS>", "if", "(", "NumBits1", "==", "<NUM_LIT>", "&&", "NumBits2", "==", "<NUM_LIT>", ")", "return", "true", ";", "return", "false", ";", "<BUGE>", "}", "bool", "AArch64TargetLowering", "::", "isZExtFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "<BUGS>", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "<BUGE>", "return", "false", ";", "unsigned", "NumBits1", "=", "VT1", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "VT2", ".", "getSizeInBits", "(", ")", ";", "<BUGS>", "if", "(", "NumBits1", "==", "<NUM_LIT>", "&&", "NumBits2", "==", "<NUM_LIT>", ")", "return", "true", ";", "return", "false", ";", "<BUGE>", "}", "bool", "AArch64TargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{" ]

[ "unsigned", "MipsSEInstrInfo", "::", "loadImmediate", "(", "int64_t", "Imm", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "II", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "*", "NewImm", ")", "const", "{", "MipsAnalyzeImmediate", "AnalyzeImm", ";", "const", "MipsSubtarget", "&", "STI", "=", "Subtarget", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Size", "=", "STI", ".", "isABI_N64", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "unsigned", "LUi", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "LUi64", ":", "Mips", "::", "LUi", ";", "unsigned", "ZEROReg", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "const", "TargetRegisterClass", "*", "RC", "=", "STI", ".", "isABI_N64", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "bool", "LastInstrIsADDiu", "=", "NewImm", ";", "const", "MipsAnalyzeImmediate", "::", "InstSeq", "&", "Seq", "=", "AnalyzeImm", ".", "Analyze", "(", "Imm", ",", "Size", ",", "LastInstrIsADDiu", ")", ";", "MipsAnalyzeImmediate", "::", "InstSeq", "::", "const_iterator", "Inst", "=", "Seq", ".", "begin", "(", ")", ";", "assert", "(", "Seq", ".", "size", "(", ")", "&&", "(", "!", "LastInstrIsADDiu", "||", "(", "Seq", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", ")", ")", ";", "Register", "Reg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "if", "(", "Inst", "->", "Opc", "==", "LUi", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "LUi", ")", ",", "Reg", ")", ".", "addImm", "(", "SignExtend64", "<", "<NUM_LIT>", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "ZEROReg", ")", ".", "addImm", "(", "SignExtend64", "<", "<NUM_LIT>", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "for", "(", "++", "Inst", ";", "Inst", "!=", "Seq", ".", "end", "(", ")", "-", "LastInstrIsADDiu", ";", "++", "Inst", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "SignExtend64", "<", "<NUM_LIT>", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "if", "(", "LastInstrIsADDiu", ")", "*", "NewImm", "=", "Inst", "->", "ImmOpnd", ";", "return", "Reg", ";", "}" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

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

[ "(", "match_operand", ":", "ssevecmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "int", "ARMRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "return", "ARMGenRegisterInfo", "::", "getDwarfRegNumFull", "(", "RegNum", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

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

[ "(", "truncate", ":", "SI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "sign_extend", ":", "DI" ]

[ ")", "]", ")" ]

[ "(", "mem", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

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

[ "Addr", ":", "$", "addr", ")", "]", ";" ]

[ "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "OpNode", "(", "TyNode", "ROWD", ":", "$", "wd", ")", "," ]

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

[ "def", "L2_ploadrhtnew_pi", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "IntRegs", ":", "$", "Rx32in", ",", "s4_1Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_e9f3243f", ",", "TypeLD", ">", ",", "Enc_733b27", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "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", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "case", "DImode", ":" ]

[ "case", "SImode", ":", "return", "true", ";", "case", "QImode", ":", "return", "TARGET_64BIT", "||", "!", "TARGET_PARTIAL_REG_STALL", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "return", "DAG", ".", "getLoad", "(", "Op", ".", "getValueType", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Chain", ",", "RetPtr", ",", "MachinePointerInfo", "(", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "Chain", "=", "CallInfo", ".", "second", ";", "<BUGS>", "return", "DAG", ".", "getLoad", "(", "Op", ".", "getValueType", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Chain", ",", "RetPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "}", "SDValue", "SparcTargetLowering", "::", "LowerF128Compare", "(", "SDValue", "LHS", ",", "SDValue", "RHS", "," ]

[ "bool", "is_fast_interrupt_func", "(", "const_tree", "decl", ")", "{", "return", "has_func_attr", "(", "decl", ",", "<STR_LIT>", "fast_interrupt", "<STR_LIT>", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "fast_interrupt", "''", "attribute", "." ]

[ "B", ",", "(", "_", "_", "v2di", ")", "_", "mm_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_prorq128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "_", "_" ]

[ "_", "_", "a", ")", ";" ]

[ "return", "_", "_", "builtin_neon_vrndv8hf", "(" ]

[ "]", ")" ]

[ "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "TF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "TF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "_", "_", "B", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvtu32_sh", "(", "_", "_", "m128h", "_", "_", "A", ",", "unsigned", "int", "_", "_", "B", ")", "{", "return", "_", "_", "builtin_ia32_vcvtusi2sh32_round", "(", "_", "_", "A", "," ]

[ "}" ]

[ "vqmovn_s16", "(", "int16x8_t", "_", "_", "a", ")", "{", "return", "(", "int8x8_t", ")", "_", "_", "builtin_neon_vqmovnsv8hi", "(", "_", "_", "a", ")", ";" ]

[ "if", "(", "EltVT", "==", "MVT", "::", "i8", ")", "return", "PopCnt", ";" ]

[ "SDValue", "In", "=", "DAG", ".", "getBitcast", "(", "ByteVecVT", ",", "Op", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "LUTVec", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumByteElts", ";", "++", "i", ")", "LUTVec", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "LUT", "[", "i", "%", "<NUM_LIT>", "]", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "InRegLUT", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "DL", ",", "ByteVecVT", ",", "LUTVec", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Mask0F", "(", "NumByteElts", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "M0F", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "DL", ",", "ByteVecVT", ",", "Mask0F", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Four", "(", "NumByteElts", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "FourV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "DL", ",", "ByteVecVT", ",", "Four", ")", ";", "SDValue", "HighNibbles", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "ByteVecVT", ",", "In", ",", "FourV", ")", ";", "SDValue", "LowNibbles", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "ByteVecVT", ",", "In", ",", "M0F", ")", ";", "SDValue", "HighPopCnt", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ByteVecVT", ",", "InRegLUT", ",", "HighNibbles", ")", ";", "SDValue", "LowPopCnt", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ByteVecVT", ",", "InRegLUT", ",", "LowNibbles", ")", ";", "SDValue", "PopCnt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "ByteVecVT", ",", "HighPopCnt", ",", "LowPopCnt", ")", ";" ]

[ "const", "int", "_", "_", "index", ")", "{" ]

[ "vcmlaq_rot180_lane_f16", "(", "float16x8_t", "_", "_", "r", ",", "float16x8_t", "_", "_", "a", ",", "float16x4_t", "_", "_", "b", "," ]

[ "return", "Imm", ">", "<NUM_LIT>", "&", "&", "Imm", "<", "=", "<NUM_LIT>", ";" ]

[ "}", "]", ">", ";", "def", "ThumbSRImmAsmOperand", ":", "ImmAsmOperand", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ">", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "imm_sr", ":", "Operand", "<", "i32", ">", ",", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "uint64_t", "Imm", "=", "N", "-", ">", "getZExtValue", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "ior", "(", "match_operand", "<NUM_LIT>" ]

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

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(" ]

[ "<STR_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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=" ]

[ "<FIXS>", "if", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_TLSCALL", ")", "<FIXE>" ]

[ "if", "(", "const", "MCSymbolRefExpr", "*", "SRE", "=", "dyn_cast", "MCSymbolRefExpr", ">", "(", "Fixup", ".", "getValue", "(", ")", ")", ")", "<BUGS>", "if", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_ARM_TLSCALL", ")", "<BUGE>", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", "&", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", ";", "case", "ARM", "::", "fixup_t2_uncondbranch", ":", "{" ]

[ "<STR_LIT>", ")" ]

[ "(", "plus", ":", "SI", "(", "ashift", ":", "SI", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "<NUM_LIT>", ";" ]

[ "def", "J4_cmpgtu_f_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "IntRegs", ":", "$", "Rt32", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_9bfd761f", ",", "TypeNCJ", ">", ",", "Enc_c9a18e", ",", "PredRel", "{", "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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "CS", "]", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "<NUM_LIT>", ";" ]

[ "unsigned", "SIMachineFunctionInfo", "::", "addFlatScratchInit", "(", "const", "SIRegisterInfo", "&", "TRI", ")", "{", "ArgInfo", ".", "FlatScratchInit", "=", "ArgDescriptor", "::", "createRegister", "(", "TRI", ".", "getMatchingSuperReg", "(", "getNextUserSGPR", "(", ")", ",", "AMDGPU", "::", "sub0", ",", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ")", ";", "NumUserSGPRs", "+=" ]

[ ",", "Pmode", ",", "goto_handler", ",", "Pmode", ")", ";" ]

[ "void", "xtensa_expand_nonlocal_goto", "(", "rtx", "*", "operands", ")", "{", "rtx", "goto_handler", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "containing_fp", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "GET_CODE", "(", "containing_fp", ")", "!=", "REG", ")", "containing_fp", "=", "force_reg", "(", "Pmode", ",", "containing_fp", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__xtensa_nonlocal_goto", "<STR_LIT>", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "containing_fp" ]

[ "printExpr", "(", "Op", ".", "getExpr", "(", ")", ",", "O", ")", ";" ]

[ "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "O", "<<", "Op", ".", "getImm", "(", ")", ";", "return", ";", "}", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "unknown operand kind in printOperand", "<STR_LIT>", ")", ";" ]

[ ",", "i32imm", ":", "$", "idx", ")", ";" ]

[ "let", "ParserMatchClass", "=", "VecListOneDByteIndexAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd" ]

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

[ "MachineInstr", "*", "getParentInst", "(", ")", "const", "{", "return", "Target", "->" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "imm4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zdn", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DestructiveInstType", "=", "Destructive", ";", "let", "ElementSize", "=", "ElementSizeNone", ";" ]

[ "<STR_LIT>" ]

[ "(", "unspec", ":", "SVE_F", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "div", ":", "SVE_F", "(", "match_operand", ":", "SVE_F", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SVE_F", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_MERGE_PTRUE", ")", ")", "]" ]

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

[ "let", "isAsmParserOnly", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "reg", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "{", "<NUM_LIT>", ",", "reg", "}", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "if", "(", "Eval", ")", "{" ]

[ "bool", "HexagonConstEvaluator", "::", "evaluateHexLogical", "(", "const", "MachineInstr", "&", "MI", ",", "const", "CellMap", "&", "Inputs", ",", "CellMap", "&", "Outputs", ")", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "MI", ".", "getNumOperands", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "const", "MachineOperand", "&", "Src1", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MachineOperand", "&", "Src2", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Register", "R1", "(", "Src1", ")", ";", "bool", "Eval", "=", "false", ";", "LatticeCell", "RC", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "false", ";", "case", "Hexagon", "::", "A2_and", ":", "case", "Hexagon", "::", "A2_andp", ":", "Eval", "=", "evaluateANDrr", "(", "R1", ",", "Register", "(", "Src2", ")", ",", "Inputs", ",", "RC", ")", ";", "break", ";", "case", "Hexagon", "::", "A2_andir", ":", "{", "if", "(", "!", "Src2", ".", "isImm", "(", ")", ")", "return", "false", ";", "APInt", "A", "(", "<NUM_LIT>", ",", "Src2", ".", "getImm", "(", ")", ",", "true", ")", ";", "Eval", "=", "evaluateANDri", "(", "R1", ",", "A", ",", "Inputs", ",", "RC", ")", ";", "break", ";", "}", "case", "Hexagon", "::", "A2_or", ":", "case", "Hexagon", "::", "A2_orp", ":", "Eval", "=", "evaluateORrr", "(", "R1", ",", "Register", "(", "Src2", ")", ",", "Inputs", ",", "RC", ")", ";", "break", ";", "case", "Hexagon", "::", "A2_orir", ":", "{", "if", "(", "!", "Src2", ".", "isImm", "(", ")", ")", "return", "false", ";", "APInt", "A", "(", "<NUM_LIT>", ",", "Src2", ".", "getImm", "(", ")", ",", "true", ")", ";", "Eval", "=", "evaluateORri", "(", "R1", ",", "A", ",", "Inputs", ",", "RC", ")", ";", "break", ";", "}", "case", "Hexagon", "::", "A2_xor", ":", "case", "Hexagon", "::", "A2_xorp", ":", "Eval", "=", "evaluateXORrr", "(", "R1", ",", "Register", "(", "Src2", ")", ",", "Inputs", ",", "RC", ")", ";", "break", ";", "}" ]

[ ")", ";" ]

[ "return", "aarch64_sve_pred_mode", "(", "type_suffix", "(", "i", ")", ".", "element_bytes", ")", ".", "require", "(" ]

[ ")", ")" ]

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

[ "let", "HasImm", "=", "!", "isa", "<", "Operand", ">", "(", "Src", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Switches", "=", "sw", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "flavor", ";", "let", "OperandType", "=", "OpType", ".", "UINT32", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

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

[ "def", "SWr", ":", "BaseAddSubCarrySetFlags", "<", "isSub", ",", "GPR32", ",", "asm_setflags", ",", "OpNode_setflags", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "mem", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_LATENCY_L2", ")", ")", "]", "<STR_LIT>" ]

[ ",", "PM", ")", ";" ]

[ "return", "new", "WebAssemblyPassConfig", "(", "*", "this" ]

[ ")", ")", ")", ",", "(", "LDRBBui", "GPR64sp", ":", "$", "Rn", ",", "uimm12s1", ":", "$", "offset", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "zextloadi1", "(", "am_indexed8", "GPR64sp", ":", "$", "Rn", ",", "uimm12s1", ":", "$", "offset" ]

[ "(", "nullptr", ")", "{" ]

[ "HexagonGenInsert", "(", ")", ":", "MachineFunctionPass", "(", "ID", ")", ",", "HII", "(", "nullptr", ")", ",", "HRI" ]

[ ")", "&", "<NUM_LIT>", ";" ]

[ "uint32_t", "I1Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J1Bit", "=", "(", "I1Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "I2Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J2Bit", "=", "(", "I2Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "imm10Bits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "imm11Bits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ";", "uint32_t", "FirstHalf", "=", "(", "(", "(", "uint16_t", ")", "signBit", "<<", "<NUM_LIT>", ")", "|", "(", "uint16_t", ")", "imm10Bits", ")", ";", "uint32_t", "SecondHalf", "=", "(", "(", "(", "uint16_t", ")", "J1Bit", "<<", "<NUM_LIT>", ")", "|", "(", "(", "uint16_t", ")", "J2Bit", "<<", "<NUM_LIT>", ")", "|", "(", "uint16_t", ")", "imm11Bits", ")", ";", "return", "joinHalfWords", "(", "FirstHalf", ",", "SecondHalf", ",", "IsLittleEndian", ")", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_blx", ":", "{", "if", "(", "Ctx", "&&", "Value", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "{", "Ctx", "->", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "misaligned ARM call destination", "<STR_LIT>", ")", ";", "return", "<NUM_LIT>", ";", "}", "uint32_t", "offset", "=", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "if", "(", "const", "MCSymbolRefExpr", "*", "SRE", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Fixup", ".", "getValue", "(", ")", ")", ")", "if", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_TLSCALL", ")", "offset", "=", "<NUM_LIT>", ";", "uint32_t", "signBit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "I1Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J1Bit", "=", "(", "I1Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "I2Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J2Bit", "=", "(", "I2Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "imm10HBits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "imm10LBits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ";", "uint32_t", "FirstHalf", "=", "(", "(", "(", "uint16_t", ")", "signBit", "<<", "<NUM_LIT>", ")", "|", "(", "uint16_t", ")", "imm10HBits", ")", ";", "uint32_t", "SecondHalf", "=", "(", "(", "(", "uint16_t", ")", "J1Bit", "<<", "<NUM_LIT>", ")", "|", "(", "(", "uint16_t", ")", "J2Bit", "<<", "<NUM_LIT>", ")", "|", "(", "(", "uint16_t", ")", "imm10LBits", ")", "<<", "<NUM_LIT>", ")", ";", "return", "joinHalfWords", "(", "FirstHalf", ",", "SecondHalf", ",", "IsLittleEndian", ")", ";", "}", "case", "ARM", "::", "fixup_thumb_adr_pcrel_10", ":", "case", "ARM", "::", "fixup_arm_thumb_cp", ":", "if", "(", "Ctx", "&&", "!", "STI", "->", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureThumb2", "]", "&&", "IsResolved", ")", "{", "const", "char", "*", "FixupDiagnostic", "=", "reasonForFixupRelaxation", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "FixupDiagnostic", ")", "{", "Ctx", "->", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "FixupDiagnostic", ")", ";", "return", "<NUM_LIT>", ";", "}", "}", "return", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "case", "ARM", "::", "fixup_arm_thumb_cb", ":", "{", "if", "(", "Ctx", "&&", "(", "(", "int64_t", ")", "Value", "<", "<NUM_LIT>", "||", "Value", ">", "<NUM_LIT>", "||", "Value", "&", "<NUM_LIT>", ")", ")", "{", "Ctx", "->", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "out of range pc-relative fixup value", "<STR_LIT>", ")", ";", "return", "<NUM_LIT>", ";", "}", "uint32_t", "Binary", "=", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "return", "(", "(", "Binary", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", "|", "(", "(", "Binary", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_br", ":", "if", "(", "Ctx", "&&", "!", "STI", "->", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureThumb2", "]", "&&", "!", "STI", "->", "getFeatureBits", "(", ")", "[", "ARM", "::", "HasV8MBaselineOps", "]", ")", "{", "const", "char", "*", "FixupDiagnostic", "=", "reasonForFixupRelaxation", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "FixupDiagnostic", ")", "{", "Ctx", "->", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "FixupDiagnostic", ")", ";", "return", "<NUM_LIT>", ";", "}", "}", "return", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "case", "ARM", "::", "fixup_arm_thumb_bcc", ":", "if", "(", "Ctx", "&&", "!", "STI", "->", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureThumb2", "]", ")", "{", "const", "char", "*", "FixupDiagnostic", "=", "reasonForFixupRelaxation", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "FixupDiagnostic", ")", "{", "Ctx", "->", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "FixupDiagnostic", ")", ";", "return", "<NUM_LIT>", ";", "}", "}", "return", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>" ]

[ "<FIXS>", "def", "ICXWriteResGroup106", ":", "SchedWriteRes", "[", "ICXPort49", ",", "ICXPort5", ",", "ICXPort78", "]", ">", "{", "<FIXE>" ]

[ "}", "def", ":", "InstRW", "[", "ICXWriteResGroup104", "]", ",", "(", "instrs", "LRET64", ",", "RET64", ")", ">", ";", "<BUGS>", "def", "ICXWriteResGroup106", ":", "SchedWriteRes", "[", "ICXPort4", ",", "ICXPort5", ",", "ICXPort237", "]", ">", "{", "<BUGE>", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";" ]

[ "void", "SIInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "MachineBasicBlock", "&", "RestoreBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "<STR_LIT>", "RegScavenger required for long branching", "<STR_LIT>", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "<STR_LIT>", "new block should be inserted for expanding unconditional branch", "<STR_LIT>", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "<NUM_LIT>", ")", ";", "assert", "(", "RestoreBB", ".", "empty", "(", ")", "&&", "<STR_LIT>", "restore block should be inserted for restoring clobbered registers", "<STR_LIT>", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "PCReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "*", "GetPC", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "PCReg", ")", ";", "auto", "&", "MCCtx", "=", "MF", "->", "getContext", "(", ")", ";", "MCSymbol", "*", "PostGetPCLabel", "=", "MCCtx", ".", "createTempSymbol", "(", "<STR_LIT>", "post_getpc", "<STR_LIT>", ",", "true", ")", ";", "GetPC", "->", "setPostInstrSymbol", "(", "*", "MF", ",", "PostGetPCLabel", ")", ";", "MCSymbol", "*", "OffsetLo", "=", "MCCtx", ".", "createTempSymbol", "(", "<STR_LIT>", "offset_lo", "<STR_LIT>", ",", "true", ")", ";", "MCSymbol", "*", "OffsetHi", "=", "MCCtx", ".", "createTempSymbol", "(", "<STR_LIT>", "offset_hi", "<STR_LIT>", ",", "true", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "PCReg", ",", "<NUM_LIT>", ",", "AMDGPU", "::", "sub0", ")", ".", "addSym", "(", "OffsetLo", ",", "MO_FAR_BRANCH_OFFSET", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub1", ")", ".", "addReg", "(", "PCReg", ",", "<NUM_LIT>", ",", "AMDGPU", "::", "sub1", ")", ".", "addSym", "(", "OffsetHi", ",", "MO_FAR_BRANCH_OFFSET", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_SETPC_B64", ")", ")", ".", "addReg", "(", "PCReg", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "Register", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "AMDGPU", "::", "SReg_64RegClass", ",", "MachineBasicBlock", "::", "iterator", "(", "GetPC", ")", ",", "false", ",", "<NUM_LIT>", ",", "false", ")", ";", "if", "(", "Scav", ")", "{", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "MRI", ".", "replaceRegWith", "(", "PCReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "}", "else", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TRI", "->", "spillEmergencySGPR", "(", "GetPC", ",", "RestoreBB", ",", "AMDGPU", "::", "SGPR0_SGPR1", ",", "RS", ")", ";", "MRI", ".", "replaceRegWith", "(", "PCReg", ",", "AMDGPU", "::", "SGPR0_SGPR1", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "}", "MCSymbol", "*", "DestLabel", "=", "Scav", "?", "DestBB", ".", "getSymbol", "(", ")", ":", "RestoreBB", ".", "getSymbol", "(", ")", ";", "auto", "*", "Offset", "=", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "DestLabel", ",", "MCCtx", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "PostGetPCLabel", ",", "MCCtx", ")", ",", "MCCtx", ")", ";", "auto", "*", "Mask", "=", "MCConstantExpr", "::", "create", "(", "<NUM_LIT>", "ULL", ",", "MCCtx", ")", ";", "OffsetLo", "->", "setVariableValue", "(", "MCBinaryExpr", "::", "createAnd", "(", "Offset", ",", "Mask", ",", "MCCtx", ")", ")", ";", "auto", "*", "ShAmt", "=", "MCConstantExpr", "::", "create", "(", "<NUM_LIT>", ",", "MCCtx", ")", ";", "OffsetHi", "->", "setVariableValue", "(", "MCBinaryExpr", "::", "createAShr", "(", "Offset", ",", "ShAmt", ",", "MCCtx", ")", ")", ";", "return", ";", "}" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ ";" ]

[ "Entry", "->", "clear", "(", ")", ";", "while", "(", "MF", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "MF", ".", "erase", "(", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ")", ";", "MachineBasicBlock", "*", "CaptureSpec", "=", "MF", ".", "CreateMachineBasicBlock", "(", "Entry", "->", "getBasicBlock", "(", ")", ")", ";", "MachineBasicBlock", "*", "CallTarget", "=", "MF", ".", "CreateMachineBasicBlock", "(", "Entry", "->", "getBasicBlock", "(", ")", ")", ";", "MCSymbol", "*", "TargetSym", "=", "MF", ".", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "MF", ".", "push_back", "(", "CaptureSpec", ")", ";", "MF", ".", "push_back", "(", "CallTarget", ")", ";", "const", "unsigned", "CallOpc", "=", "Is64Bit", "?", "X86", "::", "CALL64pcrel32", ":", "X86", "::", "CALLpcrel32", ";", "const", "unsigned", "RetOpc", "=", "Is64Bit", "?", "X86", "::", "RETQ", ":", "X86", "::", "RETL", ";", "Entry", "->", "addLiveIn", "(", "Reg", ")" ]

[ ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "emit_insn", "(", "gen_popcount", "<", "mode", ">", "<NUM_LIT>", "(", "operands", "[", "<NUM_LIT>", "]" ]

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

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

[ "<FIXS>", "MachinePointerInfo", "(", "SV", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "DAG", ".", "getConstant", "(", "GPRSize", ",", "DL", ",", "PtrVT", ")", ")", ";", "MemOps", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "GRTop", ",", "GRTopAddr", ",", "<BUGS>", "MachinePointerInfo", "(", "SV", ",", "<NUM_LIT>", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}" ]

[ "<FIXS>", "EndToBegin", "[", "&", "MI", "]", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "int32_t", "(", "retType", ")", ")", ";", "<FIXE>", "<FIXS>", "EndToBegin", "[", "&", "MI", "]", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "int32_t", "(", "retType", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "MI", ".", "isPosition", "(", ")", "||", "MI", ".", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "END_BLOCK", ")", "{", "<BUGS>", "BlockTops", "[", "&", "MI", "]", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "int32_t", "(", "retType", ")", ")", ";", "<BUGE>", "continue", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "END_LOOP", ")", "{", "<BUGS>", "LoopTops", "[", "&", "MI", "]", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "int32_t", "(", "retType", ")", ")", ";", "<BUGE>", "continue", ";", "}" ]

[ "ev", ")", ";" ]

[ "ev", "=", "(", "_", "_", "ev64_opaque__", ")", "_", "_", "ev_create_fs", "(", "a", ",", "b", ")", ";", "return", "(", "_", "_", "ev64_opaque__", ")", "_", "_", "builtin_spe_evfsctsf", "(", "(", "_", "_", "v2sf", ")" ]

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

[ "if", "(", "GET_CODE", "(", "constant", ")", "==", "CONST_INT", "&&", "IN_RANGE", "(", "INTVAL", "(", "constant", ")", ",", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "Pmode", "==", "HImode", "||", "h8300_tiny_constant_address_p", "(", "constant", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "if", "(", "Result", ".", "valueIn", "(", ")", "==", "DefVNI", ")", "{" ]

[ "const", "LiveInterval", "&", "LI", "=", "LIS", ".", "getInterval", "(", "Reg", ")", ";", "const", "VNInfo", "*", "DefVNI", "=", "LI", ".", "getVNInfoAt", "(", "LIS", ".", "getInstructionIndex", "(", "*", "Def", ")", ".", "getRegSlot", "(", ")", ")", ";", "assert", "(", "DefVNI", ")", ";", "for", "(", "auto", "&", "I", ":", "MRI", ".", "use_nodbg_operands", "(", "Reg", ")", ")", "{", "const", "auto", "&", "Result", "=", "LI", ".", "Query", "(", "LIS", ".", "getInstructionIndex", "(", "*", "I", ".", "getParent", "(", ")", ")", ")", ";" ]

[ "]", ";" ]

[ "def", "A2_vsubhs", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{", "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", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF" ]

[ "while", "(", "insn", "&&", "hw_after", ">", "<NUM_LIT>", ")", "{" ]

[ "if", "(", "pool_overflow", ")", "pool", "=", "s390_chunkify_start", "(", ")", ";", "if", "(", "!", "TARGET_CPU_ZARCH", "&&", "s390_split_branches", "(", ")", ")", "{", "if", "(", "pool_overflow", ")", "s390_chunkify_cancel", "(", "pool", ")", ";", "else", "s390_mainpool_cancel", "(", "pool", ")", ";", "continue", ";", "}", "if", "(", "pool_overflow", ")", "s390_chunkify_finish", "(", "pool", ")", ";", "else", "s390_mainpool_finish", "(", "pool", ")", ";", "cfun", "->", "machine", "->", "split_branches_pending_p", "=", "false", ";", "break", ";", "}", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "rtx_insn", "*", "insn", ",", "*", "target", ";", "rtx", "label", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "label", "=", "s390_execute_label", "(", "insn", ")", ";", "if", "(", "!", "label", ")", "continue", ";", "gcc_assert", "(", "label", "!=", "const0_rtx", ")", ";", "target", "=", "emit_label", "(", "XEXP", "(", "label", ",", "<NUM_LIT>", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "<NUM_LIT>", ")", ";", "target", "=", "emit_insn", "(", "s390_execute_target", "(", "insn", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "<NUM_LIT>", ")", ";", "}", "}", "s390_optimize_prologue", "(", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2097_Z10", ")", "{", "rtx_insn", "*", "insn", ";", "bool", "insn_added_p", "=", "false", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "<=", "<NUM_LIT>", ")", "continue", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "insn_added_p", "|=", "s390_fix_long_loop_prediction", "(", "insn", ")", ";", "if", "(", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "&&", "s390_tune", "==", "PROCESSOR_2097_Z10", ")", "insn_added_p", "|=", "s390_z10_optimize_cmp", "(", "insn", ")", ";", "}", "if", "(", "insn_added_p", ")", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "}", "s390_function_num_hotpatch_hw", "(", "current_function_decl", ",", "&", "hw_before", ",", "&", "hw_after", ")", ";", "if", "(", "hw_after", ">", "<NUM_LIT>", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "active_insn_p", "(", "insn", ")", "||", "BARRIER_P", "(", "insn", ")", "||", "LABEL_P", "(", "insn", ")", ")", "break", ";" ]

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

[ "}", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", ")", "{", "PM", ".", "add", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "}", "PM", ".", "add", "(" ]

[ ")", ")", ")" ]

[ "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>" ]

[ "]", ";" ]

[ "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", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF" ]

[ "}" ]

[ "def", "_8B", ":", "N2VShiftAdd_R", "<", "<NUM_LIT>", ",", "u", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "VPR64", ",", "v8i8", ",", "shr_imm8", ",", "OpNode", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ")", "]", ")" ]

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