1//===-- CSKY.td - Describe the CSKY Target Machine ---------*- tablegen -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9include "llvm/Target/Target.td" 10 11//===----------------------------------------------------------------------===// 12// CSKY subtarget features and instruction predicates. 13//===----------------------------------------------------------------------===// 14def ModeHardFloat : 15 SubtargetFeature<"hard-float", "UseHardFloat", 16 "true", "Use hard floating point features">; 17def ModeHardFloatABI : 18 SubtargetFeature<"hard-float-abi", "UseHardFloatABI", 19 "true", "Use hard floating point ABI to pass args">; 20 21def FeatureFPUV2_SF 22 : SubtargetFeature<"fpuv2_sf", "HasFPUv2SingleFloat", "true", 23 "Enable FPUv2 single float instructions">; 24def HasFPUv2_SF : Predicate<"Subtarget->hasFPUv2SingleFloat()">, 25 AssemblerPredicate<(all_of FeatureFPUV2_SF), 26 "Enable FPUv2 single float instructions">; 27 28def FeatureFPUV2_DF 29 : SubtargetFeature<"fpuv2_df", "HasFPUv2DoubleFloat", "true", 30 "Enable FPUv2 double float instructions">; 31def HasFPUv2_DF : Predicate<"Subtarget->hasFPUv2DoubleFloat()">, 32 AssemblerPredicate<(all_of FeatureFPUV2_DF), 33 "Enable FPUv2 double float instructions">; 34 35def FeatureFdivdu : SubtargetFeature<"fdivdu", "HasFdivdu", "true", 36 "Enable float divide instructions">; 37def HasFdivdu : Predicate<"Subtarget->hasFdivdu()">, 38 AssemblerPredicate<(all_of FeatureFdivdu), 39 "Enable float divide instructions">; 40 41def FeatureFPUV3_HI 42 : SubtargetFeature<"fpuv3_hi", "HasFPUv3HalfWord", "true", 43 "Enable FPUv3 harf word converting instructions">; 44def HasFPUv3_HI : Predicate<"Subtarget->hasFPUv3HalfWord()">, 45 AssemblerPredicate<(all_of FeatureFPUV3_HI), 46 "Enable FPUv3 harf word converting instructions">; 47 48def FeatureFPUV3_HF 49 : SubtargetFeature<"fpuv3_hf", "HasFPUv3HalfFloat", "true", 50 "Enable FPUv3 harf precision operate instructions">; 51def HasFPUv3_HF : Predicate<"Subtarget->hasFPUv3HalfFloat()">, 52 AssemblerPredicate<(all_of FeatureFPUV3_HF), 53 "Enable FPUv3 harf precision operate instructions">; 54 55def FeatureFPUV3_SF 56 : SubtargetFeature<"fpuv3_sf", "HasFPUv3SingleFloat", "true", 57 "Enable FPUv3 single float instructions">; 58def HasFPUv3_SF : Predicate<"Subtarget->hasFPUv3SingleFloat()">, 59 AssemblerPredicate<(all_of FeatureFPUV3_SF), 60 "Enable FPUv3 single float instructions">; 61 62def FeatureFPUV3_DF 63 : SubtargetFeature<"fpuv3_df", "HasFPUv3DoubleFloat", "true", 64 "Enable FPUv3 double float instructions">; 65def HasFPUv3_DF : Predicate<"Subtarget->hasFPUv3DoubleFloat()">, 66 AssemblerPredicate<(all_of FeatureFPUV3_DF), 67 "Enable FPUv3 double float instructions">; 68 69def HasFLOATE1 70 : SubtargetFeature<"floate1", "HasFLOATE1", "true", "Support CSKY floate1 instructions">; 71def iHasFLOATE1 : Predicate<"Subtarget->hasFLOATE1()">, 72 AssemblerPredicate<(all_of HasFLOATE1), 73 "Support CSKY floate1 instructions">; 74 75def HasFLOAT1E2 76 : SubtargetFeature<"float1e2", "HasFLOAT1E2", "true", "Support CSKY float1e2 instructions">; 77def iHasFLOAT1E2 : Predicate<"Subtarget->hasFLOAT1E2()">, 78 AssemblerPredicate<(all_of HasFLOAT1E2), 79 "Support CSKY float1e2 instructions">; 80 81def HasFLOAT1E3 82 : SubtargetFeature<"float1e3", "HasFLOAT1E3", "true", "Support CSKY float1e3 instructions">; 83def iHasFLOAT1E3 : Predicate<"Subtarget->hasFLOAT1E3()">, 84 AssemblerPredicate<(all_of HasFLOAT1E3), 85 "Support CSKY float1e3 instructions">; 86 87def HasFLOAT3E4 88 : SubtargetFeature<"float3e4", "HasFLOAT3E4", "true", "Support CSKY float3e4 instructions">; 89def iHasFLOAT3E4 : Predicate<"Subtarget->hasFLOAT3E4()">, 90 AssemblerPredicate<(all_of HasFLOAT3E4), 91 "Support CSKY float3e4 instructions">; 92 93def HasFLOAT7E60 94 : SubtargetFeature<"float7e60", "HasFLOAT7E60", "true", "Support CSKY float7e60 instructions">; 95def iHasFLOAT7E60 : Predicate<"Subtarget->hasFLOAT7E60()">, 96 AssemblerPredicate<(all_of HasFLOAT7E60), 97 "Support CSKY float7e60 instructions">; 98 99def FeatureHWDiv : SubtargetFeature<"hwdiv", "HasHardwareDivide", "true", 100 "Enable divide instrutions">; 101def HasHWDiv : Predicate<"Subtarget->hasHardwareDivide()">, 102 AssemblerPredicate<(all_of FeatureHWDiv), 103 "Enable divide instrutions">; 104 105def FeatureSTM : SubtargetFeature<"multiple_stld", "HasSTM", "true", 106 "Enable multiple load/store instrutions">; 107def HasSTM : Predicate<"Subtarget->hasSTM()">, 108 AssemblerPredicate<(all_of FeatureSTM), 109 "Enable multiple load/store instrutions">; 110 111def FeaturePushPop : SubtargetFeature<"pushpop", "HasPushPop", "true", 112 "Enable push/pop instrutions">; 113def HasPushPop : Predicate<"Subtarget->hasPushPop()">, 114 AssemblerPredicate<(all_of FeaturePushPop), 115 "Enable push/pop instrutions">; 116 117def FeatureDSP 118 : SubtargetFeature<"edsp", "HasDSP", "true", "Enable DSP instrutions">; 119def HasDSP : Predicate<"Subtarget->hasDSP()">, 120 AssemblerPredicate<(all_of FeatureDSP), 121 "Enable DSP instrutions">; 122 123def HasDSP1E2 124 : SubtargetFeature<"dsp1e2", "HasDSP1E2", "true", "Support CSKY dsp1e2 instructions">; 125def iHasDSP1E2 : Predicate<"Subtarget->hasDSP1E2()">, 126 AssemblerPredicate<(all_of HasDSP1E2), 127 "Support CSKY dsp1e2 instructions">; 128 129def HasDSPE60 130 : SubtargetFeature<"dspe60", "HasDSPE60", "true", "Support CSKY dspe60 instructions">; 131def iHasDSPE60 : Predicate<"Subtarget->hasDSPE60()">, 132 AssemblerPredicate<(all_of HasDSPE60), 133 "Support CSKY dspe60 instructions">; 134 135def FeatureDSPV2 : SubtargetFeature<"dspv2", "HasDSPV2", "true", 136 "Enable DSP V2.0 instrutions">; 137def HasDSPV2 : Predicate<"Subtarget->hasDSPV2()">, 138 AssemblerPredicate<(all_of FeatureDSPV2), 139 "Enable DSP V2.0 instrutions">; 140 141def FeatureDSP_Silan : SubtargetFeature<"dsp_silan", "HasDSP_Silan", "true", 142 "Enable DSP Silan instrutions">; 143def HasDSP_Silan : Predicate<"Subtarget->hasDSP_Silan()">, 144 AssemblerPredicate<(all_of FeatureDSP_Silan), 145 "Enable DSP Silan instrutions">; 146 147// Atomic Support 148def FeatureBTST16 : SubtargetFeature<"btst16", "HasBTST16", "true", 149 "Use the 16-bit btsti instruction">; 150def HasBTST16 : Predicate<"Subtarget->hasBTST16()">, 151 AssemblerPredicate<(all_of FeatureBTST16), 152 "Use the 16-bit btsti instruction">; 153 154// Atomic Support 155def FeatureExtendLrw : SubtargetFeature<"elrw", "HasExtendLrw", "true", 156 "Use the extend LRW instruction">; 157def HasExtendLrw : Predicate<"Subtarget->hasExtendLrw()">, 158 AssemblerPredicate<(all_of FeatureExtendLrw), 159 "Use the extend LRW instruction">; 160 161def FeatureTrust : SubtargetFeature<"trust", "HasTrust", "true", 162 "Enable trust instructions">; 163def HasTrust : Predicate<"Subtarget->hasTrust()">, 164 AssemblerPredicate<(all_of FeatureTrust), 165 "Enable trust instructions">; 166 167def FeatureJAVA 168 : SubtargetFeature<"java", "HasJAVA", "true", "Enable java instructions">; 169def HasJAVA : Predicate<"Subtarget->hasJAVA()">, 170 AssemblerPredicate<(all_of FeatureJAVA), 171 "Enable java instructions">; 172 173def FeatureCache 174 : SubtargetFeature<"cache", "HasCache", "true", "Enable cache">; 175def HasCache : Predicate<"Subtarget->hasCache()">, 176 AssemblerPredicate<(all_of FeatureCache), 177 "Enable cache">; 178 179def FeatureNVIC 180 : SubtargetFeature<"nvic", "HasNVIC", "true", "Enable NVIC">; 181def HasNVIC : Predicate<"Subtarget->hasNVIC()">, 182 AssemblerPredicate<(all_of FeatureNVIC), 183 "Enable NVIC">; 184 185def FeatureDoloop : SubtargetFeature<"doloop", "HasDoloop", "true", 186 "Enable doloop instructions">; 187def HasDoloop : Predicate<"Subtarget->hasDoloop()">, 188 AssemblerPredicate<(all_of FeatureDoloop), 189 "Enable doloop instructions">; 190 191// Other features than instructions 192def FeatureHighreg : SubtargetFeature<"high-registers", "HasHighRegisters", 193 "true", "Enable r16-r31 registers">; 194def HasHighRegisters : Predicate<"Subtarget->hasHighRegisters()">, 195 AssemblerPredicate<(all_of FeatureHighreg), 196 "Enable r16-r31 registers">; 197 198def FeatureSmart : SubtargetFeature<"smart", "SmartMode", "true", 199 "Let CPU work in Smart Mode">; 200def SmartMode : Predicate<"Subtarget->smartMode()">, 201 AssemblerPredicate<(all_of FeatureSmart), 202 "Let CPU work in Smart Mode">; 203 204def FeatureVDSPV2 : SubtargetFeature<"vdspv2", "HasVDSPV2", "true", 205 "Enable vdsp-v2 instructions">; 206def HasVDSPV2 : Predicate<"Subtarget->hasVDSPV2()">, 207 AssemblerPredicate<(all_of FeatureVDSPV2), 208 "Enable vdsp-v2 instructions">; 209 210def HasVDSPV2_FLOAT : Predicate<"Subtarget->hasVDSPV2_FLOAT()">; 211def HasVDSPV2_HALF: Predicate<"Subtarget->hasVDSPV2_HALF()">; 212 213def HasVDSP2E3 214 : SubtargetFeature<"vdsp2e3", "HasVDSP2E3", "true", "Support CSKY vdsp2e3 instructions">; 215def iHasVDSP2E3 : Predicate<"Subtarget->hasVDSP2E3()">, 216 AssemblerPredicate<(all_of HasVDSP2E3), 217 "Support CSKY vdsp2e3 instructions">; 218 219def HasVDSP2E60F 220 : SubtargetFeature<"vdsp2e60f", "HasVDSP2E60F", "true", "Support CSKY vdsp2e60f instructions">; 221def iHasVDSP2E60F : Predicate<"Subtarget->hasVDSP2E60F()">, 222 AssemblerPredicate<(all_of HasVDSP2E60F), 223 "Support CSKY vdsp2e60f instructions">; 224 225def FeatureHardTP : SubtargetFeature<"hard-tp", "ReadTPHard", "true", 226 "Enable TLS Pointer register">; 227def ReadTPHard : Predicate<"Subtarget->readTPHard()">, 228 AssemblerPredicate<(all_of FeatureHardTP), 229 "Enable TLS Pointer register">; 230 231def FeatureSoftTP : SubtargetFeature<"soft-tp", "ReadTPHard", "false", 232 "Disable TLS Pointer register">; 233 234def FeatureIstack : SubtargetFeature<"istack", "EnableInterruptAttribute", 235 "true", "Enable interrput attribute">; 236def EnableInterruptAttribute 237 : Predicate<"Subtarget->enableInterruptAttribute()">, 238 AssemblerPredicate<(all_of FeatureIstack), 239 "Enable interrput attribute">; 240 241def FeatureConstPool : SubtargetFeature<"constpool", "DumpConstPool", "true", 242 "Dump the constant pool by compiler">; 243def DumpConstPool : Predicate<"Subtarget->dumpConstPool()">, 244 AssemblerPredicate<(all_of FeatureConstPool), 245 "Dump the constant pool by compiler">; 246 247def FeatureStackSize : SubtargetFeature<"stack-size", "EnableStackSize", "true", 248 "Output stack size information">; 249def EnableStackSize : Predicate<"Subtarget->enableStackSize()">, 250 AssemblerPredicate<(all_of FeatureStackSize), 251 "Output stack size information">; 252 253def FeatureCCRT 254 : SubtargetFeature<"ccrt", "UseCCRT", "true", "Use CSKY compiler runtime">; 255def UseCCRT : Predicate<"Subtarget->useCCRT()">, 256 AssemblerPredicate<(all_of FeatureCCRT), 257 "Use CSKY compiler runtime">; 258 259def FeatureVDSPV1_128 : SubtargetFeature<"vdspv1", "HasVDSPV1_128", "true", 260 "Enable 128bit vdsp-v1 instructions">; 261def HasVDSPV1_128 : Predicate<"Subtarget->hasVDSPV1_128()">, 262 AssemblerPredicate<(all_of FeatureVDSPV1_128), 263 "Enable 128bit vdsp-v1 instructions">; 264 265def HasE1 266 : SubtargetFeature<"e1", "HasE1", "true", "Support CSKY e1 instructions", 267 [FeatureExtendLrw]>; 268def iHasE1 : Predicate<"Subtarget->hasE1()">, 269 AssemblerPredicate<(all_of HasE1), 270 "Support CSKY e1 instructions">; 271 272def HasE2 273 : SubtargetFeature<"e2", "HasE2", "true", "Support CSKY e2 instructions", 274 [HasE1]>; 275def iHasE2 : Predicate<"Subtarget->hasE2()">, 276 AssemblerPredicate<(all_of HasE2), 277 "Support CSKY e2 instructions">; 278 279def Has2E3 : SubtargetFeature<"2e3", "Has2E3", "true", 280 "Support CSKY 2e3 instructions", [HasE2]>; 281def iHas2E3 : Predicate<"Subtarget->has2E3()">, 282 AssemblerPredicate<(all_of Has2E3), 283 "Support CSKY 2e3 instructions">; 284 285def HasMP : SubtargetFeature<"mp", "HasMP", "true", 286 "Support CSKY mp instructions", [Has2E3]>; 287def iHasMP : Predicate<"Subtarget->hasMP()">, 288 AssemblerPredicate<(all_of HasMP), 289 "Support CSKY mp instructions">; 290 291def Has3E3r1 : SubtargetFeature<"3e3r1", "Has3E3r1", "true", 292 "Support CSKY 3e3r1 instructions">; 293def iHas3E3r1 : Predicate<"Subtarget->has3E3r1()">, 294 AssemblerPredicate<(all_of Has3E3r1), 295 "Support CSKY 3e3r1 instructions">; 296 297def Has3r1E3r2 : SubtargetFeature<"3e3r2", "Has3r1E3r2", "true", 298 "Support CSKY 3e3r2 instructions", 299 [Has3E3r1, FeatureDoloop]>; 300def iHas3r1E3r2 : Predicate<"Subtarget->has3r1E3r2()">, 301 AssemblerPredicate<(all_of Has3r1E3r2), 302 "Support CSKY 3e3r2 instructions">; 303 304def Has3r2E3r3 305 : SubtargetFeature<"3e3r3", "Has3r2E3r3", "true", 306 "Support CSKY 3e3r3 instructions", [FeatureDoloop]>; 307def iHas3r2E3r3 : Predicate<"Subtarget->has3r2E3r3()">, 308 AssemblerPredicate<(all_of Has3r2E3r3), 309 "Support CSKY 3e3r3 instructions">; 310 311def Has3E7 : SubtargetFeature<"3e7", "Has3E7", "true", 312 "Support CSKY 3e7 instructions", [Has2E3]>; 313def iHas3E7 : Predicate<"Subtarget->has3E7()">, 314 AssemblerPredicate<(all_of Has3E7), 315 "Support CSKY 3e7 instructions">; 316 317def HasMP1E2 : SubtargetFeature<"mp1e2", "HasMP1E2", "true", 318 "Support CSKY mp1e2 instructions", [Has3E7]>; 319def iHasMP1E2 : Predicate<"Subtarget->hasMP1E2()">, 320 AssemblerPredicate<(all_of HasMP1E2), 321 "Support CSKY mp1e2 instructions">; 322 323def Has7E10 : SubtargetFeature<"7e10", "Has7E10", "true", 324 "Support CSKY 7e10 instructions", [Has3E7]>; 325def iHas7E10 : Predicate<"Subtarget->has7E10()">, 326 AssemblerPredicate<(all_of Has7E10), 327 "Support CSKY 7e10 instructions">; 328 329def Has10E60 : SubtargetFeature<"10e60", "Has10E60", "true", 330 "Support CSKY 10e60 instructions", [Has7E10]>; 331def iHas10E60 : Predicate<"Subtarget->has10E60()">, 332 AssemblerPredicate<(all_of Has10E60), 333 "Support CSKY 10e60 instructions">; 334 335//===----------------------------------------------------------------------===// 336// CSKY Processor subtarget features. 337//===----------------------------------------------------------------------===// 338 339def ProcCK801 : SubtargetFeature<"ck801", "CSKYProcFamily", "CK801", 340 "CSKY ck801 processors", []>; 341def isCK801 : Predicate<"Subtarget->isCK801()">, 342 AssemblerPredicate<(all_of ProcCK801)>; 343def ProcCK802 : SubtargetFeature<"ck802", "CSKYProcFamily", "CK802", 344 "CSKY ck802 processors", []>; 345def ProcCK803 : SubtargetFeature<"ck803", "CSKYProcFamily", "CK803", 346 "CSKY ck803 processors", []>; 347def ProcCK803S : SubtargetFeature<"ck803s", "CSKYProcFamily", "CK803S", 348 "CSKY ck803s processors", []>; 349def ProcCK804 : SubtargetFeature<"ck804", "CSKYProcFamily", "CK804", 350 "CSKY ck804 processors", []>; 351def ProcCK805 : SubtargetFeature<"ck805", "CSKYProcFamily", "CK805", 352 "CSKY ck805 processors", []>; 353def ProcCK807 : SubtargetFeature<"ck807", "CSKYProcFamily", "CK807", 354 "CSKY ck807 processors", []>; 355def ProcCK810 : SubtargetFeature<"ck810", "CSKYProcFamily", "CK810", 356 "CSKY ck810 processors", []>; 357def ProcCK810V : SubtargetFeature<"ck810v", "CSKYProcFamily", "CK810V", 358 "CSKY ck810v processors", []>; 359def ProcCK860 : SubtargetFeature<"ck860", "CSKYProcFamily", "CK860", 360 "CSKY ck860 processors", []>; 361def ProcCK860V : SubtargetFeature<"ck860v", "CSKYProcFamily", "CK860V", 362 "CSKY ck860v processors", []>; 363 364//===----------------------------------------------------------------------===// 365// Registers, calling conventions, instruction descriptions. 366//===----------------------------------------------------------------------===// 367 368include "CSKYRegisterInfo.td" 369include "CSKYCallingConv.td" 370include "CSKYInstrInfo.td" 371 372//===----------------------------------------------------------------------===// 373// CSKY processors supported. 374//===----------------------------------------------------------------------===// 375 376// btsti16 is one of most basic instructions should be enable 377// even in generic processor to avoid failure codegen. 378def : ProcessorModel<"generic", NoSchedModel, [FeatureBTST16]>; 379 380// CK801 series 381class CK801<string n, SchedMachineModel m, list<SubtargetFeature> f, 382 list<SubtargetFeature> tunef = []> 383 : ProcessorModel<n, m, !listconcat(f, [HasE1, FeatureTrust, FeatureBTST16, ProcCK801]), !listconcat(tunef, [])>; 384 385def : CK801<"ck801", NoSchedModel, []>; 386def : CK801<"ck801t", NoSchedModel, []>; 387def : CK801<"e801", NoSchedModel, []>; 388 389// CK802 series 390class CK802<string n, SchedMachineModel m, list<SubtargetFeature> f, 391 list<SubtargetFeature> tunef = []> 392 : ProcessorModel<n, m, !listconcat(f, [HasE2, FeatureTrust, FeatureBTST16, FeatureNVIC, ProcCK802]), !listconcat(tunef, [])>; 393 394def : CK802<"ck802", NoSchedModel, []>; 395def : CK802<"ck802t", NoSchedModel, []>; 396def : CK802<"ck802j", NoSchedModel, [FeatureJAVA]>; 397def : CK802<"e802", NoSchedModel, []>; 398def : CK802<"e802t", NoSchedModel, []>; 399def : CK802<"s802", NoSchedModel, []>; 400def : CK802<"s802t", NoSchedModel, []>; 401 402// CK803 series 403class CK803<string n, SchedMachineModel m, list<SubtargetFeature> f, 404 list<SubtargetFeature> tunef = []> 405 : ProcessorModel<n, m, !listconcat(f, [Has2E3, HasMP, FeatureTrust, FeatureBTST16, FeatureNVIC, FeatureHWDiv, ProcCK803]), !listconcat(tunef, [])>; 406 407def : CK803<"ck803", NoSchedModel, []>; 408def : CK803<"ck803h", NoSchedModel, []>; 409def : CK803<"ck803t", NoSchedModel, []>; 410def : CK803<"ck803ht", NoSchedModel, []>; 411def : CK803<"ck803f", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 412def : CK803<"ck803fh", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 413def : CK803<"ck803e", NoSchedModel, [FeatureDSP, HasDSP1E2, HasDSPE60]>; 414def : CK803<"ck803eh", NoSchedModel, [FeatureDSP, HasDSP1E2, HasDSPE60]>; 415def : CK803<"ck803et", NoSchedModel, [FeatureDSP, HasDSP1E2, HasDSPE60]>; 416def : CK803<"ck803eht", NoSchedModel, [FeatureDSP, HasDSP1E2, HasDSPE60]>; 417def : CK803<"ck803ef", NoSchedModel, 418 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 419def : CK803<"ck803efh", NoSchedModel, 420 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 421def : CK803<"ck803ft", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 422def : CK803<"ck803eft", NoSchedModel, 423 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 424def : CK803<"ck803efht", NoSchedModel, 425 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 426def : CK803<"ck803r1", NoSchedModel, [Has3E3r1, Has3r2E3r3, FeatureDSPV2]>; 427def : CK803<"ck803hr1", NoSchedModel, [Has3E3r1, Has3r2E3r3, FeatureDSPV2]>; 428def : CK803<"ck803tr1", NoSchedModel, [Has3E3r1, Has3r2E3r3, FeatureDSPV2]>; 429def : CK803<"ck803htr1", NoSchedModel, [Has3E3r1, Has3r2E3r3, FeatureDSPV2]>; 430def : CK803<"ck803fr1", NoSchedModel, 431 [Has3E3r1, Has3r2E3r3, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureDSPV2]>; 432def : CK803<"ck803fhr1", NoSchedModel, 433 [Has3E3r1, Has3r2E3r3, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureDSPV2]>; 434def : CK803<"ck803er1", NoSchedModel, 435 [Has3E3r1, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 436def : CK803<"ck803etr1", NoSchedModel, 437 [Has3E3r1, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 438def : CK803<"ck803ehr1", NoSchedModel, 439 [Has3E3r1, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 440def : CK803<"ck803ehtr1", NoSchedModel, 441 [Has3E3r1, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 442def : CK803<"ck803efr1", NoSchedModel, 443 [Has3E3r1, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 444def : CK803<"ck803efhr1", NoSchedModel, 445 [Has3E3r1, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 446def : CK803<"ck803ftr1", NoSchedModel, [Has3E3r1, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureDSPV2]>; 447def : CK803<"ck803eftr1", NoSchedModel, 448 [Has3E3r1, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 449def : CK803<"ck803efhtr1", NoSchedModel, 450 [Has3E3r1, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 451def : CK803<"ck803r2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 452def : CK803<"ck803hr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 453def : CK803<"ck803tr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 454def : CK803<"ck803htr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 455def : CK803<"ck803fr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 456def : CK803<"ck803fhr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 457def : CK803<"ck803er2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 458def : CK803<"ck803etr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 459def : CK803<"ck803ehr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 460def : CK803<"ck803ehtr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 461def : CK803<"ck803efr2", NoSchedModel, 462 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 463def : CK803<"ck803efhr2", NoSchedModel, 464 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 465def : CK803<"ck803ftr2", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 466def : CK803<"ck803eftr2", NoSchedModel, 467 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 468def : CK803<"ck803efhtr2", NoSchedModel, 469 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 470def : CK803<"ck803r3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 471def : CK803<"ck803hr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 472def : CK803<"ck803tr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 473def : CK803<"ck803htr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2]>; 474def : CK803<"ck803fr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 475def : CK803<"ck803fhr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 476def : CK803<"ck803er3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 477def : CK803<"ck803etr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 478def : CK803<"ck803ehr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 479def : CK803<"ck803ehtr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureHighreg]>; 480def : CK803<"ck803efr3", NoSchedModel, 481 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 482def : CK803<"ck803efhr3", NoSchedModel, 483 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 484def : CK803<"ck803ftr3", NoSchedModel, [Has3r1E3r2, Has3r2E3r3, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 485def : CK803<"ck803eftr3", NoSchedModel, 486 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 487def : CK803<"ck803efhtr3", NoSchedModel, 488 [Has3r1E3r2, Has3r2E3r3, FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 489def : CK803<"s803", NoSchedModel, [Has3r1E3r2, Has3r2E3r3]>; 490def : CK803<"s803t", NoSchedModel, [Has3r1E3r2, Has3r2E3r3]>; 491def : CK803<"e803", NoSchedModel, [Has3r1E3r2, Has3r2E3r3]>; 492def : CK803<"e803t", NoSchedModel, [Has3r1E3r2, Has3r2E3r3]>; 493 494// CK803S series 495class CK803S<string n, SchedMachineModel m, list<SubtargetFeature> f, 496list<SubtargetFeature> tunef = []> : CK803<n, m, !listconcat(f, [Has3E3r1, ProcCK803S]), tunef>; 497 498def : CK803S<"ck803s", NoSchedModel, []>; 499def : CK803S<"ck803sn", NoSchedModel, [FeatureDSP_Silan]>; 500def : CK803S<"ck803st", NoSchedModel, []>; 501def : CK803S<"ck803snt", NoSchedModel, [FeatureDSP_Silan]>; 502def : CK803S<"ck803sf", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 503def : CK803S<"ck803sfn", NoSchedModel, [FeatureFPUV2_SF, FeatureDSP_Silan, HasFLOATE1, HasFLOAT1E3]>; 504def : CK803S<"ck803se", NoSchedModel, [FeatureDSP, HasDSP1E2, HasDSPE60]>; 505def : CK803S<"ck803sen", NoSchedModel, [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureDSP_Silan]>; 506def : CK803S<"ck803sef", NoSchedModel, 507 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 508def : CK803S<"ck803sefn", NoSchedModel, 509 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, FeatureDSP_Silan, 510 HasFLOATE1, HasFLOAT1E3]>; 511def : CK803S<"ck803seft", NoSchedModel, 512 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 513def : CK803S<"ck803sefnt", NoSchedModel, 514 [FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, FeatureDSP_Silan, 515 HasFLOATE1, HasFLOAT1E3]>; 516 517// CK804 series 518class CK804<string n, SchedMachineModel m, list<SubtargetFeature> f, 519 list<SubtargetFeature> tunef = []> 520 : CK803<n, m, !listconcat(f, [Has3r1E3r2, Has3r2E3r3, ProcCK804]), !listconcat(tunef, [])>; 521 522def : CK804<"ck804", NoSchedModel, []>; 523def : CK804<"ck804h", NoSchedModel, []>; 524def : CK804<"ck804t", NoSchedModel, []>; 525def : CK804<"ck804ht", NoSchedModel, []>; 526def : CK804<"ck804f", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 527def : CK804<"ck804fh", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 528def : CK804<"ck804e", NoSchedModel, [FeatureDSPV2, FeatureHighreg]>; 529def : CK804<"ck804et", NoSchedModel, [FeatureDSPV2, FeatureHighreg]>; 530def : CK804<"ck804eh", NoSchedModel, [FeatureDSPV2, FeatureHighreg]>; 531def : CK804<"ck804eht", NoSchedModel, [FeatureDSPV2, FeatureHighreg]>; 532def : CK804<"ck804ef", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 533def : CK804<"ck804efh", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 534def : CK804<"ck804ft", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 535def : CK804<"ck804eft", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 536def : CK804<"ck804efht", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 537def : CK804<"e804d", NoSchedModel, [FeatureDSPV2, FeatureHighreg]>; 538def : CK804<"e804dt", NoSchedModel, [FeatureDSPV2, FeatureHighreg]>; 539def : CK804<"e804f", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 540def : CK804<"e804ft", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 541def : CK804<"e804df", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 542def : CK804<"e804dft", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3, FeatureHighreg]>; 543 544// CK805 series 545class CK805<string n, SchedMachineModel m, list<SubtargetFeature> f, 546 list<SubtargetFeature> tunef = []> 547 : CK803<n, m, !listconcat(f, [FeatureHighreg, FeatureVDSPV2, HasVDSP2E3, Has3r1E3r2, Has3r2E3r3, ProcCK805]), 548 !listconcat(tunef, [])>; 549 550def : CK805<"ck805", NoSchedModel, []>; 551def : CK805<"i805", NoSchedModel, []>; 552def : CK805<"ck805t", NoSchedModel, []>; 553def : CK805<"i805f", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 554def : CK805<"ck805f", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 555def : CK805<"ck805e", NoSchedModel, [FeatureDSPV2]>; 556def : CK805<"ck805ef", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 557def : CK805<"ck805et", NoSchedModel, [FeatureDSPV2]>; 558def : CK805<"ck805ft", NoSchedModel, [FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 559def : CK805<"ck805eft", NoSchedModel, [FeatureDSPV2, FeatureFPUV2_SF, HasFLOATE1, HasFLOAT1E3]>; 560 561// CK807 series 562class CK807<string n, SchedMachineModel m, list<SubtargetFeature> f, 563 list<SubtargetFeature> tunef = []> 564 : ProcessorModel<n, m, !listconcat(f, 565 [ Has3E7, HasMP, HasMP1E2, FeatureTrust, FeatureHWDiv, FeatureDSP, HasDSP1E2, HasDSPE60, 566 FeatureHighreg, FeatureHardTP, FeatureNVIC, FeatureCache, ProcCK807]), !listconcat(tunef, [])>; 567 568def : CK807<"ck807", NoSchedModel, []>; 569def : CK807<"c807", NoSchedModel, []>; 570def : CK807<"r807", NoSchedModel, []>; 571def : CK807<"ck807e", NoSchedModel, [FeatureDSP, HasDSP1E2, HasDSPE60]>; 572def : CK807<"ck807f", NoSchedModel, 573 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 574 HasFLOATE1, HasFLOAT1E2, HasFLOAT1E3, HasFLOAT3E4]>; 575def : CK807<"c807f", NoSchedModel, 576 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 577 HasFLOATE1, HasFLOAT1E2, HasFLOAT1E3, HasFLOAT3E4]>; 578def : CK807<"r807f", NoSchedModel, 579 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 580 HasFLOATE1, HasFLOAT1E2, HasFLOAT1E3, HasFLOAT3E4]>; 581def : CK807<"ck807ef", NoSchedModel, [ 582 FeatureDSP, HasDSP1E2, HasDSPE60, FeatureFPUV2_SF, FeatureFPUV2_DF, 583 FeatureFdivdu, HasFLOATE1, HasFLOAT1E2, HasFLOAT1E3, HasFLOAT3E4]>; 584 585// CK810 series 586class CK810<string n, SchedMachineModel m, list<SubtargetFeature> f, 587 list<SubtargetFeature> tunef = []> 588 : ProcessorModel<n, m, !listconcat(f, 589 [ Has7E10, HasMP, HasMP1E2, FeatureTrust, FeatureHWDiv, FeatureDSP, HasDSP1E2, HasDSPE60, 590 FeatureHighreg, FeatureHardTP, FeatureNVIC, FeatureCache, ProcCK810]), !listconcat(tunef, [])>; 591 592def : CK810<"ck810", NoSchedModel, []>; 593def : CK810<"ck810e", NoSchedModel, []>; 594def : CK810<"ck810t", NoSchedModel, []>; 595def : CK810<"ck810et", NoSchedModel, []>; 596def : CK810<"c810", NoSchedModel, 597 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 598 HasFLOATE1, HasFLOAT1E2]>; 599def : CK810<"ck810f", NoSchedModel, 600 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 601 HasFLOATE1, HasFLOAT1E2]>; 602def : CK810<"ck810ef", NoSchedModel, 603 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 604 HasFLOATE1, HasFLOAT1E2]>; 605def : CK810<"ck810ft", NoSchedModel, 606 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 607 HasFLOATE1, HasFLOAT1E2]>; 608def : CK810<"ck810eft", NoSchedModel, 609 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 610 HasFLOATE1, HasFLOAT1E2]>; 611def : CK810<"c810t", NoSchedModel, 612 [FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 613 HasFLOATE1, HasFLOAT1E2]>; 614 615class CK810V<string n, SchedMachineModel m, list<SubtargetFeature> f, 616 list<SubtargetFeature> tunef = []> 617 : CK810<n, m, !listconcat(f, [FeatureVDSPV1_128, ProcCK810V]), !listconcat(tunef, [])>; 618 619def : CK810V<"ck810v", NoSchedModel, []>; 620def : CK810V<"ck810ev", NoSchedModel, []>; 621def : CK810V<"ck810tv", NoSchedModel, []>; 622def : CK810V<"ck810etv", NoSchedModel, []>; 623def : CK810V<"ck810fv", NoSchedModel, [ 624 FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 625 HasFLOATE1, HasFLOAT1E2 626]>; 627def : CK810V<"ck810efv", NoSchedModel, [ 628 FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 629 HasFLOATE1, HasFLOAT1E2 630]>; 631def : CK810V<"c810v", NoSchedModel, [ 632 FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 633 HasFLOATE1, HasFLOAT1E2 634]>; 635def : CK810V<"ck810ftv", NoSchedModel, [ 636 FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 637 HasFLOATE1, HasFLOAT1E2 638]>; 639def : CK810V<"ck810eftv", NoSchedModel, [ 640 FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 641 HasFLOATE1, HasFLOAT1E2 642]>; 643def : CK810V<"c810tv", NoSchedModel, [ 644 FeatureFPUV2_SF, FeatureFPUV2_DF, FeatureFdivdu, 645 HasFLOATE1, HasFLOAT1E2 646]>; 647 648// CK860 series 649class CK860<string n, SchedMachineModel m, list<SubtargetFeature> f, 650 list<SubtargetFeature> tunef = []> 651 : ProcessorModel<n, m, !listconcat(f, 652 [ Has10E60, HasMP, HasMP1E2, Has3r1E3r2, Has3r2E3r3, FeatureTrust, FeatureBTST16, FeatureHWDiv, HasDSPE60, 653 FeatureHighreg, FeatureHardTP, FeatureNVIC, FeatureCache, ProcCK860]), !listconcat(tunef, [])>; 654 655class CK860V<string n, SchedMachineModel m, list<SubtargetFeature> f, 656 list<SubtargetFeature> tunef = []> 657 : CK860<n, m, !listconcat(f, [FeatureVDSPV2, HasVDSP2E60F, ProcCK860V]), !listconcat(tunef, [])>; 658 659def : CK860<"ck860", NoSchedModel, []>; 660def : CK860<"ck860f", NoSchedModel, 661 [FeatureFPUV3_HI, FeatureFPUV3_HF, FeatureFPUV3_SF, FeatureFPUV3_DF, HasFLOAT7E60]>; 662def : CK860<"c860", NoSchedModel, 663 [FeatureFPUV3_HI, FeatureFPUV3_HF, FeatureFPUV3_SF, FeatureFPUV3_DF, HasFLOAT7E60]>; 664def : CK860V<"c860v", NoSchedModel, 665 [FeatureFPUV3_HI, FeatureFPUV3_HF, FeatureFPUV3_SF, FeatureFPUV3_DF, HasFLOAT7E60]>; 666def : CK860V<"ck860v", NoSchedModel, []>; 667def : CK860V<"ck860fv", NoSchedModel, 668 [FeatureFPUV3_HI, FeatureFPUV3_HF, FeatureFPUV3_SF, FeatureFPUV3_DF, HasFLOAT7E60]>; 669 670//===----------------------------------------------------------------------===// 671// Define the CSKY target. 672//===----------------------------------------------------------------------===// 673 674def CSKYInstrInfo : InstrInfo; 675 676 677def CSKYAsmParser : AsmParser { 678 let ShouldEmitMatchRegisterAltName = 1; 679 let AllowDuplicateRegisterNames = 1; 680} 681 682def CSKYAsmWriter : AsmWriter { 683 int PassSubtarget = 1; 684} 685 686def CSKY : Target { 687 let InstructionSet = CSKYInstrInfo; 688 let AssemblyParsers = [CSKYAsmParser]; 689 let AssemblyWriters = [CSKYAsmWriter]; 690 let AllowRegisterRenaming = 1; 691} 692