Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "unsigned", "MIbG", "=", "getCompoundCandidateGroup", "(", "MIb", ",", "IsExtendedB", ")", ";", "unsigned", "Opca", "=", "MIa", ".", "getOpcode", "(", ")", ";", "if", "(", "MIaG", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MIbG", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "(", "Opca", "==", "Hexagon", "::", "A2_tfr", "||", "Opca", "==", "Hexagon", "::", "A2_tfrsi", ")", ")", "return", "true", ";", "return", "(", "(", "MIaG", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MIbG", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "(", "MIa", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "MIb", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";" ]

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

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

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

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

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

[ "bits", "<", "<NUM_LIT>", ">", "extend", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "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", ";" ]

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

[ "class", "VOP3_VOP3PInst", "<", "string", "OpName", ",", "VOPProfile", "P", ",", "bit", "UseTiedOutput", "=", "<NUM_LIT>", ",", "SDPatternOperator", "node", "=", "null_frag", ">", ":", "VOP3P_Pseudo", "<", "OpName", ",", "P", ">", "{", "let", "InOperandList", "=", "!", "con", "(", "!", "con", "(", "(", "ins", "FP16InputMods", ":", "$", "src0_modifiers", ",", "VCSrc_f16", ":", "$", "src0", ",", "FP16InputMods", ":", "$", "src1_modifiers", ",", "VCSrc_f16", ":", "$", "src1", ",", "FP16InputMods", ":", "$", "src2_modifiers", ",", "VCSrc_f16", ":", "$", "src2", ")", ",", "!", "if", "(", "UseTiedOutput", ",", "(", "ins", "clampmod", ":", "$", "clamp", ",", "VGPR_32", ":", "$", "vdst_in", ")", ",", "(", "ins", "clampmod0", ":", "$", "clamp", ")", ")", ")", ",", "(", "ins", "op_sel", ":", "$", "op_sel", ",", "op_sel_hi", ":", "$", "op_sel_hi", ")", ")", ";", "let", "Constraints", "=", "!", "if", "(", "UseTiedOutput" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", ":", "BI", "(", "ne", ":", "BI", "(", "and", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "not", ":", "BI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "scratch", ")", ")", "]", ")", "]" ]

[ "<FIXS>", "c4x_immed_float_p", "(", "op", ")", "rtx", "op", ";", "<FIXE>", "<FIXS>", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "if", "(", "GET_MODE", "(", "op", ")", "==", "HFmode", ")", "<FIXE>" ]

[ "}", "}", "static", "int", "<BUGS>", "c4x_immed_float_p", "(", "operand", ")", "rtx", "operand", ";", "<BUGE>", "{", "long", "convval", "[", "<NUM_LIT>", "]", ";", "int", "exponent", ";", "REAL_VALUE_TYPE", "r", ";", "<BUGS>", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "operand", ")", ";", "if", "(", "GET_MODE", "(", "operand", ")", "==", "HFmode", ")", "<BUGE>", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "r", ",", "convval", ")", ";", "else", "{" ]

[ ")" ]

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

[ "ARM", "::", "VMOVv4f32", ")", ";" ]

[ "unsigned", "Vm", "=", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "Vm", "|=", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "unsigned", "imm", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "cmode", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "op", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "DecodeStatus", "S", "=", "MCDisassembler", "::", "Success", ";", "if", "(", "!", "(", "imm", "&", "<NUM_LIT>", ")", "&&", "cmode", "==", "<NUM_LIT>", ")", "{", "if", "(", "op", "==", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "Inst", ".", "setOpcode", "(" ]

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

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

[ "<STR_LIT>" ]

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

[ ";" ]

[ "CheckPreds", "=", "false", ";", "break", ";", "}", "if", "(", "I", "!=", "BI", "&&", "clobbersCTR", "(", "*", "I", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "<STR_LIT>", " (", "<STR_LIT>", "<<", "MBB", "->", "getFullName", "(", ")", "<<", "<STR_LIT>", ") instruction ", "<STR_LIT>", "<<", "*", "I", "<<", "<STR_LIT>", " clobbers CTR, invalidating ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "BI", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", " (", "<STR_LIT>", "<<", "BI", "->", "getParent", "(", ")", "->", "getFullName", "(", ")", "<<", "<STR_LIT>", ") instruction ", "<STR_LIT>", "<<", "*", "BI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "I", "==", "IE", ")", "break", ";", "}", "if", "(", "!", "CheckPreds", "&&", "Preds", ".", "empty", "(", ")", ")", "return", "true", ";", "if", "(", "CheckPreds", ")", "{", "queue_preds", ":", "if", "(", "MachineFunction", "::", "iterator", "(", "MBB", ")", "==", "MBB", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Unable to find a MTCTR instruction for ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "BI", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", " (", "<STR_LIT>", "<<", "BI", "->", "getParent", "(", ")", "->", "getFullName", "(", ")", "<<", "<STR_LIT>", ") instruction ", "<STR_LIT>", "<<", "*", "BI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "false" ]

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

[ "class", "BaseSIMDPairwiseScalar", "<", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "regtype", ",", "RegisterOperand", "vectype", ",", "string", "asm", ",", "string", "kind", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "vectype", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", "#", "kind", "#", "<STR_LIT>", "#", "kind", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVd", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";" ]

[ "_", "_", "v8hi", ")", "_", "_", "O", ",", "_", "_", "M", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_set1_epi16", "(", "_", "_", "m128i", "_", "_", "O", ",", "_", "_", "mmask8", "_", "_", "M", ",", "short", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pbroadcastw128_gpr_mask", "(", "_", "_", "A", ",", "(" ]

[ "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";" ]

[ "AU", ".", "addRequired", "<", "MachineDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachinePostDominatorTreeWrapperPass", ">", "(", ")", ";" ]

[ "}" ]

[ "}", "}", "if", "(", "UseMI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "COPY", ")", "{", "unsigned", "MovOp", "=", "TII", "->", "getMovOpcode", "(", "MRI", ".", "getRegClass", "(", "UseMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "MovOp", "==", "AMDGPU", "::", "COPY", ")", "continue", ";", "UseMI", "->", "setDesc", "(", "TII", "->", "get", "(", "MovOp", ")", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "UseDesc", "=", "UseMI", "->", "getDesc", "(", ")", ";", "if", "(", "UseDesc", ".", "isVariadic", "(", ")", "||", "UseDesc", ".", "OpInfo", "[", "Use", ".", "getOperandNo", "(", ")", "]", ".", "RegClass", "==", "-", "<NUM_LIT>", ")", "continue", ";", "if", "(", "FoldingImm", ")", "{", "MachineOperand", "ImmOp", "=", "MachineOperand", "::", "CreateImm", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ";", "tryAddToFoldList", "(", "FoldList", ",", "UseMI", ",", "Use", ".", "getOperandNo", "(", ")", ",", "&", "ImmOp", ",", "TII", ")", ";", "continue", ";", "}", "tryAddToFoldList", "(", "FoldList", ",", "UseMI", ",", "Use", ".", "getOperandNo", "(", ")", ",", "&", "OpToFold", ",", "TII", ")", ";", "}", "for", "(", "FoldCandidate", "&", "Fold", ":", "FoldList", ")", "{", "if", "(", "updateOperand", "(", "Fold", ",", "TRI", ")", ")", "{", "if", "(", "!", "Fold", ".", "isImm", "(", ")", ")", "{", "assert", "(", "Fold", ".", "OpToFold", "&&", "Fold", ".", "OpToFold", "->", "isReg", "(", ")", ")", ";", "Fold", ".", "OpToFold", "->", "setIsKill", "(", "false", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Folded source from ", "<STR_LIT>", "<<", "MI", "<<", "<STR_LIT>", " into OpNo ", "<STR_LIT>", "<<", "Fold", ".", "UseOpNo", "<<", "<STR_LIT>", " of ", "<STR_LIT>", "<<", "*", "Fold", ".", "UseMI", "<<", "'", "\\n", "'", ")", ";", "}", "}" ]

[ "let", "Defs", "=", "[", "PC", "]", ";" ]

[ "def", "J2_jumpfpt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_cd374165", ",", "TypeJ", ">", ",", "Enc_daea09", ",", "Requires", "<", "[", "HasV60", "]", ">", ",", "PredNewRel", "{", "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", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "if", "(", "!", "isSameBB", "(", "getParentInst", "(", ")", ",", "PotentialMO", ".", "getParent", "(", ")", ")", "||", "!", "isSameReg", "(", "*", "Replaced", ",", "PotentialMO", ")", ")", "return", "nullptr", ";", "for", "(", "MachineOperand", "&", "UseMO", ":", "MRI", "->", "use_operands", "(", "PotentialMO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "isSubregOf", "(", "UseMO", ",", "PotentialMO", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", "&&", "UseMO", ".", "getParent", "(", ")", "!=", "ParentMI", ")", "{", "return", "nullptr", ";" ]

[ "!", "contains_symbol_ref_p", "(", "op", ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "match_code", "<STR_LIT>", ")", "{", "return", "memory_operand", "(", "op", ",", "mode", ")", "&", "&" ]

[ "TYPE_ATTRIBUTES", "(", "fn_type", ")", ")", "!=", "NULL", ";" ]

[ "tree", "fn_type", "=", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ";", "gcc_assert", "(", "POINTER_TYPE_P", "(", "fn_type", ")", ")", ";", "fn_type", "=", "TREE_TYPE", "(", "fn_type", ")", ";", "gcc_assert", "(", "FUNC_OR_METHOD_TYPE_P", "(", "fn_type", ")", ")", ";", "call_interrupt_p", "=", "lookup_attribute", "(", "<STR_LIT>", "interrupt", "<STR_LIT>", "," ]

[ ")", ";" ]

[ "void", "PPCXCOFFStreamer", "::", "emitPrefixedInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "emitCodeAlignment", "(", "<NUM_LIT>", ",", "&", "STI", ",", "<NUM_LIT>" ]

[ ")" ]

[ "(", "define_reservation", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "define_reservation", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "define_reservation", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_reservation", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_reservation", "<STR_LIT>", "<STR_LIT>" ]

[ "PPCSubtarget", ">", "(", ")", ".", "isDarwin", "(", ")", ")", "{" ]

[ "EVT", "PtrVT", "=", "Op", ".", "getValueType", "(", ")", ";", "JumpTableSDNode", "*", "JT", "=", "cast", "<", "JumpTableSDNode", ">", "(", "Op", ")", ";", "SDValue", "JTI", "=", "DAG", ".", "getTargetJumpTable", "(", "JT", "->", "getIndex", "(", ")", ",", "PtrVT", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrVT", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "DAG", ".", "getTarget", "(", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "PtrVT", ",", "JTI", ",", "Zero", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "PtrVT", ",", "JTI", ",", "Zero", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", "||", "!", "TM", ".", "getSubtarget", "<" ]

[ "I", ")", ";" ]

[ "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", "," ]

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

[ "(", "fix", ":", "SI", "(", "match_operand", ":", "DF", "<NUM_LIT>" ]

[ "return", "new", "X86IntelInstPrinter", "(", "MAI", ")", ";" ]

[ "static", "MCInstPrinter", "*", "createX86MCInstPrinter", "(", "const", "Target", "&", "T", ",", "unsigned", "SyntaxVariant", ",", "const", "MCAsmInfo", "&", "MAI", ")", "{", "if", "(", "SyntaxVariant", "==", "<NUM_LIT>", ")", "return", "new", "X86ATTInstPrinter", "(", "MAI", ")", ";", "if", "(", "SyntaxVariant", "==", "<NUM_LIT>", ")" ]

[ "A", ",", "unsigned", "long", "long", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvtu64_ss", "(", "_", "_", "m128", "_", "_" ]

[ "Imm", "{", "<NUM_LIT>", "}", ";" ]

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

[ "<FIXS>", "pa_emit_bcond_fp", "(", "rtx", "operands", "[", "]", ")", "<FIXE>" ]

[ "}", "void", "<BUGS>", "emit_bcond_fp", "(", "rtx", "operands", "[", "]", ")", "<BUGE>", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "rtx", "operand0", "=", "operands", "[", "<NUM_LIT>", "]", ";" ]

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

[ "bool", "PIC16TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createPIC16MemSelOptimizerPass", "(", ")", ")", ";" ]

[ "ShiftedRegAsmOperand", ";" ]

[ "def", "shift_so_reg_reg", ":", "Operand", "<", "i32", ">", ",", "ComplexPattern", "<", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "shl", ",", "srl", ",", "sra", ",", "rotr", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=" ]

[ ">", "(", "Value", ")", "->", "getSymbol", "(", ")", ")", ";" ]

[ "void", "MipsTargetELFStreamer", "::", "emitAssignment", "(", "MCSymbol", "*", "S", ",", "const", "MCExpr", "*", "Value", ")", "{", "auto", "*", "Symbol", "=", "cast", "<", "MCSymbolELF", ">", "(", "S", ")", ";", "if", "(", "Value", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "SymbolRef", ")", "return", ";", "const", "auto", "&", "RhsSym", "=", "cast", "<", "MCSymbolELF", ">", "(", "static_cast", "<", "const", "MCSymbolRefExpr", "*" ]

[ "unsigned", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

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

[ "SDValue", "SRLOp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "MVT", "::", "i128", ",", "ArgVal", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "-", "SHLAmt", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "SDValue", "PPCTargetLowering", "::", "LowerROTL", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ROTL", "&&", "<STR_LIT>", "Should only be called for ISD::ROTL", "<STR_LIT>", ")", ";", "assert", "(", "Op", ".", "getValueType", "(", ")", "==", "MVT", "::", "v1i128", "&&", "<STR_LIT>", "Only set v1i128 as custom, other type shouldn't reach here!", "<STR_LIT>", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "N0", "=", "peekThroughBitcasts", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "N1", "=", "peekThroughBitcasts", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "SHLAmt", "=", "N1", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "if", "(", "SHLAmt", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "std", "::", "iota", "(", "Mask", ".", "begin", "(", ")", ",", "Mask", ".", "end", "(", ")", ",", "<NUM_LIT>", ")", ";", "std", "::", "rotate", "(", "Mask", ".", "begin", "(", ")", ",", "Mask", ".", "begin", "(", ")", "+", "SHLAmt", "/", "<NUM_LIT>", ",", "Mask", ".", "end", "(", ")", ")", ";", "if", "(", "SDValue", "Shuffle", "=", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v16i8", ",", "dl", ",", "DAG", ".", "getBitcast", "(", "MVT", "::", "v16i8", ",", "N0", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v16i8", ")", ",", "Mask", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v1i128", ",", "Shuffle", ")", ";", "}", "SDValue", "ArgVal", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "i128", ",", "N0", ")", ";", "SDValue", "SHLOp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "MVT", "::", "i128", ",", "ArgVal", ",", "DAG", ".", "getConstant", "(", "SHLAmt", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "static", "poly_uint16", "aarch64_convert_sve_vector_bits", "(", "aarch64_sve_vector_bits_enum", "value", ")", "{", "if", "(", "value", "==", "SVE_SCALABLE", "||", "(", "value", "==", "SVE_128", "&&", "BYTES_BIG_ENDIAN", ")", ")", "return", "poly_uint16", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "else", "return", "(", "int", ")", "value", "/" ]

[ "for", "(", "unsigned", "ShiftVal", "=", "<NUM_LIT>", ";", "ShiftVal", "<", "BitSize", ";", "ShiftVal", "+=", "<NUM_LIT>", ")", "{" ]

[ "if", "(", "BitSize", "==", "<NUM_LIT>", ")", "return", "~", "<NUM_LIT>", "U", ";", "APInt", "ImmVal", "=", "Imm", ";", "if", "(", "BitSize", "&", "<NUM_LIT>", ")", "ImmVal", "=", "Imm", ".", "sext", "(", "(", "BitSize", "+", "<NUM_LIT>", ")", "&", "~", "<NUM_LIT>", "U", ")", ";", "int", "Cost", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "return", "\\\"or{l}\\\\t{%1, %0|%1, %0}\\\"}", "<STR_LIT>", "type", "<STR_LIT>", "alu1", "<STR_LIT>", "length", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "*", "movsi_1", "<STR_LIT>", "nonimmediate_operand", "<STR_LIT>", "=", "r", ",", "m", "<STR_LIT>", "general_operand", "<STR_LIT>", "rinm", ",", "rin", "<STR_LIT>", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "MEM", "|", "|", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "MEM", "<STR_LIT>", "*", "{" ]

[ "}" ]

[ "bool", "isBDXAddr64Disp20", "(", ")", "const", "{", "return", "isMemDisp20", "(", "ADDR64Reg", ",", "BDXMem", ")", ";" ]

[ "let", "ParserMatchClass", "=", "CondCode", ";" ]

[ "def", "ccode", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "void", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", "&&", "<STR_LIT>", "Private offset should never exceed maximum private size", "<STR_LIT>", ")", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "UnusedCarry", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "BaseReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addImm", "(", "Offset", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "}" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ ")", ")", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";" ]

[ "if", "(", "HexagonMCInstrInfo", "::", "IsABranchingInst", "(", "MCII", ",", "STI", ",", "*", "ISJ", "->", "ID", ")", ")", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";", "break", ";", "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>", ":", "++", "Summary", ".", "NonZCVIloads", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "AllCVIloads", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "loads", ";", "++", "Summary", ".", "memory", ";", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotSingleLoad", "||", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "ID", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "++", "Summary", ".", "load0", ";", "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "isReturn", "(", ")", ")", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";", "break", ";", "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>", ":", "++", "Summary", ".", "CVIstores", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "stores", ";", "++", "Summary", ".", "memory", ";", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotSingleStore", "||", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "ID", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "++", "Summary", ".", "store0", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "loads", ";", "++", "Summary", ".", "stores", ";", "++", "Summary", ".", "store1", ";", "++", "Summary", ".", "memops", ";", "++", "Summary", ".", "memory", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "memory", ";", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "mayLoad", "(", ")", ")", "{", "++", "Summary", ".", "loads", ";", "++", "Summary", ".", "memory", ";", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotSingleLoad", "||", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "ID", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "++", "Summary", ".", "load0", ";", "}", "else", "{", "assert", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "mayStore", "(", ")", ")", ";", "++", "Summary", ".", "memory", ";", "++", "Summary", ".", "stores", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "isBranch", "(" ]

[ "}" ]

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

[ "Type", ")", ";" ]

[ "std", "::", "string", "S", ";", "for", "(", "const", "auto", "&", "Type", ":", "List", ")", "{", "if", "(", "&", "Type", "!=", "&", "List", "[", "<NUM_LIT>", "]", ")", "S", "+=", "<STR_LIT>", ", ", "<STR_LIT>", ";", "S", "+=", "WebAssembly", "::", "typeToString", "(" ]

[ "<FIXS>", "fprintf", "(", "stderr", ",", "<STR_LIT>", "s390 multiple literalpool support:\\n No code label between this insn %X %X", "<STR_LIT>", ",", "<FIXE>" ]

[ "{", "debug_rtx", "(", "insn", ")", ";", "debug_rtx", "(", "tmp", ")", ";", "<BUGS>", "fprintf", "(", "stderr", ",", "<STR_LIT>", "s390 multiple literalpool support:", "<STR_LIT>", "<STR_LIT>", "\\n No code label between this insn %X %X", "<STR_LIT>", ",", "<BUGE>", "naddr", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "tmp", ")", ")", ")", ";", "abort", "(", ")", ";", "}" ]

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

[ "(", "unspec", ":", "CCDSP", "[", "(", "match_operand", ":", "DSPV", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DSPV", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "reg", ":", "CCDSP", "CCDSP_CC_REGNUM", ")", "]" ]

[ "<FIXS>", "def", "TSV110Wr_6cyc_2LdSt", ":", "SchedWriteRes", "[", "TSV110UnitLd", ",", "TSV110UnitLd", "]", ">", "{", "<FIXE>", "<FIXS>", "def", "TSV110Wr_6cyc_1LdSt_1ALUAB", ":", "SchedWriteRes", "[", "TSV110UnitLd", ",", "<FIXE>", "<FIXS>", "TSV110UnitLd", "]", ">", "{", "<FIXE>" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "}", "<BUGS>", "def", "TSV110Wr_6cyc_2LdSt", ":", "SchedWriteRes", "[", "TSV110UnitLdSt", ",", "TSV110UnitLdSt", "]", ">", "{", "<BUGE>", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "}", "<BUGS>", "def", "TSV110Wr_6cyc_1LdSt_1ALUAB", ":", "SchedWriteRes", "[", "TSV110UnitLdSt", ",", "<BUGE>", "TSV110UnitALUAB", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "}", "def", "TSV110Wr_7cyc_1F_1LdSt", ":", "SchedWriteRes", "[", "TSV110UnitF", ",", "<BUGS>", "TSV110UnitLdSt", "]", ">", "{", "<BUGE>", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "}" ]

[ "}" ]

[ "vqsub_u32", "(", "uint32x2_t", "_", "_", "a", ",", "uint32x2_t", "_", "_", "b", ")", "{", "return", "(", "uint32x2_t", ")", "_", "_", "builtin_neon_vqsubuv2si", "(", "(", "int32x2_t", ")", "_", "_", "a", ",", "(", "int32x2_t", ")", "_", "_", "b", ")", ";" ]

[ ")", ",", "<STR_LIT>", ",", "tc_643b4717", ",", "TypeS_2op", ">", ",", "Enc_5d6c34", "{" ]

[ "def", "C2_bitsclri", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "u6_0Imm", ":", "$", "Ii" ]

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

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

[ "}" ]

[ "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", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "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>", ";" ]

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

[ "}", "else", "if", "(", "TheTriple", ".", "isOSBinFormatELF", "(", ")", ")", "{", "MAI", "=", "new", "X86ELFMCAsmInfo", "(", "TheTriple", ")", ";", "}", "else", "if", "(", "TheTriple", ".", "isWindowsMSVCEnvironment", "(", ")", "||", "TheTriple", ".", "isWindowsCoreCLREnvironment", "(", ")", ")", "{", "MAI", "=", "new", "X86MCAsmInfoMicrosoft", "(", "TheTriple", ")", ";", "}", "else", "if", "(", "TheTriple", ".", "isOSCygMing", "(", ")", "||", "TheTriple", ".", "isWindowsItaniumEnvironment", "(", ")", ")", "{", "MAI", "=", "new", "X86MCAsmInfoGNUCOFF", "(", "TheTriple", ")", ";", "}", "else", "{", "MAI", "=", "new", "X86ELFMCAsmInfo", "(", "TheTriple", ")", ";", "}", "int", "stackGrowth", "=", "is64Bit", "?", "-", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ";", "unsigned", "StackPtr", "=", "is64Bit", "?", "X86", "::", "RSP", ":", "X86", "::", "ESP", ";", "MCCFIInstruction", "Inst", "=", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "MRI", ".", "getDwarfRegNum", "(", "StackPtr", ",", "true", ")", ",", "-", "stackGrowth", ")", ";", "MAI", "->", "addInitialFrameState", "(", "Inst", ")", ";", "unsigned", "InstPtr", "=", "is64Bit", "?", "X86", "::", "RIP", ":", "X86", "::", "EIP", ";", "MCCFIInstruction", "Inst2", "=", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "MRI", ".", "getDwarfRegNum", "(", "InstPtr", ",", "true", ")", ",", "stackGrowth", ")", ";", "MAI", "->", "addInitialFrameState" ]

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

[ ")", "(", "define_peephole2", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "plus", ":", "GPI", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "CC", "CC_REGNUM", ")" ]

[ "case", "Mips", "::", "fixup_MICROMIPS_PC16_S1", ":" ]

[ "Value", "=", "(", "int64_t", ")", "Value", "/", "<NUM_LIT>", ";", "if", "(", "!", "isIntN", "(", "<NUM_LIT>", ",", "Value", ")", "&&", "Ctx", ")", "Ctx", "->", "FatalError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "out of range PC19 fixup", "<STR_LIT>", ")", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_26", ":", "Value", ">>=", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_HI16", ":", "case", "Mips", "::", "fixup_Mips_GOT_Local", ":", "case", "Mips", "::", "fixup_Mips_GOT_HI16", ":", "case", "Mips", "::", "fixup_Mips_CALL_HI16", ":", "case", "Mips", "::", "fixup_MICROMIPS_HI16", ":", "case", "Mips", "::", "fixup_MIPS_PCHI16", ":", "Value", "=", "(", "(", "Value", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_HIGHER", ":", "Value", "=", "(", "(", "Value", "+", "<NUM_LIT>", "LL", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_HIGHEST", ":", "Value", "=", "(", "(", "Value", "+", "<NUM_LIT>", "LL", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_MICROMIPS_26_S1", ":", "Value", ">>=", "<NUM_LIT>", ";", "break", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC7_S1", ":", "Value", "-=", "<NUM_LIT>", ";", "Value", "=", "(", "int64_t", ")", "Value", "/", "<NUM_LIT>", ";", "if", "(", "!", "isIntN", "(", "<NUM_LIT>", ",", "Value", ")", "&&", "Ctx", ")", "Ctx", "->", "FatalError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "out of range PC7 fixup", "<STR_LIT>", ")", ";", "break", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ":", "Value", "-=", "<NUM_LIT>", ";", "Value", "=", "(", "int64_t", ")", "Value", "/", "<NUM_LIT>", ";", "if", "(", "!", "isIntN", "(", "<NUM_LIT>", ",", "Value", ")", "&&", "Ctx", ")", "Ctx", "->", "FatalError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "out of range PC10 fixup", "<STR_LIT>", ")", ";", "break", ";" ]

[ "}" ]

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

[ "<FIXS>", "for", "(", "r", "=", "<NUM_LIT>", ";", "HARD_REGISTER_NUM_P", "(", "r", ")", ";", "++", "r", ")", "<FIXE>" ]

[ "for", "(", "r", "=", "<NUM_LIT>", ";", "r", "<NUM_LIT>", ";", "++", "r", ")", "rs6000_regno_regclass", "[", "r", "]", "=", "FLOAT_REGS", ";", "<BUGS>", "for", "(", "r", "=", "<NUM_LIT>", ";", "r", "FIRST_PSEUDO_REGISTER", ";", "++", "r", ")", "<BUGE>", "rs6000_regno_regclass", "[", "r", "]", "=", "NO_REGS", ";", "for", "(", "r", "=", "FIRST_ALTIVEC_REGNO", ";", "r", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "r", ")" ]

[ "<FIXS>", "return", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "<FIXE>" ]

[ "AVRRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", "->", "getInfo", "AVRMachineFunctionInfo", ">", "(", ")", ";", "<BUGS>", "return", "AFI", "->", "isInterruptHandler", "(", ")", "<BUGE>", "?", "CSR_Interrupts_SaveList", ":", "CSR_Normal_SaveList", ";", "}" ]

[ "instrs", "FADD_rec", ",", "FADDS_rec", ",", "FMUL_rec", ",", "FMULS_rec", ",", "FSUB_rec", ",", "FSUBS_rec", ")", ">", ";" ]

[ "def", ":", "InstRW", "<", "[", "P10W_BF_7C", ",", "P10W_DISP_EVEN", ",", "P10W_FX_3C", ",", "P10W_DISP_ANY", "]", ",", "(" ]

[ "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "]", ")" ]

[ "(", "clobber", "(", "reg", ":", "DI", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "{", "gcc_unreachable", "(", ")", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "HI", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "mult", ":", "SI", "(", "not", ":", "SI", "(", "zero_extend", ":", "SI", "(", "not", ":", "HI", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", ")", ")", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "void", "PPCTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Do not know how to custom type legalize this operation!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", "!=", "Intrinsic", "::", "ppc_is_decremented_ctr_nonzero", ")", "break", ";", "assert", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i1", "&&", "<STR_LIT>", "Unexpected result type for CTR decrement intrinsic", "<STR_LIT>", ")", ";", "EVT", "SVT", "=", "getSetCCResultType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "SVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "NewInt", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "NewInt", ")", ";", "Results", ".", "push_back", "(", "NewInt", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "VAARG", ":", "{", "if", "(", "!", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isSVR4ABI", "(", ")", "||", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ")", "return", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "{", "SDValue", "NewNode", "=", "LowerVAARG", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "DAG", ",", "PPCSubTarget", ")", ";", "Results", ".", "push_back", "(", "NewNode", ")", ";", "Results", ".", "push_back", "(", "NewNode", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "return", ";", "}", "case", "ISD", "::", "FP_ROUND_INREG", ":", "{", "assert", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "ppcf128", ")", ";", "assert", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "ppcf128", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "FPreg", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "f64", ",", "Lo", ",", "Hi", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "ppcf128", ",", "FPreg", ",", "FPreg", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "Results", ".", "push_back", "(", "LowerFP_TO_INT", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "DAG", ",", "dl", ")", ")", ";", "return", ";", "}", "}" ]

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

[ "<FIXS>", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", "||", "cxx17_empty_base_field_p", "(", "field", ")", ")", "<FIXE>" ]

[ "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "<BUGS>", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "<BUGE>", "continue", ";", "if", "(", "single", "==", "NULL_TREE", ")" ]

[ "int", "aarch64_epilogue_uses", "(", "int", "regno", ")", "{", "if", "(", "epilogue_completed", ")", "{", "if", "(", "regno", "==", "LR_REGNUM", ")", "return", "<NUM_LIT>", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "1", "if", "the", "register", "is", "used", "by", "the", "epilogue", ".", "We", "need", "to", "say", "the", "return", "register", "is", "used", ",", "but", "only", "after", "epilogue", "generation", "is", "complete", ".", "Note", "that", "in", "the", "case", "of", "sibcalls", ",", "the", "values", "``", "used", "by", "the", "epilogue", "''", "are", "considered", "live", "at", "the", "start", "of", "the", "called", "function", ".", "For", "SIMD", "functions", "we", "need", "to", "return", "1", "for", "FP", "registers", "that", "are", "saved", "and", "restored", "by", "a", "function", "but", "are", "not", "zero", "in", "call_used_regs", ".", "If", "we", "do", "not", "do", "this", "optimizations", "may", "remove", "the", "restore", "of", "the", "register", "." ]

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

[ "TargetPassConfig", "*", "Tile64TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "Tile64PassConfig", "(", "this" ]

[ "<FIXS>", "EmitConstant", "(", "<NUM_LIT>", "|", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "<NUM_LIT>", ",", "OS", ")", ";", "<FIXE>" ]

[ "EmitConstant", "(", "<NUM_LIT>", "|", "(", "encodeArArpSttModOp", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "<<", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "OS", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "<BUGS>", "EmitConstant", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "OS", ")", ";", "<BUGE>", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "EmitConstant", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "<NUM_LIT>", ",", "OS", ")", ";" ]

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

[ "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "div", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "fix", ":", "SI", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "pc", ")", "]" ]

[ ";" ]

[ "class", "AsmVectorIndex", "<", "int", "Min", ",", "int", "Max", ",", "string", "NamePrefix", "=", "<STR_LIT>", ">", ":", "AsmOperandClass", "{", "let", "Name", "=", "NamePrefix", "#", "<STR_LIT>", "#", "Min", "#", "<STR_LIT>", "#", "Max", ";", "let", "DiagnosticType", "=", "<STR_LIT>", "#", "Name", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "Min", "#", "<STR_LIT>", "#", "Max", "#", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>" ]

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

[ "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", "." ]

[ "}" ]

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

[ ",", "[", "(", "set", "vsrc", ":", "$", "XT", ",", "(", "int_ppc_vsx_xvmaxsp", "vsrc", ":", "$", "XA", ",", "vsrc", ":", "$", "XB", ")", ")", "]", ">", ";" ]

[ "def", "XVMAXSP", ":", "XX3Form", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "vsrc", ":", "$", "XT", ")", ",", "(", "ins", "vsrc", ":", "$", "XA", ",", "vsrc", ":", "$", "XB", ")", ",", "<STR_LIT>", ",", "IIC_VecFP" ]

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

[ "CI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "if", "(", "convertAccurateDivide", "(", "CI", ")", ")", "{", "expandAccurateDivide", "(", "CI", ")", ";", "++", "(", "*", "bbb", ")", ";", "CI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "StringRef", "calleeName", "=", "CI", "->", "getOperand", "(", "CI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", "->", "getName", "(", ")", ";", "if", "(", "calleeName", ".", "startswith", "(", "<STR_LIT>", "__amdil_is_constant", "<STR_LIT>", ")", ")", "{", "if", "(", "optLevel", "==", "CodeGenOpt", "::", "None", ")", "{", "isConstVec", ".", "push_back", "(", "CI", ")", ";", "return", "false", ";", "}", "else", "{", "Constant", "*", "CV", "=", "dyn_cast", "<", "Constant", ">", "(", "CI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Type", "*", "aType", "=", "Type", "::", "getInt32Ty", "(", "*", "mCTX", ")", ";", "Value", "*", "Val", "=", "(", "CV", "!=", "NULL", ")", "?", "ConstantInt", "::", "get", "(", "aType", ",", "<NUM_LIT>", ")", ":", "ConstantInt", "::", "get", "(", "aType", ",", "<NUM_LIT>", ")", ";", "CI", "->", "replaceAllUsesWith", "(", "Val", ")", ";", "++", "(", "*", "bbb", ")", ";", "CI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "}", "if", "(", "calleeName", ".", "equals", "(", "<STR_LIT>", "__amdil_is_asic_id_i32", "<STR_LIT>", ")", ")", "{", "ConstantInt", "*", "CV", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Type", "*", "aType", "=", "Type", "::", "getInt32Ty", "(", "*", "mCTX", ")", ";", "Value", "*", "Val", "=", "CV", ";", "if", "(", "Val", ")", "{", "Val", "=", "ConstantInt", "::", "get", "(", "aType", ",", "mSTM", "->", "device", "(", ")", "->", "getDeviceFlag", "(", ")", "&", "CV", "->", "getZExtValue", "(", ")", ")", ";", "}", "else", "{", "Val", "=", "ConstantInt", "::", "get", "(", "aType", ",", "<NUM_LIT>", ")", ";", "}", "CI", "->", "replaceAllUsesWith", "(", "Val", ")", ";", "++", "(", "*", "bbb", ")", ";", "CI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "CI", "->", "getOperand", "(", "CI", "->", "getNumOperands", "(" ]

[ "I", ")", ".", "getSubReg", "(", ")", ";" ]

[ "MachineInstr", "&", "CopyUse", "=", "*", "MRI", ".", "use_instr_begin", "(", "DstReg", ")", ";", "if", "(", "!", "CopyUse", ".", "isCopy", "(", ")", ")", "return", "false", ";", "if", "(", "CopyUse", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ".", "isPhysical", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterClass", "*", "SrcRC", ",", "*", "DstRC", ";", "std", "::", "tie", "(", "SrcRC", ",", "DstRC", ")", "=", "getCopyRegClasses", "(", "CopyUse", ",", "*", "TRI", ",", "MRI", ")", ";", "if", "(", "!", "isSGPRToVGPRCopy", "(", "SrcRC", ",", "DstRC", ",", "*", "TRI", ")", ")", "return", "false", ";", "if", "(", "tryChangeVGPRtoSGPRinCopy", "(", "CopyUse", ",", "TRI", ",", "TII", ")", ")", "return", "true", ";", "unsigned", "SubReg", "=", "CopyUse", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", ";", "if", "(", "SubReg", "!=", "AMDGPU", "::", "NoSubRegister", ")", "return", "false", ";", "MRI", ".", "setRegClass", "(", "DstReg", ",", "DstRC", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "CopyUse", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "bool", "IsAGPR", "=", "TRI", "->", "hasAGPRs", "(", "DstRC", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "N", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "N", ";", "I", "+=", "<NUM_LIT>", ")", "{", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "I", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcSubReg", "=", "MI", ".", "getOperand", "(" ]

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

[ "EVT", "WidenedVT", "=", "VT", ";", "EVT", "WidenedMemVT", "=", "MemVT", ";", "if", "(", "!", "Subtarget", "->", "hasDwordx3LoadStores", "(", ")", "&&", "(", "WidenedVT", "==", "MVT", "::", "v3i32", "||", "WidenedVT", "==", "MVT", "::", "v3f32", ")", ")", "{", "WidenedVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WidenedVT", ".", "getVectorElementType", "(", ")", ",", "<NUM_LIT>", ")", ";", "WidenedMemVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WidenedMemVT", ".", "getVectorElementType", "(", ")", ",", "<NUM_LIT>", ")", ";", "MMO", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getMachineMemOperand", "(", "MMO", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "}", "assert", "(", "VTList", ".", "NumVTs", "==", "<NUM_LIT>", ")", ";", "SDVTList", "WidenedVTList", "=", "DAG", ".", "getVTList", "(", "WidenedVT", ",", "VTList", "." ]

[ "A", ",", "(", "_", "_", "v8df", ")", "_", "mm512_setzero_pd", "(", ")", ",", "_", "_", "M", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_broadcastsd_pd", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m128d", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_broadcastsd512", "(", "(", "_", "_", "v2df", ")", "_", "_" ]

[ "<STR_LIT>", ")" ]

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

[ "JITInfo", ";" ]

[ "virtual", "AlphaJITInfo", "*", "getJITInfo", "(", ")", "{", "return", "&" ]

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

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

[ ",", "MMO", ")", ";" ]

[ "SrcOpnd", "=", "<NUM_LIT>", ";", "if", "(", "MMO", "->", "getSize", "(", ")", "<", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_VOID", ":", "{", "MemIntrinsicSDNode", "*", "Intrin", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "N", ")", ";", "Chain", "=", "Intrin", "->", "getChain", "(", ")", ";", "Base", "=", "Intrin", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MMO", "=", "Intrin", "->", "getMemOperand", "(", ")", ";", "SrcOpnd", "=", "<NUM_LIT>", ";", "break", ";", "}", "}", "SDValue", "Src", "=", "N", "->", "getOperand", "(", "SrcOpnd", ")", ";", "MVT", "VecTy", "=", "Src", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "SDValue", "Swap", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DAG", ".", "getVTList", "(", "VecTy", ",", "MVT", "::", "Other", ")", ",", "Chain", ",", "Src", ")", ";", "DCI", ".", "AddToWorklist", "(", "Swap", ".", "getNode", "(", ")", ")", ";", "Chain", "=", "Swap", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "StoreOps", "[", "]", "=", "{", "Chain", ",", "Swap", ",", "Base", "}", ";", "SDValue", "Store", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ")", ",", "StoreOps", ",", "VecTy" ]

[ "&", "MFI", ")", "{" ]

[ "static", "bool", "CantUseSP", "(", "const", "MachineFrameInfo" ]

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

[ "(", "and", ":", "DI", "(", "not", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "result", ";" ]

[ "vpaddl_u32", "(", "uint32x2_t", "a", ")", "{", "uint64x1_t", "result", ";", "_", "_", "asm__", "(", "<STR_LIT>", "uaddlp %0.1d,%1.2s", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "w", "<STR_LIT>", "(", "a", ")", ":", ")", ";", "return" ]

[ "<STR_LIT>", ")" ]

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

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

[ "(", "define_mode_attr", "DPWI", "[", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>", ")", "(", "DI" ]

[ "<FIXS>", "if", "(", "WasmSym", "->", "isDefined", "(", ")", ")", "{", "<FIXE>", "<FIXS>", "LastFunctionLabel", "=", "WasmSym", ";", "<FIXE>" ]

[ "if", "(", "SymName", ".", "empty", "(", ")", ")", "return", "true", ";", "auto", "WasmSym", "=", "cast", "MCSymbolWasm", ">", "(", "Ctx", ".", "getOrCreateSymbol", "(", "SymName", ")", ")", ";", "<BUGS>", "if", "(", "CurrentState", "==", "Label", "&&", "WasmSym", "==", "LastLabel", ")", "{", "<BUGE>", "if", "(", "ensureEmptyNestingStack", "(", ")", ")", "return", "true", ";", "CurrentState", "=", "FunctionStart", ";", "<BUGS>", "LastFunctionLabel", "=", "LastLabel", ";", "<BUGE>", "push", "(", "Function", ")", ";", "}", "auto", "Signature", "=", "std", "::", "make_unique", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", ")", ";" ]

[ "}", ";" ]

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

[ "}" ]

[ "def", "C2_not", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ")", ",", "<STR_LIT>", ",", "tc_de554571", ",", "TypeCR", ">", ",", "Enc_65d691", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

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

[ "return", "std", "::", "max", "<", "unsigned", ">", "(", "<NUM_LIT>", ",", "(", "MinElts", "*", "ElSize", "+", "<NUM_LIT>", ")", "/", "VecSize", ")", ";" ]

[ "unsigned", "ElSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", "->", "getElementType", "(", ")", ")", ";", "unsigned", "MinElts", "=", "VecTy", "->", "getElementCount", "(", ")", ".", "getKnownMinValue", "(", ")", ";", "if", "(", "UseScalable", "&&", "isa", "<", "FixedVectorType", ">", "(", "VecTy", ")", ")", "VecSize", "=", "std", "::", "max", "(", "Subtarget", "->", "getMinSVEVectorSizeInBits", "(", ")", ",", "<NUM_LIT>", "u", ")", ";" ]

[ "_", "artificial__", ")", ")", "_", "mm512_getexp_ps", "(", "_", "_", "m512", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_" ]

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

[ "class", "BaseBitfieldImm", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "regtype", ",", "Operand", "imm_type", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "imm_type", ":", "$", "immr", ",", "imm_type", ":", "$", "imms", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteIS", ",", "ReadI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "immr", ";", "bits", "<", "<NUM_LIT>", ">", "imms", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ ",", "TII", ")", ";" ]

[ "SPIRVType", "*", "SPIRVGlobalRegistry", "::", "assignIntTypeToVReg", "(", "unsigned", "BitWidth", ",", "Register", "VReg", ",", "MachineInstr", "&", "I", ",", "const", "SPIRVInstrInfo", "&", "TII", ")", "{", "SPIRVType", "*", "SpirvType", "=", "getOrCreateSPIRVIntegerType", "(", "BitWidth", ",", "I" ]

[ "let", "opNewValue", "=", "<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>", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "=", "RC", ";" ]

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

[ "}" ]

[ "def", "MEMdp", ":", "Operand", "<", "iPTR", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

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

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

[ "(", "extend", ":", "DI" ]

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

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

[ "def", "UXDri", ":", "BaseIntegerToFPUnscaled", "<", "isUnsigned", ",", "GPR64", ",", "FPR64", ",", "f64", ",", "asm", ",", "node", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "SDValue", "Result", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "CPAddr", ",", "MachinePointerInfo", "::", "getConstantPool", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Chain", "=", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "GOT", "=", "DAG", ".", "getGLOBAL_OFFSET_TABLE", "(", "PtrVT", ")", ";", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "Result", ",", "GOT", ")", ";", "if", "(", "!", "UseGOTOFF", ")", "Result", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "Chain", ",", "Result", ",", "MachinePointerInfo", "::", "getGOT", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "return", "Result", ";", "}", "if", "(", "Subtarget", "->", "useMovt", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ")", "{", "++", "NumMovwMovt", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "PtrVT", ",", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "dl", ",", "PtrVT", ")", ")", ";", "}", "else", "{", "SDValue", "CPAddr", "=", "DAG", ".", "getTargetConstantPool", "(", "GV" ]

[ "A", ",", "_", "_", "m256i", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_cmpgt_epu64_mask", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256i", "_", "_" ]

[ "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_cmpge_epu64_mask", "(", "_", "_", "m512i", "_", "_", "X", ",", "_", "_", "m512i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_ucmpq512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "X", ",", "(", "_", "_", "v8di", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_" ]