Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

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

[ "<STR_LIT>", ")", ")", ")", "Value", "|=", "(", "<NUM_LIT>", "<<", "QBitShift", ")", ";" ]

[ "const", "MCOperand", "Op2", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Value", "&=", "~", "(", "<NUM_LIT>", "<<", "PBitShift", ")", ";", "if", "(", "!", "LPAC", "::", "isPostOp", "(", "AluCode", ")", "&&", "(", "(", "Op2", ".", "isImm", "(", ")", "&&", "Op2", ".", "getImm", "(", ")", "!=", "<NUM_LIT>", ")", "||", "(", "Op2", ".", "isReg", "(", ")", "&&", "Op2", ".", "getReg", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "(", "Op2", ".", "isExpr", "(", ")", ")", ")", ")", "Value", "|=", "(", "<NUM_LIT>", "<<", "PBitShift", ")", ";", "assert", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Expected register operand.", "<STR_LIT>", ")", ";", "Value", "&=", "~", "(", "<NUM_LIT>", "<<", "QBitShift", ")", ";", "if", "(", "LPAC", "::", "modifiesOp", "(", "AluCode", ")", "&&", "(", "(", "Op2", ".", "isImm", "(", ")", "&&", "Op2", ".", "getImm", "(", ")", "!=", "<NUM_LIT>", ")", "||", "(", "Op2", ".", "isReg", "(", ")", "&&", "Op2", ".", "getReg", "(", ")", "!=", "<STR_LIT>", "::" ]

[ "BaseRegNum", ")", ")", ";" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "getImm", "(", ")", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "return", ";", "}", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Memory", "." ]

[ "}" ]

[ "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "getOrder", "(", ")", "const", "{", "return", "Order", ";" ]

[ "<NUM_LIT>", ";" ]

[ "unsigned", "descriptorEnvironmentPointerOffset", "(", ")", "const", "{", "assert", "(", "usesFunctionDescriptors", "(", ")", "&&", "<STR_LIT>", "Should only be called when the target uses descriptors.", "<STR_LIT>", ")", ";", "return", "IsPPC64", "?", "<NUM_LIT>", ":" ]

[ "}" ]

[ "def", "VLD4LNq16_UPD", ":", "VLD4LNWB", "<", "<NUM_LIT>", ",", "{", "?", ",", "?", ",", "<NUM_LIT>", ",", "?", "}", ",", "<STR_LIT>", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "case", "Hexagon", "::", "CMPbEQrr_sbsb_V4", ":" ]

[ "case", "Hexagon", "::", "CMPGTUri", ":", "case", "Hexagon", "::", "CMPGTUrr", ":", "case", "Hexagon", "::", "CMPGTri", ":", "case", "Hexagon", "::", "CMPGTrr", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "~", "<NUM_LIT>", ";", "break", ";", "case", "Hexagon", "::", "CMPbEQri_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_sbsb_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_ubub_V4", ":", "case", "Hexagon", "::", "CMPbGTUri_V4", ":", "case", "Hexagon", "::", "CMPbGTUrr_V4", ":", "case", "Hexagon", "::", "CMPbGTrr_V4", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "<NUM_LIT>", ";", "break", ";", "case", "Hexagon", "::", "CMPhEQri_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_shl_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_xor_V4", ":", "case", "Hexagon", "::", "CMPhGTUri_V4", ":", "case", "Hexagon", "::", "CMPhGTUrr_V4", ":", "case", "Hexagon", "::", "CMPhGTrr_shl_V4", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "<NUM_LIT>", ";", "break", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "CMPEHexagon4rr", ":", "case", "Hexagon", "::", "CMPEQrr", ":", "case", "Hexagon", "::", "CMPGT64rr", ":", "case", "Hexagon", "::", "CMPGTU64rr", ":", "case", "Hexagon", "::", "CMPGTUrr", ":", "case", "Hexagon", "::", "CMPGTrr", ":" ]

[ "return", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ";" ]

[ "case", "ESize16", ":", "return", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", "|", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ";", "case", "ESize32", ":" ]

[ "=", "instr_asm", ";" ]

[ "bit", "hasSideEffects", "=", "<NUM_LIT>", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "]", ";", "InstrItinClass", "Itinerary", "=", "NoItinerary", ";", "Format", "Form", "=", "FrmR", ";", "string", "BaseOpcode" ]

[ "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{" ]

[ "class", "arith_extended_reg32", "<", "ValueType", "Ty", ">", ":", "Operand", "<", "Ty", ">", ",", "ComplexPattern", "<", "Ty", "," ]

[ "<STR_LIT>", ")" ]

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

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

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

[ "||", "!", "Op", ".", "isKill", "(", ")", ")", "continue", ";" ]

[ "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "Op", ".", "getReg", "(", ")", "!=", "RegNotKilled" ]

[ ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "DL", ",", "MVT", "::", "v8i8", ",", "&", "VTBLMask", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "SDValue", "V2", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "DL", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "VTBLMask", ";", "for", "(", "ArrayRef", "<", "int", ">", "::", "iterator", "I", "=", "ShuffleMask", ".", "begin", "(", ")", ",", "E", "=", "ShuffleMask", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "VTBLMask", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "*", "I", ",", "MVT", "::", "i32", ")", ")", ";", "if", "(", "V2", ".", "getNode", "(", ")", "->", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8i8", ",", "V1", ",", "DAG" ]

[ "}" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

[ "addImm", "(", "<NUM_LIT>", ")", ".", "addOperand", "(", "Op", ")", ";" ]

[ "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "assert", "(", "MFI", "->", "getShaderType", "(", ")", "==", "ShaderType", "::", "PIXEL", "||", "MFI", "->", "getShaderType", "(", ")", "==", "ShaderType", "::", "GEOMETRY", ")", ";", "if", "(", "(", "Op", ".", "isImm", "(", ")", ")", ")", "{", "if", "(", "Op", ".", "getImm", "(", ")", "&", "<NUM_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_CMPX_LE_F32_e32", ")", ")", "." ]

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

[ "void", "PPCELFStreamer", "::", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "PPCMCCodeEmitter", "*", "Emitter", "=", "static_cast", "<", "PPCMCCodeEmitter", "*", ">", "(", "getAssembler", "(", ")", ".", "getEmitterPtr", "(", ")", ")", ";", "if", "(", "!", "Emitter", "->", "isPrefixedInstruction", "(", "Inst", ")", ")", "{", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "emitCodeAlignment", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "MCFragment", "*", "InstructionFragment", "=", "getCurrentFragment", "(", ")", ";", "SMLoc", "InstLoc", "=", "Inst", ".", "getLoc", "(", ")", ";", "if", "(", "LastLabel", "&&", "!", "LastLabel", "->", "isUnset", "(", ")", "&&", "LastLabelLoc", ".", "isValid", "(", ")", "&&", "InstLoc", ".", "isValid", "(", ")", ")", "{", "const", "SourceMgr", "*", "SourceManager", "=", "getContext", "(", ")", ".", "getSourceManager", "(", ")", ";", "unsigned", "InstLine", "=", "SourceManager", "->", "FindLineNumber", "(", "InstLoc", ")", ";", "unsigned", "LabelLine", "=", "SourceManager", "->", "FindLineNumber", "(", "LastLabelLoc", ")", ";", "if", "(", "InstLine", "==", "LabelLine", ")", "{", "AssignFragment", "(", "LastLabel", ",", "InstructionFragment", ")", ";", "LastLabel", "->", "setOffset", "(", "<NUM_LIT>", ")", ";", "}", "}", "}" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "V4SF", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]" ]

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

[ "MipsAsmParser", "(", "MCSubtargetInfo", "&", "sti", ",", "MCAsmParser", "&", "parser", ",", "const", "MCInstrInfo", "&", "MII", ",", "const", "MCTargetOptions", "&", "Options", ")", ":", "MCTargetAsmParser", "(", ")", ",", "STI", "(", "sti", ")", ",", "ABI", "(", "MipsABIInfo", "::", "computeTargetABI", "(", "Triple", "(", "sti", ".", "getTargetTriple", "(", ")", ")", ",", "sti", ".", "getCPU", "(", ")", ",", "Options", ")", ")", "{", "MCAsmParserExtension", "::", "Initialize", "(", "parser", ")", ";", "parser", ".", "addAliasForDirective", "(", "<STR_LIT>", ".asciiz", "<STR_LIT>", ",", "<STR_LIT>", ".asciz", "<STR_LIT>", ")", ";", "setAvailableFeatures", "(", "ComputeAvailableFeatures", "(", "STI", ".", "getFeatureBits" ]

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

[ "let", "Name" ]

[ "(", "v4f32", "V128", ":", "$", "Rn", ")", ")", ")", "]", ">", ";" ]

[ "def", "v4f32", ":", "BaseSIMDTwoSameVector", "<", "<NUM_LIT>", ",", "U", ",", "{", "S", ",", "<NUM_LIT>", "}", ",", "opc", ",", "V128", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v4f32", "V128", ":", "$", "Rd", ")", ",", "(", "OpNode" ]

[ "fprintf", "(", "file", ",", "<STR_LIT>", ")", "<STR_LIT>", ")", ";" ]

[ "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "text_segment_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "gs(", "<STR_LIT>", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "+", "<STR_LIT>", "HOST_WIDE_INT_PRINT_DEC", "<STR_LIT>", ")", "<STR_LIT>", ",", "<NUM_LIT>", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "AVR_3_BYTE_PC", ")", "if", "(", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "pointer offset from symbol maybe incorrect", "<STR_LIT>", ")", ")", "{", "output_addr_const", "(", "stderr", ",", "addr", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "}", "else", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "gs(", "<STR_LIT>", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";" ]

[ "MIB", ".", "addReg", "(", "PPC", "::", "X2", ",", "RegState", "::", "Implicit", ")", ";" ]

[ "if", "(", "Subtarget", "->", "isUsingPCRelativeCalls", "(", ")", ")", "return", "false", ";", "Type", "*", "RetTy", "=", "CLI", ".", "RetTy", ";", "MVT", "RetVT", ";", "if", "(", "RetTy", "->", "isVoidTy", "(", ")", ")", "RetVT", "=", "MVT", "::", "isVoid", ";", "else", "if", "(", "!", "isTypeLegal", "(", "RetTy", ",", "RetVT", ")", "&&", "RetVT", "!=", "MVT", "::", "i16", "&&", "RetVT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "else", "if", "(", "RetVT", "==", "MVT", "::", "i1", "&&", "Subtarget", "->", "useCRBits", "(", ")", ")", "return", "false", ";", "if", "(", "RetVT", "!=", "MVT", "::", "isVoid", "&&", "RetVT", "!=", "MVT", "::", "i8", "&&", "RetVT", "!=", "MVT", "::", "i16", "&&", "RetVT", "!=", "MVT", "::", "i32", "&&", "RetVT", "!=", "MVT", "::", "i64", "&&", "RetVT", "!=", "MVT", "::", "f32", "&&", "RetVT", "!=", "MVT", "::", "f64", ")", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "IsVarArg", ",", "*", "FuncInfo", ".", "MF", ",", "RVLocs", ",", "*", "Context", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "RetVT", ",", "RetCC_PPC64_ELF_FIS", ")", ";", "if", "(", "RVLocs", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "return", "false", ";", "}", "unsigned", "NumArgs", "=", "CLI", ".", "OutVals", ".", "size", "(", ")", ";", "if", "(", "NumArgs", ">", "<NUM_LIT>", ")", "return", "false", ";", "SmallVector", "<", "Value", "*", ",", "<NUM_LIT>", ">", "Args", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "ArgRegs", ";", "SmallVector", "<", "MVT", ",", "<NUM_LIT>", ">", "ArgVTs", ";", "SmallVector", "<", "ISD", "::", "ArgFlagsTy", ",", "<NUM_LIT>", ">", "ArgFlags", ";", "Args", ".", "reserve", "(", "NumArgs", ")", ";", "ArgRegs", ".", "reserve", "(", "NumArgs", ")", ";", "ArgVTs", ".", "reserve", "(", "NumArgs", ")", ";", "ArgFlags", ".", "reserve", "(", "NumArgs", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "ie", "=", "NumArgs", ";", "i", "!=", "ie", ";", "++", "i", ")", "{", "ISD", "::", "ArgFlagsTy", "Flags", "=", "CLI", ".", "OutFlags", "[", "i", "]", ";", "if", "(", "Flags", ".", "isInReg", "(", ")", "||", "Flags", ".", "isSRet", "(", ")", "||", "Flags", ".", "isNest", "(", ")", "||", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "Value", "*", "ArgValue", "=", "CLI", ".", "OutVals", "[", "i", "]", ";", "Type", "*", "ArgTy", "=", "ArgValue", "->", "getType", "(", ")", ";", "MVT", "ArgVT", ";", "if", "(", "!", "isTypeLegal", "(", "ArgTy", ",", "ArgVT", ")", "&&", "ArgVT", "!=", "MVT", "::", "i16", "&&", "ArgVT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "if", "(", "ArgVT", ".", "isVector", "(", ")", "||", "ArgVT", "==", "MVT", "::", "f128", ")", "return", "false", ";", "Register", "Arg", "=", "getRegForValue", "(", "ArgValue", ")", ";", "if", "(", "Arg", "==", "<NUM_LIT>", ")", "return", "false", ";", "Args", ".", "push_back", "(", "ArgValue", ")", ";", "ArgRegs", ".", "push_back", "(", "Arg", ")", ";", "ArgVTs", ".", "push_back", "(", "ArgVT", ")", ";", "ArgFlags", ".", "push_back", "(", "Flags", ")", ";", "}", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "RegArgs", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "Args", ",", "ArgRegs", ",", "ArgVTs", ",", "ArgFlags", ",", "RegArgs", ",", "CC", ",", "NumBytes", ",", "IsVarArg", ")", ")", "return", "false", ";", "MachineInstrBuilder", "MIB", ";", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "Callee", ")", ";", "if", "(", "!", "GV", ")", "{", "if", "(", "CLI", ".", "IsPatchPoint", ")", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "MIMD", ",", "TII", ".", "get", "(", "PPC", "::", "NOP", ")", ")", ";", "else", "return", "false", ";", "}", "else", "{", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "MIMD", ",", "TII", ".", "get", "(", "PPC", "::", "BL8_NOP", ")", ")", ";", "MIB", ".", "addGlobalAddress", "(", "GV", ")", ";", "}", "for", "(", "unsigned", "Reg", ":", "RegArgs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "PPCFuncInfo", "->", "setUsesTOCBasePtr", "(", ")", ";" ]

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

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "VF1", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_duplicate", ":", "VF1", "<BUGE>", "(", "vec_select", ":", "SF", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]" ]

[ "}" ]

[ "}", "]", ">", "{", "let", "ParserMatchClass", "=", "Imm1_16Operand", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "<", "TRI", ".", "getEncodingValue", "(", "RHS", ".", "first", ")", ";" ]

[ "Register", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "(", "Func", ")", "(", "Reg", ",", "STI", ".", "splitFramePushPop", "(", "MF", ")", ")", ")", "continue", ";", "if", "(", "Reg", ">=", "ARM", "::", "D8", "&&", "Reg", "<", "ARM", "::", "D8", "+", "NumAlignedDPRCS2Regs", ")", "continue", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", "&&", "!", "MRI", ".", "isReserved", "(", "Reg", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "NoGap", "&&", "LastReg", "&&", "LastReg", "!=", "Reg", "-", "<NUM_LIT>", ")", "break", ";", "LastReg", "=", "Reg", ";", "Regs", ".", "push_back", "(", "std", "::", "make_pair", "(", "Reg", ",", "!", "isLiveIn", ")", ")", ";", "}", "if", "(", "Regs", ".", "empty", "(", ")", ")", "continue", ";", "llvm", "::", "sort", "(", "Regs", ",", "[", "&", "]", "(", "const", "RegAndKill", "&", "LHS", ",", "const", "RegAndKill", "&", "RHS", ")", "{", "return", "TRI", ".", "getEncodingValue", "(", "LHS", ".", "first", ")" ]

[ "]", ")" ]

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

[ "}" ]

[ "bool", "hasApertureRegs", "(", ")", "const", "{", "return", "HasApertureRegs", ";" ]

[ "<FIXS>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "return", "<STR_LIT>", "elsereturn", "<STR_LIT>", "<BUGS>", "}", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "int", "i", ",", "words", ";", "words", "=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "/", "<NUM_LIT>", ";", "pdp11_expand_operands", "(", "operands", ",", "exops", ",", "<NUM_LIT>", ",", "action", ",", "either", ")", ";", "if", "(", "action", "[", "<NUM_LIT>", "]", "==", "dec_before", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "sub $4,%0", "<STR_LIT>", ",", "operands", ")", ";", "}", "if", "(", "action", "[", "<NUM_LIT>", "]", "==", "dec_before", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "sub $4,%1", "<STR_LIT>", ",", "operands", ")", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "words", ";", "i", "++", ")", "output_asm_insn", "(", "singlemove_string", "(", "exops", "[", "i", "]", ")", ",", "exops", "[", "i", "]", ")", ";", "if", "(", "action", "[", "<NUM_LIT>", "]", "==", "inc_after", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "add $4,%0", "<STR_LIT>", ",", "operands", ")", ";", "}", "if", "(", "action", "[", "<NUM_LIT>", "]", "==", "inc_after", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "add $4,%1", "<STR_LIT>", ",", "operands", ")", ";", "}" ]

[ "<STR_LIT>" ]

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

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

[ "def", "L2_loadri_pr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_74d4e5", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "}" ]

[ "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", "(", "VT", ".", "getVectorNumElements", "(", ")", ",", "Value", ")", ";", "return", "DAG", ".", "getBuildVector", "(", "VT", ",", "DL", ",", "Ops", ")", ";", "}", "if", "(", "Value", ".", "isUndef", "(", ")", ")", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "VT", ",", "Value", ")", ";" ]

[ "_", "_", "b", ")", "{" ]

[ "vrshr_n_u16", "(", "uint16x4_t", "_", "_", "a", ",", "const", "int" ]

[ "MIB", ".", "addMBB", "(", "TBB", ")", ";" ]

[ "}", "else", "if", "(", "!", "FBB", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "Cond", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "Cond", "[", "i", "]", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "return", ")", "]" ]

[ "}" ]

[ "vsri_n_p64", "(", "poly64x1_t", "_", "_", "a", ",", "poly64x1_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "poly64x1_t", ")", "_", "_", "builtin_neon_vsri_ndi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c", ")", ";" ]

[ "bitmask", ")", ";" ]

[ "DebugLoc", "DL", "(", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "int", "fi", "=", "PMFI", "->", "getSinglePathS0SpillFI", "(", "slot", ")", ";", "unsigned", "tmpReg", "=", "GuardsReg", ";", "int", "bitpos", "=", "TRI", "->", "getS0Index", "(", "predReg", ")", ";", "assert", "(", "bitpos", ">", "<NUM_LIT>", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "tmpReg", ")", ")", ".", "addFrameIndex", "(", "fi", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "tmpReg", ")", ".", "addReg", "(", "guard", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "tmpReg", ")", ".", "addImm", "(", "bitpos", ")", ".", "addOperand", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ".", "addOperand", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ";", "InsertedInstrs", "++", ";", "uint32_t", "or", "_", "bitmask", "=", "<NUM_LIT>", "<<", "bitpos", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "PRTmp", ")", ")", ".", "addReg", "(", "guard", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addOperand", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ".", "addOperand", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ";", "assert", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "or", "_" ]

[ "{" ]

[ "MVT", "VT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "int", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "int", "NumBytes", "=", "NumElts", "*", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "/", "<NUM_LIT>", ")", ";", "MVT", "CurrVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i8", ",", "NumBytes", ")", ";", "const", "int", "LUT", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "LUTVec", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "LUTVec", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "LUT", "[", "i", "%", "<NUM_LIT>", "]", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "InRegLUT", "=", "DAG", ".", "getBuildVector", "(", "CurrVT", ",", "DL", ",", "LUTVec", ")", ";", "SDValue", "Op0", "=", "DAG", ".", "getBitcast", "(", "CurrVT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Zero", "=", "getZeroVector", "(", "CurrVT", ",", "Subtarget", ",", "DAG", ",", "DL", ")", ";", "SDValue", "NibbleMask", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "CurrVT", ")", ";", "SDValue", "NibbleShift", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "CurrVT", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "CurrVT", ",", "Op0", ",", "NibbleMask", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "CurrVT", ",", "Op0", ",", "NibbleShift", ")", ";", "SDValue", "HiZ", ";", "if", "(", "CurrVT", ".", "is512BitVector", "(", ")", ")", "{", "MVT", "MaskVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "CurrVT", ".", "getVectorNumElements", "(", ")", ")", ";", "HiZ", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "MaskVT", ",", "Hi", ",", "Zero", ",", "ISD", "::", "SETEQ", ")", ";", "HiZ", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "CurrVT", ",", "HiZ", ")", ";", "}", "else" ]

[ ":", "$", "Rx", ",", "<NUM_LIT>", ")", ">", ";" ]

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "MFSPR", "gprc" ]

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

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

[ "_", "o", ",", "(", "int8x8_t", ")", "_", "_", "c", ")", ";" ]

[ "union", "{", "uint8x8x4_t", "_", "_", "i", ";", "_", "_", "builtin_neon_oi", "_", "_", "o", ";", "}", "_", "_", "bu", "=", "{", "_", "_", "b", "}", ";", "return", "(", "uint8x8_t", ")", "_", "_", "builtin_neon_vtbx4v8qi", "(", "(", "int8x8_t", ")", "_", "_", "a", ",", "_", "_", "bu", ".", "_" ]

[ "}" ]

[ "if", "(", "ConstantSDNode", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "ShImmVal", "=", "RHS", "->", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ";", "Opc", "=", "getI32Imm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "ShOpcVal", ",", "ShImmVal", ")", ")", ";", "return", "true", ";" ]

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

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

[ "_", "_", "lasx_xvfmina_s", "(", "_", "_", "m256", "_", "<NUM_LIT>", ",", "_", "_", "m256", "_", "<NUM_LIT>", ")", "{" ]

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

[ "<STR_LIT>" ]

[ "(", "udiv", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "umod", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "unspec", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_DIV_ALREADY_SPLIT", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "static", "void", "emit_move_after_reload", "(", "rtx", "to", ",", "rtx", "from", ",", "rtx", "scratch", ")", "{", "rtx", "insn", ";", "if", "(", "TARGET_M6812", "||", "H_REG_P", "(", "to", ")", "||", "H_REG_P", "(", "from", ")", ")", "{", "insn", "=", "emit_move_insn", "(", "to", ",", "from", ")", ";", "}", "else", "{", "emit_move_insn", "(", "scratch", ",", "from", ")", ";", "insn", "=", "emit_move_insn", "(", "to", ",", "scratch", ")", ";", "}", "if", "(", "IS_STACK_PUSH", "(", "to", ")", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "XEXP", "(", "XEXP", "(", "to", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "else", "if", "(", "IS_STACK_POP", "(", "from", ")", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "XEXP", "(", "XEXP", "(", "from", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "else", "if", "(", "TARGET_M6811", "&&", "SP_REG_P", "(", "from", ")", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "from", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "}" ]

[ "Emit", "a", "move", "after", "the", "reload", "pass", "has", "completed", ".", "This", "is", "used", "to", "emit", "the", "prologue", "and", "epilogue", "." ]

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

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

[ "Width", ",", "Val", ")", ";" ]

[ "return", "createSRegOperand", "(", "getTtmpClassId", "(", "Width", ")", ",", "Val", "-", "TTMP_MIN", ")", ";", "}", "assert", "(", "Width", "==", "OPW16", "||", "Width", "==", "OPW32", "||", "Width", "==", "OPW64", ")", ";", "if", "(", "INLINE_INTEGER_C_MIN", "<=", "Val", "&&", "Val", "<=", "INLINE_INTEGER_C_MAX", ")", "return", "decodeIntImmed", "(", "Val", ")", ";", "if", "(", "INLINE_FLOATING_C_MIN", "<=", "Val", "&&", "Val", "<=", "INLINE_FLOATING_C_MAX", ")", "return", "decodeFPImmed", "(" ]

[ "bool", "SIFixSGPRCopies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "Worklist", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "continue", ";", "case", "AMDGPU", "::", "COPY", ":", "{", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "SrcRC", ",", "*", "DstRC", ";", "std", "::", "tie", "(", "SrcRC", ",", "DstRC", ")", "=", "getCopyRegClasses", "(", "MI", ",", "*", "TRI", ",", "MRI", ")", ";", "if", "(", "isVGPRToSGPRCopy", "(", "SrcRC", ",", "DstRC", ",", "*", "TRI", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Fixing VGPR -> SGPR copy: ", "<STR_LIT>", "<<", "MI", ")", ";", "TII", "->", "moveToVALU", "(", "MI", ")", ";", "}", "break", ";", "}", "case", "AMDGPU", "::", "PHI", ":", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Fixing PHI: ", "<STR_LIT>", "<<", "MI", ")", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "TRI", "->", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "Reg", ")", ")", ")", "break", ";", "bool", "SGPRBranch", "=", "false", ";", "bool", "HasBreakDef", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "MI", ".", "getNumOperands", "(", ")", ";", "i", "+=", "<NUM_LIT>", ")", "{", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "if", "(", "TRI", "->", "hasVGPRs", "(", "MRI", ".", "getRegClass", "(", "Reg", ")", ")", ")", "{", "TII", "->", "moveToVALU", "(", "MI", ")", ";", "break", ";", "}", "MachineInstr", "*", "DefInstr", "=", "MRI", ".", "getUniqueVRegDef", "(", "Reg", ")", ";", "assert", "(", "DefInstr", ")", ";", "switch", "(", "DefInstr", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_BREAK", ":", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "case", "AMDGPU", "::", "PHI", ":", "HasBreakDef", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "SGPRBranch", "&&", "!", "HasBreakDef", ")", "TII", "->", "moveToVALU", "(", "MI", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "REG_SEQUENCE", ":", "{", "if", "(", "TRI", "->", "hasVGPRs", "(", "TII", "->", "getOpRegClass", "(", "MI", ",", "<NUM_LIT>", ")", ")", "||", "!", "hasVGPROperands", "(", "MI", ",", "TRI", ")", ")", "{", "foldVGPRCopyIntoRegSequence", "(", "MI", ",", "TRI", ",", "TII", ",", "MRI", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Fixing REG_SEQUENCE: ", "<STR_LIT>", "<<", "MI", ")", ";", "TII", "->", "moveToVALU", "(", "MI", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "INSERT_SUBREG", ":", "{", "const", "TargetRegisterClass", "*", "DstRC", ",", "*", "Src0RC", ",", "*", "Src1RC", ";", "DstRC", "=", "MRI", ".", "getRegClass", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "Src0RC", "=", "MRI", ".", "getRegClass", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "Src1RC", "=", "MRI", ".", "getRegClass", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "TRI", "->", "isSGPRClass", "(", "DstRC", ")", "&&", "(", "TRI", "->", "hasVGPRs", "(", "Src0RC", ")", "||", "TRI", "->", "hasVGPRs", "(", "Src1RC", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " Fixing INSERT_SUBREG: ", "<STR_LIT>", "<<", "MI", ")", ";", "TII", "->", "moveToVALU", "(", "MI", ")", ";", "}", "break", ";", "}", "}", "}", "}", "return", "true", ";", "}" ]

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

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isCommutable", "=", "<NUM_LIT>", ";", "let", "isPredicable", "=", "<NUM_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", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "src2", ")", ")", "]", ",", "IIC_BT_RI", ">", ",", "OpSize16", ",", "TB", ";" ]

[ "def", "BT16ri8", ":", "Ii8", "<", "<NUM_LIT>", ",", "MRM4r", ",", "(", "outs", ")", ",", "(", "ins", "GR16", ":", "$", "src1", ",", "i16i8imm", ":", "$", "src2", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "EFLAGS", ",", "(", "X86bt", "GR16", ":", "$", "src1", ",", "i16immSExt8", ":", "$" ]

[ "Instruction", "*", "Reload", "=", "B", ".", "CreateLoad", "(", "Alloc", ")", ";" ]

[ "const", "AMDGPUAS", "AS", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "*", "M", ")", ";", "nf", ".", "getLeads", "(", ")", "[", "<NUM_LIT>", "]", ".", "PtrKind", "=", "AMDGPULibFunc", "::", "getEPtrKindFromAddrSpace", "(", "AS", ".", "FLAT_ADDRESS", ")", ";", "Function", "*", "Fsincos", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "getFunction", "(", "M", ",", "nf", ")", ")", ";", "if", "(", "!", "Fsincos", ")", "return", "false", ";", "BasicBlock", "::", "iterator", "ItOld", "=", "B", ".", "GetInsertPoint", "(", ")", ";", "AllocaInst", "*", "Alloc", "=", "insertAlloca", "(", "UI", ",", "B", ",", "<STR_LIT>", "__sincos_", "<STR_LIT>", ")", ";", "B", ".", "SetInsertPoint", "(", "UI", ")", ";", "Value", "*", "P", "=", "Alloc", ";", "Type", "*", "PTy", "=", "Fsincos", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "<NUM_LIT>", ")", ";", "if", "(", "PTy", "->", "getPointerAddressSpace", "(", ")", "!=", "AS", ".", "PRIVATE_ADDRESS", ")", "P", "=", "B", ".", "CreateAddrSpaceCast", "(", "Alloc", ",", "PTy", ")", ";", "CallInst", "*", "Call", "=", "CreateCallEx2", "(", "B", ",", "Fsincos", ",", "UI", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ",", "P", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "AMDIC: fold_sincos (", "<STR_LIT>", "<<", "*", "CI", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "*", "UI", "<<", "<STR_LIT>", ") with ", "<STR_LIT>", "<<", "*", "Call", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "isSin", ")", "{", "B", ".", "SetInsertPoint", "(", "&", "*", "ItOld", ")", ";", "UI", "->", "replaceAllUsesWith", "(", "&", "*", "Call", ")", ";" ]

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

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

[ "auto", "*", "IVExpr", "=", "SE", "->", "getSCEV", "(", "IV", ")", ";" ]

[ "auto", "*", "VW", "=", "SE", "->", "getSCEV", "(", "ConstantInt", "::", "get", "(", "TripCount", "->", "getType", "(", ")", ",", "VectorWidth", ")", ")", ";", "auto", "*", "ECPlusVWMinus1", "=", "SE", "->", "getAddExpr", "(", "EC", ",", "SE", "->", "getSCEV", "(", "ConstantInt", "::", "get", "(", "TripCount", "->", "getType", "(", ")", ",", "VectorWidth", "-", "<NUM_LIT>", ")", ")", ")", ";", "auto", "*", "Ceil", "=", "SE", "->", "getUDivExpr", "(", "ECPlusVWMinus1", ",", "VW", ")", ";", "(", "void", ")", "TC", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: Analysing overflow behaviour for:\\n", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: - TripCount = ", "<STR_LIT>", ";", "TC", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: - ElemCount = ", "<STR_LIT>", ";", "EC", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: - VecWidth = ", "<STR_LIT>", "<<", "VectorWidth", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: - (ElemCount+VW-1) / VW = ", "<STR_LIT>", ";", "Ceil", "->", "dump", "(", ")", ";", ")", ";", "const", "SCEV", "*", "Sub", "=", "SE", "->", "getMinusSCEV", "(", "SE", "->", "getBackedgeTakenCount", "(", "L", ")", ",", "SE", "->", "getUDivExpr", "(", "SE", "->", "getAddExpr", "(", "SE", "->", "getMulExpr", "(", "Ceil", ",", "VW", ")", ",", "SE", "->", "getNegativeSCEV", "(", "VW", ")", ")", ",", "VW", ")", ")", ";", "Sub", "=", "SE", "->", "applyLoopGuards", "(", "Sub", ",", "L", ")", ";", "if", "(", "!", "Sub", "->", "isZero", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: possible overflow in sub expression.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "}", "auto", "*", "IV", "=", "ActiveLaneMask", "->", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "def", "tvecshiftR16", ":", "Operand", "<", "i32", ">", ",", "TImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "Imm1_16Operand", ";" ]

[ "bool", "constant_address_p", "(", "rtx", "x", ")", "{", "return", "CONSTANT_P", "(", "x", ")", "&&", "legitimate_address_p", "(", "Pmode", ",", "x", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", "address", "." ]

[ "}" ]

[ "SPIRVType", "*", "relTy", "=", "resType", ";", "Register", "cmpReg", "=", "resVReg", ";", "if", "(", "!", "IsBoolReturn", ")", "cmpReg", "=", "buildScalarOrVectorBoolReg", "(", "MIRBuilder", ",", "relTy", ",", "resType", ",", "GR", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstr", "(", "opcode", ")", ".", "addDef", "(", "cmpReg", ")", ".", "addUse", "(", "GR", "->", "getSPIRVTypeID", "(", "relTy", ")", ")", ";", "for", "(", "auto", "arg", ":", "OrigArgs", ")", "{", "MIB", ".", "addUse", "(", "arg", ")", ";", "}", "bool", "Result", "=", "constrainRegOperands", "(", "MIB", ")", ";", "if", "(", "!", "IsBoolReturn", ")", "return", "buildScalarOrVectorSelect", "(", "MIRBuilder", ",", "resVReg", ",", "cmpReg", ",", "resType", ",", "GR", ")", ";", "return", "Result", ";" ]

[ "c_register_pragma", "(", "NULL", ",", "<STR_LIT>", "ctable_entry", "<STR_LIT>", ",", "pru_pragma_ctable_entry", ")", ";" ]

[ "void", "pru_register_pragmas", "(", "void", ")", "{", "c_register_pragma", "(", "NULL", ",", "<STR_LIT>", "ctable_entry", "<STR_LIT>", ",", "pru_pragma_ctable_entry", ")", ";", "c_register_pragma", "(", "NULL", ",", "<STR_LIT>", "CTABLE_ENTRY", "<STR_LIT>", ",", "pru_pragma_ctable_entry", ")", ";", "c_register_addr_space", "(", "<STR_LIT>", "__regio_symbol", "<STR_LIT>", ",", "ADDR_SPACE_REGIO", ")", ";", "}", "void", "pru_register_pragmas", "(", "void", ")", "{" ]

[ ")", ",", "Node", "->", "getSynchScope", "(", ")", ")", ";" ]

[ "SDValue", "Src2", "=", "Node", "->", "getVal", "(", ")", ";", "SDValue", "NegSrc2", ";", "SDLoc", "DL", "(", "Src2", ")", ";", "if", "(", "auto", "*", "Op2", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src2", ")", ")", "{", "int64_t", "Value", "=", "(", "-", "Op2", "->", "getAPIntValue", "(", ")", ")", ".", "getSExtValue", "(", ")", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Value", ")", "||", "Subtarget", ".", "hasInterlockedAccess1", "(", ")", ")", "NegSrc2", "=", "DAG", ".", "getConstant", "(", "Value", ",", "DL", ",", "MemVT", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "hasInterlockedAccess1", "(", ")", ")", "NegSrc2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "MemVT", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MemVT", ")", ",", "Src2", ")", ";", "if", "(", "NegSrc2", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getAtomic", "(", "ISD", "::", "ATOMIC_LOAD_ADD", ",", "DL", ",", "MemVT", ",", "Node", "->", "getChain", "(", ")", ",", "Node", "->", "getBasePtr", "(", ")", ",", "NegSrc2", ",", "Node", "->", "getMemOperand", "(", ")", ",", "Node", "->", "getOrdering", "(" ]

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

[ "LLVM_DEBUG", "(", "Current", "->", "print", "(", "dbgs", "(", ")", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", ")", ";", "Current", "->", "replaceLiveOut", "(", "Register", ",", "NewRegister", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Region after register replace\\n", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "Current", "->", "print", "(", "dbgs", "(", ")", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", ")", ";", "Current", "=", "Current", "->", "getParent", "(", ")", ";", "}", "}", "for", "(", "MachineRegisterInfo", "::", "reg_iterator", "I", "=", "MRI", "->", "reg_begin", "(", "Register", ")", ",", "E", "=", "MRI", "->", "reg_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineOperand", "&", "O", "=", "*", "I", ";", "++", "I", ";", "if", "(", "O", ".", "isDef", "(", ")", ")", "continue", ";", "bool", "IsInside", "=", "contains", "(", "O", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ")", ";", "bool", "IsLoopPHI", "=", "IsInside", "&&", "(", "O", ".", "getParent", "(", ")", "->", "isPHI", "(", ")", "&&", "O", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "getEntry", "(", ")", ")", ";", "bool", "ShouldReplace", "=", "(", "IsInside", "&&", "ReplaceInside", ")", "||", "(", "!", "IsInside", "&&", "ReplaceOutside", ")", "||", "(", "IncludeLoopPHI", "&&", "IsLoopPHI", ")", ";", "if", "(", "ShouldReplace", ")", "{", "if", "(", "NewRegister", ".", "isPhysical", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Trying to substitute physical register: ", "<STR_LIT>", "<<", "printReg", "(", "NewRegister", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Cannot substitute physical registers", "<STR_LIT>", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Replacing register (region): ", "<STR_LIT>", "<<", "printReg", "(", "Register", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", "<<", "<STR_LIT>", " with ", "<STR_LIT>", "<<", "printReg", "(", "NewRegister", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")" ]

[ "}" ]

[ "if", "(", "!", "Instr", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", "return", ";", "MachineBasicBlock", "::", "iterator", "DI", "=", "*", "Instr", ";", "++", "DI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "DE", "=", "Instr", "->", "getParent", "(", ")", "->", "end", "(", ")", ";", "DI", "!=", "DE", ";", "++", "DI", ")", "{", "if", "(", "DI", "->", "isDebugValue", "(", ")", "&&", "DI", "->", "getDebugOperandForReg", "(", "Instr", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "DbgValues", ".", "push_back", "(", "&", "*", "DI", ")", ";", "}" ]

[ ")", ";" ]

[ "HII", "=", "HST", "->", "getInstrInfo", "(", ")", ";", "HRI", "=", "HST", "->", "getRegisterInfo", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "updateAligna", "(" ]

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

[ "def", ":", "InstAlias", "<", "cmp", "#", "<STR_LIT>", ",", "(", "!", "cast", "<", "Instruction", ">", "(", "NAME", "#", "<STR_LIT>", ")", "WZR", ",", "GPR32sponly", ":", "$", "src1", ",", "GPR32", ":", "$", "src2" ]

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

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

[ ";" ]

[ "int", "AArch64TargetLowering", "::", "getScalingFactorCost", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "isLegalAddressingMode", "(", "AM", ",", "Ty", ")", ")", "return", "AM", ".", "Scale", "!=", "<NUM_LIT>", "&&", "AM", ".", "Scale", "!=", "<NUM_LIT>", ";", "return", "-", "<NUM_LIT>" ]

[ "}" ]

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

[ "<FIXS>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "QI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "SI", "SP_REG", ")", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "SP_REG", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>" ]

[ "}", ")", "(", "define_insn_and_split", "<STR_LIT>", "<BUGS>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "QI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "SI", "SP_REG", ")", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "SP_REG", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", ")", "<BUGE>", "(", "unspec", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_CALL_NEEDS_VZEROUPPER", ")", "]", "<STR_LIT>" ]

[ "shift", "#", "<STR_LIT>", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "!", "cast", "<", "AsmOperandClass", ">", "(", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ")", ";", "let", "DecoderMethod", "=", "<STR_LIT>", "#" ]

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

[ "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "src", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Rdst", ")", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "?", ";", "let", "SrcB", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "src", "}", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";" ]

[ ")" ]

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

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

[ "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "DI", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "reg", ":", "DI", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "CCIfType", "[", "v16i8", ",", "v8i16", ",", "v4i32", ",", "v4f32", ",", "v2f64", ",", "v2i64", "]", ",", "CCAssignToReg", "[", "V2", "]", ">", ">", "<FIXE>" ]

[ "CCIfType", "[", "f64", "]", ",", "CCAssignToReg", "[", "F1", ",", "F2", ",", "F3", ",", "F4", "]", ">", ">", ",", "<BUGS>", "CCIfType", "[", "v16i8", ",", "v8i16", ",", "v4i32", ",", "v4f32", ",", "v2f64", "]", ",", "CCAssignToReg", "[", "V2", "]", ">", ">", "<BUGE>", "]", ">", ";" ]

[ "}" ]

[ "void", "setLRStoreRequired", "(", ")", "{", "LRStoreRequired", "=", "true", ";" ]

[ "void", "mmix_asm_output_labelref", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "int", "is_extern", "=", "<NUM_LIT>", ";", "for", "(", ";", "(", "*", "name", "==", "'", "@", "'", "||", "*", "name", "==", "'", "*", "'", ")", ";", "name", "++", ")", "if", "(", "*", "name", "==", "'", "@", "'", ")", "is_extern", "=", "<NUM_LIT>", ";", "asm_fprintf", "(", "stream", ",", "<STR_LIT>", "%s%U%s", "<STR_LIT>", ",", "is_extern", "&&", "TARGET_TOPLEVEL_SYMBOLS", "?", "<STR_LIT>", ":", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ",", "name", ")", ";", "}" ]

[ "ASM_OUTPUT_LABELREF", ".", "Strip", "GCC", "'s", "'", "*", "'", "and", "our", "own", "'", "@", "'", ".", "No", "order", "is", "assumed", "." ]

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

[ "const", "Value", "*", "Opnd", "=", "nullptr", ";", "switch", "(", "Predicate", ")", "{", "default", ":", "break", ";", "case", "CmpInst", "::", "FCMP_FALSE", ":", "Opnd", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "CmpInst", "::", "FCMP_TRUE", ":", "Opnd", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "break", ";", "}", "if", "(", "Opnd", ")", "{", "unsigned", "OpReg", "=", "getRegForValue", "(", "Opnd", ")", ";", "if", "(", "OpReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "bool", "OpIsKill", "=", "hasTrivialKill", "(", "Opnd", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "RetVT", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "OpReg", ",", "getKillRegState", "(", "OpIsKill", ")", ")", ";", "UpdateValueMap", "(", "I", ",", "ResultReg", ")", ";", "return", "true", ";", "}", "}", "if", "(", "X86FastEmitCMoveSelect", "(", "RetVT", ",", "I", ")", ")", "return", "true", ";", "if", "(", "X86FastEmitSSESelect", "(", "RetVT", ",", "I", ")", ")", "return", "true", ";", "if", "(", "X86FastEmitPseudoSelect", "(", "RetVT", ",", "I", ")", ")", "return", "true", ";" ]

[ "This should not happen with red zone", "<STR_LIT>", ")", ";" ]

[ "if", "(", "stackUpdateCanBeMoved", "(", "MF", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "Info", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "CalleeSavedInfo", "CSI", ":", "Info", ")", "{", "if", "(", "CSI", ".", "isSpilledToReg", "(", ")", ")", "{", "StackUpdateLoc", "=", "MBBI", ";", "break", ";", "}", "int", "FrIdx", "=", "CSI", ".", "getFrameIdx", "(", ")", ";", "if", "(", "FrIdx", ">=", "<NUM_LIT>", ")", "continue", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FrIdx", ")", "&&", "MFI", ".", "getObjectOffset", "(", "FrIdx", ")", "<", "<NUM_LIT>", ")", "StackUpdateLoc", "--", ";", "else", "{", "StackUpdateLoc", "=", "MBBI", ";", "break", ";", "}", "}", "}", "if", "(", "FrameSize", ")", "{", "if", "(", "HasRedZone", "&&", "HasBP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrInst", ",", "RBReg", ")", ".", "addReg", "(", "BPReg", ")", ".", "addReg", "(", "BPReg", ")", ";", "}", "else", "if", "(", "FI", "->", "hasFastCall", "(", ")", "||", "MF", ".", "exposesReturnsTwice", "(", ")", ")", "{", "assert", "(", "HasFP", "&&", "<STR_LIT>", "Expecting a valid frame pointer.", "<STR_LIT>", ")", ";", "if", "(", "!", "HasRedZone", ")", "RBReg", "=", "FPReg", ";", "if", "(", "!", "isLargeFrame", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "AddImmInst", ",", "RBReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadImmShiftedInst", ",", "ScratchReg", ")", ".", "addImm", "(", "FrameSize", ">>", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrImmInst", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", "&", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "AddInst", ")", ".", "addReg", "(", "RBReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addReg", "(", "ScratchReg", ")", ";", "}", "}", "else", "if", "(", "!", "isLargeFrame", "&&", "!", "HasBP", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "if", "(", "HasRedZone", ")", "{", "BuildMI", "(", "MBB", ",", "StackUpdateLoc", ",", "dl", ",", "AddImmInst", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "{", "assert", "(", "FPOffset", "<=", "<NUM_LIT>", "&&", "BPOffset", "<=", "<NUM_LIT>", "&&", "PBPOffset", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Local offsets should be negative", "<STR_LIT>", ")", ";", "SPAdd", "=", "FrameSize", ";", "FPOffset", "+=", "FrameSize", ";", "BPOffset", "+=", "FrameSize", ";", "PBPOffset", "+=", "FrameSize", ";", "}", "}", "else", "{", "if", "(", "!", "HasRedZone", ")", "{", "if", "(", "!", "HasFP", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrInst", ",", "ScratchReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addReg", "(", "FPReg", ")", ";", "RBReg", "=", "FPReg", ";", "}", "BuildMI", "(", "MBB", ",", "StackUpdateLoc", ",", "dl", ",", "LoadInst", ",", "RBReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SPReg", ")", ";", "}", "}", "assert", "(", "RBReg", "!=", "ScratchReg", "&&", "<STR_LIT>", "Should have avoided ScratchReg", "<STR_LIT>", ")", ";", "if", "(", "MustSaveCR", "&&", "SingleScratchReg", "&&", "MustSaveLR", ")", "{", "assert", "(", "HasRedZone", "&&", "<STR_LIT>", "Expecting red zone", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadWordInst", ",", "TempReg", ")", ".", "addImm", "(", "CRSaveOffset", ")", ".", "addReg", "(", "SPReg", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MustSaveCRs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MoveToCRInst", ",", "MustSaveCRs", "[", "i", "]", ")", ".", "addReg", "(", "TempReg", ",", "getKillRegState", "(", "i", "==", "e", "-", "<NUM_LIT>", ")", ")", ";", "}", "bool", "LoadedLR", "=", "false", ";", "if", "(", "MustSaveLR", "&&", "RBReg", "==", "SPReg", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "LROffset", "+", "SPAdd", ")", ")", "{", "BuildMI", "(", "MBB", ",", "StackUpdateLoc", ",", "dl", ",", "LoadInst", ",", "ScratchReg", ")", ".", "addImm", "(", "LROffset", "+", "SPAdd", ")", ".", "addReg", "(", "RBReg", ")", ";", "LoadedLR", "=", "true", ";", "}", "if", "(", "MustSaveCR", "&&", "!", "(", "SingleScratchReg", "&&", "MustSaveLR", ")", ")", "{", "assert", "(", "RBReg", "==", "SPReg", "&&", "<STR_LIT>", "Should be using SP as a base register", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadWordInst", ",", "TempReg", ")", ".", "addImm", "(", "CRSaveOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "}", "if", "(", "HasFP", ")", "{", "if", "(", "HasRedZone", "||", "RBReg", "==", "SPReg", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "FPReg", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "SPReg", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "ScratchReg", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "PPC", "::", "R30", ")", ".", "addImm", "(", "PBPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "if", "(", "HasBP", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "BPReg", ")", ".", "addImm", "(", "BPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "if", "(", "RBReg", "!=", "SPReg", "||", "SPAdd", "!=", "<NUM_LIT>", ")", "{", "assert", "(", "!", "HasRedZone", "&&", "<STR_LIT>" ]

[ "return", "IsPPC64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";" ]

[ "unsigned", "descriptorEnvironmentPointerOffset", "(", ")", "const", "{", "assert", "(", "usesFunctionDescriptors", "(", ")", "&&", "<STR_LIT>", "Should only be called when the target uses descriptors.", "<STR_LIT>", ")", ";" ]

[ "let", "Constraints", "=", "<STR_LIT>", ";" ]

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

[ "MFI", ",", "MRI", ")", ";" ]

[ "if", "(", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "UseTee", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MII", "=", "MBB", ".", "rbegin", "(", ")", ";", "MII", "!=", "MBB", ".", "rend", "(", ")", ";", "++", "MII", ")", "{", "MachineInstr", "*", "Insert", "=", "&", "*", "MII", ";", "if", "(", "Insert", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "continue", ";", "if", "(", "Insert", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", ")", "continue", ";", "CommutingState", "Commuting", ";", "TreeWalkerState", "TreeWalker", "(", "Insert", ")", ";", "while", "(", "!", "TreeWalker", ".", "Done", "(", ")", ")", "{", "MachineOperand", "&", "Op", "=", "TreeWalker", ".", "Pop", "(", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "assert", "(", "Op", ".", "isUse", "(", ")", "&&", "<STR_LIT>", "explicit_uses() should only iterate over uses", "<STR_LIT>", ")", ";", "assert", "(", "!", "Op", ".", "isImplicit", "(", ")", "&&", "<STR_LIT>", "explicit_uses() should only iterate over explicit operands", "<STR_LIT>", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Reg", ")", ")", "continue", ";", "MachineInstr", "*", "Def", "=", "GetVRegDef", "(", "Reg", ",", "Insert", ",", "MRI", ",", "LIS", ")", ";", "if", "(", "!", "Def", ")", "continue", ";", "if", "(", "Def", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "continue", ";", "if", "(", "WebAssembly", "::", "isArgument", "(", "*", "Def", ")", ")", "continue", ";", "bool", "SameBlock", "=", "Def", "->", "getParent", "(", ")", "==", "&", "MBB", ";", "bool", "CanMove", "=", "SameBlock", "&&", "IsSafeToMove", "(", "Def", ",", "Insert", ",", "AA", ",", "MRI", ")", "&&", "!", "TreeWalker", ".", "IsOnStack", "(", "Reg", ")", ";", "if", "(", "CanMove", "&&", "HasOneUse", "(", "Reg", ",", "Def", ",", "MRI", ",", "MDT", ",", "LIS", ")", ")", "{", "Insert", "=", "MoveForSingleUse", "(", "Reg", ",", "Op", ",", "Def", ",", "MBB", ",", "Insert", ",", "LIS", "," ]

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

[ "bits", "<", "<NUM_LIT>", ">", "mask", ";", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "mask", ",", "<NUM_LIT>", "}", ";", "let", "Dest", "=", "dst", ";", "let", "Switches", "=", "sw", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "MaskInReg", ";", "let", "PredAddress", "=", "pred", "{" ]

[ "if", "(", "update", ")", "strcat", "(", "pattern", ",", "<STR_LIT>", "!, {", "<STR_LIT>", ")", ";" ]

[ "if", "(", "regno", "==", "regno_base", ")", "gcc_assert", "(", "!", "update", ")", ";", "}", "conditional", "=", "reverse", "?", "<STR_LIT>", "%?%D0", "<STR_LIT>", ":", "<STR_LIT>", "%?%d0", "<STR_LIT>", ";", "if", "(", "(", "regno_base", "==", "SP_REGNUM", ")", "&&", "update", ")", "{", "sprintf", "(", "pattern", ",", "<STR_LIT>", "pop%s\\t{", "<STR_LIT>", ",", "conditional", ")", ";", "}", "else", "{", "if", "(", "regno_base", "==", "SP_REGNUM", ")", "sprintf", "(", "pattern", ",", "<STR_LIT>", "ldmfd%s", "<STR_LIT>", ",", "conditional", ")", ";", "if", "(", "update", ")", "sprintf", "(", "pattern", ",", "<STR_LIT>", "ldmia%s\\t", "<STR_LIT>", ",", "conditional", ")", ";", "else", "sprintf", "(", "pattern", ",", "<STR_LIT>", "ldm%s\\t", "<STR_LIT>", ",", "conditional", ")", ";", "strcat", "(", "pattern", ",", "reg_names", "[", "regno_base", "]", ")", ";" ]

[ "}" ]

[ "case", "Mips", "::", "CIncOffset", ":", "Base", "=", "&", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Increment", "=", "&", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}" ]

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

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

[ "]", ")" ]

[ "(", "define_int_attr", "mcr", "[", "(", "VUNSPEC_MCR", "<STR_LIT>", ")", "(", "VUNSPEC_MCR2", "<STR_LIT>", ")", "]", ")", "(", "define_int_attr", "MCR", "[", "(", "VUNSPEC_MCR", "<STR_LIT>", ")", "(", "VUNSPEC_MCR2", "<STR_LIT>", ")" ]

[ "}" ]

[ "const", "MCExpr", "*", "EVal", ";", "Op", "=", "nullptr", ";", "switch", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AsmToken", "::", "Percent", ":", "unsigned", "RegNo", ";", "if", "(", "tryParseRegister", "(", "RegNo", ",", "S", ",", "E", ")", "==", "MatchOperand_Success", ")", "Op", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "RegNo", ",", "S", ",", "E", ")", ";", "break", ";", "case", "AsmToken", "::", "Minus", ":", "case", "AsmToken", "::", "Integer", ":", "case", "AsmToken", "::", "Dot", ":", "if", "(", "!", "getParser", "(", ")", ".", "parseExpression", "(", "EVal", ",", "E", ")", ")", "Op", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "EVal", ",", "S", ",", "E", ")", ";", "break", ";", "case", "AsmToken", "::", "Identifier", ":", "{", "StringRef", "Identifier", ";", "if", "(", "!", "getParser", "(", ")", ".", "parseIdentifier", "(", "Identifier", ")", ")", "{", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "MCSymbol", "*", "Sym", "=", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Identifier", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "getContext", "(", ")", ")", ";", "Op", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Res", ",", "S", ",", "E", ")", ";", "}", "break", ";", "}" ]

[ "case", "Saphira", ":" ]

[ "case", "AppleA13", ":", "case", "AppleA14", ":", "CacheLineSize", "=", "<NUM_LIT>", ";", "PrefetchDistance", "=", "<NUM_LIT>", ";", "MinPrefetchStride", "=", "<NUM_LIT>", ";", "MaxPrefetchIterationsAhead", "=", "<NUM_LIT>", ";", "break", ";", "case", "ExynosM3", ":", "MaxInterleaveFactor", "=", "<NUM_LIT>", ";", "MaxJumpTableSize", "=", "<NUM_LIT>", ";", "PrefFunctionLogAlignment", "=", "<NUM_LIT>", ";", "PrefLoopLogAlignment", "=", "<NUM_LIT>", ";", "break", ";", "case", "Falkor", ":", "MaxInterleaveFactor", "=", "<NUM_LIT>", ";", "MinVectorRegisterBitWidth", "=", "<NUM_LIT>", ";", "CacheLineSize", "=", "<NUM_LIT>", ";", "PrefetchDistance", "=", "<NUM_LIT>", ";", "MinPrefetchStride", "=", "<NUM_LIT>", ";", "MaxPrefetchIterationsAhead", "=", "<NUM_LIT>", ";", "break", ";", "case", "Kryo", ":", "MaxInterleaveFactor", "=", "<NUM_LIT>", ";", "VectorInsertExtractBaseCost", "=", "<NUM_LIT>", ";", "CacheLineSize", "=", "<NUM_LIT>", ";", "PrefetchDistance", "=", "<NUM_LIT>", ";", "MinPrefetchStride", "=", "<NUM_LIT>", ";", "MaxPrefetchIterationsAhead", "=", "<NUM_LIT>", ";", "MinVectorRegisterBitWidth", "=", "<NUM_LIT>", ";", "break", ";", "case", "NeoverseE1", ":", "PrefFunctionLogAlignment", "=", "<NUM_LIT>", ";", "break", ";", "case", "NeoverseN1", ":", "PrefFunctionLogAlignment", "=", "<NUM_LIT>", ";", "PrefLoopLogAlignment", "=", "<NUM_LIT>", ";", "MaxBytesForLoopAlignment", "=", "<NUM_LIT>", ";", "break", ";", "case", "NeoverseN2", ":", "PrefFunctionLogAlignment", "=", "<NUM_LIT>", ";", "PrefLoopLogAlignment", "=", "<NUM_LIT>", ";", "MaxBytesForLoopAlignment", "=", "<NUM_LIT>", ";", "VScaleForTuning", "=", "<NUM_LIT>", ";", "break", ";", "case", "NeoverseV1", ":", "PrefFunctionLogAlignment", "=", "<NUM_LIT>", ";", "PrefLoopLogAlignment", "=", "<NUM_LIT>", ";", "MaxBytesForLoopAlignment", "=", "<NUM_LIT>", ";", "VScaleForTuning", "=", "<NUM_LIT>", ";", "break", ";", "case", "Neoverse512TVB", ":", "PrefFunctionLogAlignment", "=", "<NUM_LIT>", ";", "VScaleForTuning", "=", "<NUM_LIT>", ";", "MaxInterleaveFactor", "=", "<NUM_LIT>", ";", "break", ";" ]

[ "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{" ]

[ "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemmove", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", "," ]

[ ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "m_paddusw", "(", "_", "_", "m64", "_", "_", "m1", ",", "_", "_", "m64", "_", "_", "m2", ")", "{", "return", "_", "mm_adds_pu16", "(", "_", "_", "m1", ",", "_", "_", "m2" ]

[ "<STR_LIT>", ";" ]

[ "static", "<STR_LIT>", "::", "<STR_LIT>", "getLoongArchWOpcode", "(", "unsigned", "Opcode", ")", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected opcode", "<STR_LIT>", ")", ";", "case", "ISD", "::", "UDIV", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "UREM", ":", "return", "<STR_LIT>", "::" ]

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

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

[ "}" ]

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

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

[ "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "bits", "<", "<NUM_LIT>", ">", "fid", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "SrcExtra", "=", "{", "fid", ",", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "<NUM_LIT>", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "OutOfSlotData", "=", "<NUM_LIT>", ";", "let", "Constraints" ]

[ "RegNum", ";" ]

[ "assert", "(", "(", "Kind", "==", "k_Register", ")", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "return", "Reg", "." ]

[ "dbgs", "(", ")", "<<", "<STR_LIT>", "null", "<STR_LIT>", ";" ]

[ "if", "(", "BaseReg", ".", "getNode", "(", ")", ")", "BaseReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "<STR_LIT>", "null", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", ", BaseFI: ", "<STR_LIT>", "<<", "BaseFrameIndex", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", ", IndexReg: ", "<STR_LIT>", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", ")", "{", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "{" ]

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "Absolute", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "Index", ";" ]

[ "const", "MCExpr", "*", "getMemIndex", "(", ")", "const", "{", "assert", "(", "(", "Kind", "==", "k_MemoryRegImmImm", "||", "Kind", "==", "k_MemoryZeroImmImm", ")", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "return", "Mem", "." ]

[ ";" ]

[ "APFloatOfN", ".", "convert", "(", "APFloat", ":", ":", "IEEEdouble", "(", ")", ",", "APFloat", ":", ":", "rmNearestTiesToEven", ",", "&", "Unused", ")", ";", "uint32_t", "Hi", "=", "(", "uint32_t", ")", "(", "(", "APFloatOfN", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", ">", ">", "<NUM_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "Hi", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "getFPAs64BitIntLo", ":", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "APFloatOfN", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "bool", "Unused", ";", "APFloatOfN", ".", "convert", "(", "APFloat", ":", ":", "IEEEdouble", "(", ")", ",", "APFloat", ":", ":", "rmNearestTiesToEven", ",", "&", "Unused", ")", ";", "uint32_t", "Lo", "=", "(", "uint32_t", ")", "(", "APFloatOfN", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "Lo", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "imm34", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isInt", "<", "<NUM_LIT>", ">", "(", "N", "-", ">", "getSExtValue", "(", ")", ")", ";", "}", "]", ">", ";", "def", "getImmAs64BitInt", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "getI64Imm", "(", "N", "-", ">", "getSExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "SHL32", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "getI32Imm", "(", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "SRL32", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "N", "-", ">", "getZExtValue", "(", ")", "?", "getI32Imm", "(", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ")", ":", "getI32Imm", "(", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "LO16", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "getI32Imm", "(", "(", "unsigned", "short", ")", "N", "-", ">", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "HI16", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "getI32Imm", "(", "(", "unsigned", ")", "N", "-", ">", "getZExtValue", "(", ")", ">", ">", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">" ]