1//===-- X86.h - Top-level interface for X86 representation ------*- C++ -*-===//
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//
9// This file contains the entry points for global functions defined in the x86
10// target library, as used by the LLVM JIT.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_X86_X86_H
15#define LLVM_LIB_TARGET_X86_X86_H
16
17#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
18#include "llvm/CodeGen/SelectionDAGISel.h"
19#include "llvm/IR/Analysis.h"
20#include "llvm/IR/Module.h"
21#include "llvm/IR/PassManager.h"
22#include "llvm/PassInfo.h"
23#include "llvm/Support/CodeGen.h"
24#include "llvm/Target/TargetMachine.h"
25
26struct RetpolineThunkInserter;
27struct LVIThunkInserter;
28
29namespace llvm {
30
31class FunctionPass;
32class InstructionSelector;
33class MachineFunction;
34class PassRegistry;
35class X86RegisterBankInfo;
36class X86Subtarget;
37class X86TargetMachine;
38
39/// This pass converts a legalized DAG into a X86-specific DAG, ready for
40/// instruction scheduling.
41class X86ISelDAGToDAGPass : public SelectionDAGISelPass {
42public:
43 X86ISelDAGToDAGPass(X86TargetMachine &TM);
44};
45
46FunctionPass *createX86ISelDag(X86TargetMachine &TM, CodeGenOptLevel OptLevel);
47
48/// This pass initializes a global base register for PIC on x86-32.
49class X86GlobalBaseRegPass
50 : public OptionalPassInfoMixin<X86GlobalBaseRegPass> {
51public:
52 PreservedAnalyses run(MachineFunction &MF,
53 MachineFunctionAnalysisManager &MFAM);
54};
55
56FunctionPass *createX86GlobalBaseRegLegacyPass();
57
58/// This pass combines multiple accesses to local-dynamic TLS variables so that
59/// the TLS base address for the module is only fetched once per execution path
60/// through the function.
61class X86CleanupLocalDynamicTLSPass
62 : public OptionalPassInfoMixin<X86CleanupLocalDynamicTLSPass> {
63public:
64 PreservedAnalyses run(MachineFunction &MF,
65 MachineFunctionAnalysisManager &MFAM);
66};
67
68FunctionPass *createCleanupLocalDynamicTLSLegacyPass();
69
70/// This function returns a pass which converts floating-point register
71/// references and pseudo instructions into floating-point stack references and
72/// physical instructions.
73class X86FPStackifierPass : public OptionalPassInfoMixin<X86FPStackifierPass> {
74public:
75 PreservedAnalyses run(MachineFunction &MF,
76 MachineFunctionAnalysisManager &MFAM);
77};
78
79FunctionPass *createX86FPStackifierLegacyPass();
80
81/// This pass aligns the code so that it conforms to the LFI sandboxing rules.
82class X86LFIRewritePass : public RequiredPassInfoMixin<X86LFIRewritePass> {
83public:
84 PreservedAnalyses run(MachineFunction &MF,
85 MachineFunctionAnalysisManager &MFAM);
86};
87
88FunctionPass *createX86LFIRewritePass();
89
90/// This pass inserts AVX vzeroupper instructions before each call to avoid
91/// transition penalty between functions encoded with AVX and SSE.
92class X86InsertVZeroUpperPass
93 : public OptionalPassInfoMixin<X86InsertVZeroUpperPass> {
94public:
95 PreservedAnalyses run(MachineFunction &MF,
96 MachineFunctionAnalysisManager &MFAM);
97};
98
99FunctionPass *createX86InsertVZeroUpperLegacyPass();
100/// This pass inserts ENDBR instructions before indirect jump/call
101/// destinations as part of CET IBT mechanism.
102class X86IndirectBranchTrackingPass
103 : public OptionalPassInfoMixin<X86IndirectBranchTrackingPass> {
104public:
105 PreservedAnalyses run(MachineFunction &MF,
106 MachineFunctionAnalysisManager &MFAM);
107};
108
109FunctionPass *createX86IndirectBranchTrackingLegacyPass();
110
111/// Return a pass that pads short functions with NOOPs.
112/// This will prevent a stall when returning on the Atom.
113class X86PadShortFunctionsPass
114 : public OptionalPassInfoMixin<X86PadShortFunctionsPass> {
115public:
116 PreservedAnalyses run(MachineFunction &MF,
117 MachineFunctionAnalysisManager &MFAM);
118};
119
120FunctionPass *createX86PadShortFunctionsLegacyPass();
121
122/// Return a pass that selectively replaces certain instructions (like add,
123/// sub, inc, dec, some shifts, and some multiplies) by equivalent LEA
124/// instructions, in order to eliminate execution delays in some processors.
125class X86FixupLEAsPass : public OptionalPassInfoMixin<X86FixupLEAsPass> {
126public:
127 PreservedAnalyses run(MachineFunction &MF,
128 MachineFunctionAnalysisManager &MFAM);
129};
130
131FunctionPass *createX86FixupLEAsLegacyPass();
132
133/// Return a pass that replaces equivalent slower instructions with faster
134/// ones.
135class X86FixupInstTuningPass
136 : public OptionalPassInfoMixin<X86FixupInstTuningPass> {
137public:
138 PreservedAnalyses run(MachineFunction &MF,
139 MachineFunctionAnalysisManager &MFAM);
140};
141
142FunctionPass *createX86FixupInstTuningLegacyPass();
143
144/// Return a pass that reduces the size of vector constant pool loads.
145class X86FixupVectorConstantsPass
146 : public OptionalPassInfoMixin<X86FixupVectorConstantsPass> {
147public:
148 PreservedAnalyses run(MachineFunction &MF,
149 MachineFunctionAnalysisManager &MFAM);
150};
151
152FunctionPass *createX86FixupVectorConstantsLegacyPass();
153
154/// Return a pass that removes redundant LEA instructions and redundant address
155/// recalculations.
156class X86OptimizeLEAsPass : public OptionalPassInfoMixin<X86OptimizeLEAsPass> {
157public:
158 PreservedAnalyses run(MachineFunction &MF,
159 MachineFunctionAnalysisManager &MFAM);
160};
161
162FunctionPass *createX86OptimizeLEAsLegacyPass();
163
164/// Return a pass that transforms setcc + movzx pairs into xor + setcc.
165class X86FixupSetCCPass : public OptionalPassInfoMixin<X86FixupSetCCPass> {
166public:
167 PreservedAnalyses run(MachineFunction &MF,
168 MachineFunctionAnalysisManager &MFAM);
169};
170
171FunctionPass *createX86FixupSetCCLegacyPass();
172
173/// Return a pass that avoids creating store forward block issues in the
174/// hardware.
175class X86AvoidStoreForwardingBlocksPass
176 : public OptionalPassInfoMixin<X86AvoidStoreForwardingBlocksPass> {
177public:
178 PreservedAnalyses run(MachineFunction &MF,
179 MachineFunctionAnalysisManager &MFAM);
180};
181
182FunctionPass *createX86AvoidStoreForwardingBlocksLegacyPass();
183
184/// Return a pass that lowers EFLAGS copy pseudo instructions.
185class X86FlagsCopyLoweringPass
186 : public OptionalPassInfoMixin<X86FlagsCopyLoweringPass> {
187public:
188 PreservedAnalyses run(MachineFunction &MF,
189 MachineFunctionAnalysisManager &MFAM);
190};
191
192FunctionPass *createX86FlagsCopyLoweringLegacyPass();
193
194/// Return a pass that expands DynAlloca pseudo-instructions.
195class X86DynAllocaExpanderPass
196 : public OptionalPassInfoMixin<X86DynAllocaExpanderPass> {
197public:
198 PreservedAnalyses run(MachineFunction &MF,
199 MachineFunctionAnalysisManager &MFAM);
200};
201
202FunctionPass *createX86DynAllocaExpanderLegacyPass();
203
204/// Return a pass that config the tile registers.
205class X86TileConfigPass : public OptionalPassInfoMixin<X86TileConfigPass> {
206public:
207 PreservedAnalyses run(MachineFunction &MF,
208 MachineFunctionAnalysisManager &MFAM);
209};
210
211FunctionPass *createX86TileConfigLegacyPass();
212
213/// Return a pass that preconfig the tile registers before fast reg allocation.
214class X86FastPreTileConfigPass
215 : public OptionalPassInfoMixin<X86FastPreTileConfigPass> {
216public:
217 PreservedAnalyses run(MachineFunction &MF,
218 MachineFunctionAnalysisManager &MFAM);
219};
220
221FunctionPass *createX86FastPreTileConfigLegacyPass();
222
223/// Return a pass that config the tile registers after fast reg allocation.
224class X86FastTileConfigPass
225 : public OptionalPassInfoMixin<X86FastTileConfigPass> {
226public:
227 PreservedAnalyses run(MachineFunction &MF,
228 MachineFunctionAnalysisManager &MFAM);
229};
230
231FunctionPass *createX86FastTileConfigLegacyPass();
232
233/// Return a pass that insert pseudo tile config instruction.
234class X86PreTileConfigPass
235 : public OptionalPassInfoMixin<X86PreTileConfigPass> {
236public:
237 PreservedAnalyses run(MachineFunction &MF,
238 MachineFunctionAnalysisManager &MFAM);
239};
240
241FunctionPass *createX86PreTileConfigLegacyPass();
242
243/// Return a pass that lower the tile copy instruction.
244class X86LowerTileCopyPass
245 : public OptionalPassInfoMixin<X86LowerTileCopyPass> {
246public:
247 PreservedAnalyses run(MachineFunction &MF,
248 MachineFunctionAnalysisManager &MFAM);
249};
250
251FunctionPass *createX86LowerTileCopyLegacyPass();
252
253/// Return a pass that inserts int3 at the end of the function if it ends with a
254/// CALL instruction. The pass does the same for each funclet as well. This
255/// ensures that the open interval of function start and end PCs contains all
256/// return addresses for the benefit of the Windows x64 unwinder.
257class X86AvoidTrailingCallPass
258 : public RequiredPassInfoMixin<X86AvoidTrailingCallPass> {
259public:
260 PreservedAnalyses run(MachineFunction &MF,
261 MachineFunctionAnalysisManager &MFAM);
262};
263
264FunctionPass *createX86AvoidTrailingCallLegacyPass();
265
266/// Return a pass that optimizes the code-size of x86 call sequences. This is
267/// done by replacing esp-relative movs with pushes.
268class X86CallFrameOptimizationPass
269 : public OptionalPassInfoMixin<X86CallFrameOptimizationPass> {
270public:
271 PreservedAnalyses run(MachineFunction &MF,
272 MachineFunctionAnalysisManager &MFAM);
273};
274
275FunctionPass *createX86CallFrameOptimizationLegacyPass();
276
277/// Return an IR pass that inserts EH registration stack objects and explicit
278/// EH state updates. This pass must run after EH preparation, which does
279/// Windows-specific but architecture-neutral preparation.
280class X86WinEHStatePass : public OptionalPassInfoMixin<X86WinEHStatePass> {
281public:
282 X86WinEHStatePass() = default;
283 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
284};
285
286FunctionPass *createX86WinEHStateLegacyPass();
287
288/// Return a Machine IR pass that expands X86-specific pseudo
289/// instructions into a sequence of actual instructions. This pass
290/// must run after prologue/epilogue insertion and before lowering
291/// the MachineInstr to MC.
292class X86ExpandPseudoPass : public OptionalPassInfoMixin<X86ExpandPseudoPass> {
293public:
294 PreservedAnalyses run(MachineFunction &MF,
295 MachineFunctionAnalysisManager &MFAM);
296};
297
298FunctionPass *createX86ExpandPseudoLegacyPass();
299
300/// This pass converts X86 cmov instructions into branch when profitable.
301class X86CmovConversionPass
302 : public OptionalPassInfoMixin<X86CmovConversionPass> {
303public:
304 PreservedAnalyses run(MachineFunction &MF,
305 MachineFunctionAnalysisManager &MFAM);
306};
307
308FunctionPass *createX86CmovConversionLegacyPass();
309
310/// Return a Machine IR pass that selectively replaces
311/// certain byte and word instructions by equivalent 32 bit instructions,
312/// in order to eliminate partial register usage, false dependences on
313/// the upper portions of registers, and to save code size.
314class X86FixupBWInstsPass : public OptionalPassInfoMixin<X86FixupBWInstsPass> {
315public:
316 PreservedAnalyses run(MachineFunction &MF,
317 MachineFunctionAnalysisManager &MFAM);
318};
319
320FunctionPass *createX86FixupBWInstsLegacyPass();
321
322/// Return a Machine IR pass that reassigns instruction chains from one domain
323/// to another, when profitable.
324class X86DomainReassignmentPass
325 : public OptionalPassInfoMixin<X86DomainReassignmentPass> {
326public:
327 PreservedAnalyses run(MachineFunction &MF,
328 MachineFunctionAnalysisManager &MFAM);
329};
330
331FunctionPass *createX86DomainReassignmentLegacyPass();
332
333/// This pass compress instructions from EVEX space to legacy/VEX/EVEX space when
334/// possible in order to reduce code size or facilitate HW decoding.
335class X86CompressEVEXPass : public OptionalPassInfoMixin<X86CompressEVEXPass> {
336public:
337 PreservedAnalyses run(MachineFunction &MF,
338 MachineFunctionAnalysisManager &MFAM);
339};
340
341FunctionPass *createX86CompressEVEXLegacyPass();
342
343/// This pass creates the thunks for the retpoline feature.
344class X86IndirectThunksPass
345 : public RequiredPassInfoMixin<X86IndirectThunksPass> {
346 std::unique_ptr<RetpolineThunkInserter> RetpolineInserter;
347 std::unique_ptr<LVIThunkInserter> LVIInserter;
348
349public:
350 X86IndirectThunksPass();
351 X86IndirectThunksPass(X86IndirectThunksPass &&);
352 ~X86IndirectThunksPass();
353
354 PreservedAnalyses run(MachineFunction &MF,
355 MachineFunctionAnalysisManager &MFAM);
356};
357
358FunctionPass *createX86IndirectThunksLegacyPass();
359
360/// This pass replaces ret instructions with jmp's to __x86_return thunk.
361class X86ReturnThunksPass : public OptionalPassInfoMixin<X86ReturnThunksPass> {
362public:
363 PreservedAnalyses run(MachineFunction &MF,
364 MachineFunctionAnalysisManager &MFAM);
365};
366
367FunctionPass *createX86ReturnThunksLegacyPass();
368
369/// This pass insert wait instruction after X87 instructions which could raise
370/// fp exceptions when strict-fp enabled.
371class X86InsertX87WaitPass
372 : public OptionalPassInfoMixin<X86InsertX87WaitPass> {
373public:
374 PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &);
375};
376
377FunctionPass *createX86InsertX87WaitLegacyPass();
378
379/// This pass optimizes arithmetic based on knowledge that is only used by
380/// a reduction sequence and is therefore safe to reassociate in interesting
381/// ways.
382class X86PartialReductionPass
383 : public OptionalPassInfoMixin<X86PartialReductionPass> {
384private:
385 const X86TargetMachine *TM;
386
387public:
388 X86PartialReductionPass(const X86TargetMachine *TM) : TM(TM) {}
389 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
390};
391
392FunctionPass *createX86PartialReductionLegacyPass();
393
394/// Return a pass that inserts sfence intrinsics between non-temporal stores and
395/// potential synchronization points (or function returns).
396class X86FenceNonTemporalStoresPass
397 : public RequiredPassInfoMixin<X86FenceNonTemporalStoresPass> {
398private:
399 const X86TargetMachine *TM;
400
401public:
402 explicit X86FenceNonTemporalStoresPass(const X86TargetMachine *TM = nullptr)
403 : TM(TM) {}
404 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
405};
406
407FunctionPass *createX86FenceNonTemporalStoresLegacyPass();
408
409/// // Analyzes and emits pseudos to support Win x64 Unwind V2.
410class X86WinEHUnwindV2Pass
411 : public OptionalPassInfoMixin<X86WinEHUnwindV2Pass> {
412public:
413 X86WinEHUnwindV2Pass() = default;
414 PreservedAnalyses run(MachineFunction &MF,
415 MachineFunctionAnalysisManager &MFAM);
416};
417
418FunctionPass *createX86WinEHUnwindV2LegacyPass();
419
420/// The pass transforms load/store <256 x i32> to AMX load/store intrinsics
421/// or split the data to two <128 x i32>.
422class X86LowerAMXTypePass : public RequiredPassInfoMixin<X86LowerAMXTypePass> {
423private:
424 const TargetMachine *TM;
425
426public:
427 X86LowerAMXTypePass(const TargetMachine *TM) : TM(TM) {}
428 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
429};
430
431FunctionPass *createX86LowerAMXTypeLegacyPass();
432
433// Suppresses APX features for relocations for supporting older linkers.
434class X86SuppressAPXForRelocationPass
435 : public OptionalPassInfoMixin<X86SuppressAPXForRelocationPass> {
436public:
437 PreservedAnalyses run(MachineFunction &MF,
438 MachineFunctionAnalysisManager &MFAM);
439};
440
441FunctionPass *createX86SuppressAPXForRelocationLegacyPass();
442
443/// The pass transforms amx intrinsics to scalar operation if the function has
444/// optnone attribute or it is O0.
445class X86LowerAMXIntrinsicsPass
446 : public RequiredPassInfoMixin<X86LowerAMXIntrinsicsPass> {
447private:
448 const TargetMachine *TM;
449
450public:
451 X86LowerAMXIntrinsicsPass(const TargetMachine *TM) : TM(TM) {}
452 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
453};
454
455FunctionPass *createX86LowerAMXIntrinsicsLegacyPass();
456
457/// Capacity check and sub-fragment splitting for Win x64 Unwind V3.
458FunctionPass *createX86WinEHUnwindV3Pass();
459
460/// Returns true when \p MF must use Windows x64 Unwind V3: the module is in V3
461/// mode, or the function needs an unwind table and may use EGPR (R16-R31),
462/// which V1/V2 cannot encode. Shared by frame lowering and the WinEH Unwind
463/// V2/V3 passes so their decisions cannot disagree.
464bool requireWinX64UnwindV3(const MachineFunction &MF);
465
466InstructionSelector *createX86InstructionSelector(const X86TargetMachine &TM,
467 const X86Subtarget &,
468 const X86RegisterBankInfo &);
469
470class X86PostLegalizerCombinerPass
471 : public OptionalPassInfoMixin<X86PostLegalizerCombinerPass> {
472public:
473 PreservedAnalyses run(MachineFunction &MF,
474 MachineFunctionAnalysisManager &MFAM);
475};
476
477FunctionPass *createX86PostLegalizerCombinerLegacy();
478
479class X86PreLegalizerCombinerPass
480 : public RequiredPassInfoMixin<X86PreLegalizerCombinerPass> {
481public:
482 PreservedAnalyses run(MachineFunction &MF,
483 MachineFunctionAnalysisManager &MFAM);
484};
485
486FunctionPass *createX86PreLegalizerCombinerLegacy();
487
488class X86LoadValueInjectionLoadHardeningPass
489 : public OptionalPassInfoMixin<X86LoadValueInjectionLoadHardeningPass> {
490public:
491 PreservedAnalyses run(MachineFunction &MF,
492 MachineFunctionAnalysisManager &MFAM);
493};
494
495FunctionPass *createX86LoadValueInjectionLoadHardeningLegacyPass();
496
497class X86LoadValueInjectionRetHardeningPass
498 : public OptionalPassInfoMixin<X86LoadValueInjectionRetHardeningPass> {
499public:
500 PreservedAnalyses run(MachineFunction &MF,
501 MachineFunctionAnalysisManager &MFAM);
502};
503
504FunctionPass *createX86LoadValueInjectionRetHardeningLegacyPass();
505
506class X86SpeculativeExecutionSideEffectSuppressionPass
507 : public OptionalPassInfoMixin<
508 X86SpeculativeExecutionSideEffectSuppressionPass> {
509public:
510 PreservedAnalyses run(MachineFunction &MF,
511 MachineFunctionAnalysisManager &MFAM);
512};
513
514FunctionPass *createX86SpeculativeExecutionSideEffectSuppressionLegacyPass();
515
516class X86SpeculativeLoadHardeningPass
517 : public OptionalPassInfoMixin<X86SpeculativeLoadHardeningPass> {
518public:
519 PreservedAnalyses run(MachineFunction &MF,
520 MachineFunctionAnalysisManager &MFAM);
521};
522
523FunctionPass *createX86SpeculativeLoadHardeningLegacyPass();
524
525class X86ArgumentStackSlotPass
526 : public OptionalPassInfoMixin<X86ArgumentStackSlotPass> {
527public:
528 PreservedAnalyses run(MachineFunction &MF,
529 MachineFunctionAnalysisManager &MFAM);
530};
531
532FunctionPass *createX86ArgumentStackSlotLegacyPass();
533
534void initializeCompressEVEXLegacyPass(PassRegistry &);
535void initializeX86FixupBWInstLegacyPass(PassRegistry &);
536void initializeFixupLEAsLegacyPass(PassRegistry &);
537void initializeX86ArgumentStackSlotLegacyPass(PassRegistry &);
538void initializeX86AsmPrinterPass(PassRegistry &);
539void initializeX86FixupInstTuningLegacyPass(PassRegistry &);
540void initializeX86FixupVectorConstantsLegacyPass(PassRegistry &);
541void initializeWinEHStateLegacyPass(PassRegistry &);
542void initializeX86AvoidSFBLegacyPass(PassRegistry &);
543void initializeX86AvoidTrailingCallLegacyPassPass(PassRegistry &);
544void initializeX86CallFrameOptimizationLegacyPass(PassRegistry &);
545void initializeX86CmovConversionLegacyPass(PassRegistry &);
546void initializeX86DAGToDAGISelLegacyPass(PassRegistry &);
547void initializeX86DomainReassignmentLegacyPass(PassRegistry &);
548void initializeX86DynAllocaExpanderLegacyPass(PassRegistry &);
549void initializeX86ExpandPseudoLegacyPass(PassRegistry &);
550void initializeX86FPStackifierLegacyPass(PassRegistry &);
551void initializeX86FastPreTileConfigLegacyPass(PassRegistry &);
552void initializeX86FastTileConfigLegacyPass(PassRegistry &);
553void initializeX86FenceNonTemporalStoresLegacyPass(PassRegistry &);
554void initializeX86FixupSetCCLegacyPass(PassRegistry &);
555void initializeX86FlagsCopyLoweringLegacyPass(PassRegistry &);
556void initializeX86IndirectBranchTrackingLegacyPass(PassRegistry &);
557void initializeX86LoadValueInjectionLoadHardeningLegacyPass(PassRegistry &);
558void initializeX86LoadValueInjectionRetHardeningLegacyPass(PassRegistry &);
559void initializeX86LowerAMXIntrinsicsLegacyPassPass(PassRegistry &);
560void initializeX86LowerAMXTypeLegacyPassPass(PassRegistry &);
561void initializeX86LowerTileCopyLegacyPass(PassRegistry &);
562void initializeX86OptimizeLEAsLegacyPass(PassRegistry &);
563void initializeX86PartialReductionLegacyPass(PassRegistry &);
564void initializeX86PreTileConfigLegacyPass(PassRegistry &);
565void initializeX86ReturnThunksLegacyPass(PassRegistry &);
566void initializeX86SpeculativeExecutionSideEffectSuppressionLegacyPass(
567 PassRegistry &);
568void initializeX86SpeculativeLoadHardeningLegacyPass(PassRegistry &);
569void initializeX86SuppressAPXForRelocationLegacyPass(PassRegistry &);
570void initializeX86TileConfigLegacyPass(PassRegistry &);
571void initializeX86WinEHUnwindV2LegacyPass(PassRegistry &);
572void initializeX86PreLegalizerCombinerLegacyPass(PassRegistry &);
573void initializeX86PostLegalizerCombinerLegacyPass(PassRegistry &);
574void initializeX86WinEHUnwindV3Pass(PassRegistry &);
575
576namespace X86AS {
577enum : unsigned {
578 GS = 256,
579 FS = 257,
580 SS = 258,
581 PTR32_SPTR = 270,
582 PTR32_UPTR = 271,
583 PTR64 = 272
584};
585} // End X86AS namespace
586
587} // End llvm namespace
588
589#endif
590