Target

Compiler\Compilation.cs (1)

423int pointerSize = _nodeFactory.Target.PointerSize;

Compiler\DependencyAnalysis\ArrayOfFrozenObjectsNode.cs (2)

23builder.EmitZeros(AlignmentHelper.AlignUp(builder.CountBytes, factory.Target.PointerSize) - builder.CountBytes); 33builder.RequireInitialAlignment(factory.Target.PointerSize);

Compiler\DependencyAnalysis\DataOnlyEETypeNode.cs (3)

39if (factory.Target.IsWindows) 76int totalSize = (_gcMap.Size + 1) * factory.Target.PointerSize; 100totalSize = Math.Max(totalSize, factory.Target.PointerSize * 3); // minimum GC MethodTable size is 3 pointers

Compiler\DependencyAnalysis\DictionaryLayoutNode.cs (2)

52if (factory.Target.IsWindows) 135Debug.Assert(builder.CountBytes - offsetBefore == factory.Target.PointerSize);

Compiler\DependencyAnalysis\EETypeNode.cs (14)

Compiler\DependencyAnalysis\EmbeddedPointerIndirectionNode.cs (1)

33if (factory.Target.SupportsRelativePointers)

Compiler\DependencyAnalysis\ExternalReferencesTableNode.cs (5)

67if (factory.Target.IsWindows || factory.Target.SupportsRelativePointers) 87builder.RequireInitialAlignment(factory.Target.SupportsRelativePointers ? 4 : factory.Target.PointerSize); 91if (factory.Target.SupportsRelativePointers)

Compiler\DependencyAnalysis\FatFunctionPointerNode.cs (4)

48if (factory.Target.IsWindows) 64Debug.Assert(factory.Target.MinimumFunctionAlignment <= factory.Target.PointerSize); 65builder.RequireInitialAlignment(factory.Target.PointerSize);

Compiler\DependencyAnalysis\FieldRvaDataNode.cs (1)

43Math.Max(factory.Target.PointerSize, fieldTypePack),

Compiler\DependencyAnalysis\GCStaticsNode.cs (5)

50bool requiresAlign8 = _type.GCStaticFieldAlignment.AsInt > factory.Target.PointerSize; 106if (factory.Target.SupportsRelativePointers) 113if (factory.Target.SupportsRelativePointers) 118else if (factory.Target.SupportsRelativePointers && factory.Target.PointerSize == 8)

Compiler\DependencyAnalysis\GCStaticsPreInitDataNode.cs (2)

46if (factory.Target.IsWindows) 59builder.RequireInitialAlignment(factory.Target.PointerSize);

Compiler\DependencyAnalysis\GenericCompositionNode.cs (2)

46if (factory.Target.IsWindows) 61bool useRelativePointers = factory.Target.SupportsRelativePointers;

Compiler\DependencyAnalysis\GenericVarianceNode.cs (1)

41if (factory.Target.IsWindows)

Compiler\DependencyAnalysis\InterfaceDispatchCellNode.cs (1)

90if (factory.Target.SupportsRelativePointers)

Compiler\DependencyAnalysis\InterfaceDispatchCellSectionNode.cs (1)

29builder.RequireInitialAlignment(factory.Target.PointerSize * 2);

Compiler\DependencyAnalysis\InterfaceDispatchMapNode.cs (1)

44if (factory.Target.IsWindows)

Compiler\DependencyAnalysis\ManagedDataDescriptorNode.cs (4)

32factory.Target.IsWindows ? ObjectNodeSection.ReadOnlyDataSection : ObjectNodeSection.DataSection; 54int headerSize = 8 + 4 + 4 + factory.Target.PointerSize + 4 + 4 + factory.Target.PointerSize; 64uint flags = (uint)(0x01 | (factory.Target.PointerSize == 4 ? 0x02 : 0x00));

Compiler\DependencyAnalysis\ModuleInitializerListNode.cs (2)

130builder.RequireInitialAlignment(factory.Target.PointerSize); 136if (factory.Target.SupportsRelativePointers)

Compiler\DependencyAnalysis\ModulesSectionNode.cs (1)

19return factory.Target.IsWindows ?

Compiler\DependencyAnalysis\NativeLayoutVertexNode.cs (2)

911bool requiresAlign8 = closestCanonDefType.GCStaticFieldAlignment.AsInt > context.Target.PointerSize; 921bool requiresAlign8 = closestCanonDefType.ThreadGcStaticFieldAlignment.AsInt > context.Target.PointerSize;

Compiler\DependencyAnalysis\NodeFactory.cs (1)

937requiredAlign8 &= Target.SupportsAlign8;

Compiler\DependencyAnalysis\NonGCStaticsNode.cs (2)

45if (!factory.Target.IsWindows) 188int classConstructorContextStorageSize = GetClassConstructorContextStorageSize(factory.Target, _type);

Compiler\DependencyAnalysis\PInvokeMethodFixupNode.cs (4)

60if (factory.Target.IsWindows && entryPointName.StartsWith('#')) 87uint? objcFunction = MarshalHelpers.GetObjectiveCMessageSendFunction(factory.Target, _pInvokeMethodData.ModuleData.ModuleName, _pInvokeMethodData.EntryPointName); 97else if (factory.Target.IsWindows && factory.Target.Architecture == TargetArchitecture.X86)

Compiler\DependencyAnalysis\ReadyToRunHeaderNode.cs (2)

48if (factory.Target.IsWindows) 78builder.EmitByte((byte)(8 + factory.Target.PointerSize));

Compiler\DependencyAnalysis\RuntimeFieldHandleNode.cs (1)

35if (factory.Target.IsWindows)

Compiler\DependencyAnalysis\RuntimeMethodHandleNode.cs (1)

42if (factory.Target.IsWindows)

Compiler\DependencyAnalysis\SealedVTableNode.cs (3)

266objData.RequireInitialAlignment(factory.Target.SupportsRelativePointers ? 4 : factory.Target.PointerSize); 281if (factory.Target.SupportsRelativePointers)

Compiler\DependencyAnalysis\StackTraceDocumentsNode.cs (2)

30if (factory.Target.IsWindows || factory.Target.SupportsRelativePointers)

Compiler\DependencyAnalysis\Target_ARM\ARMReadyToRunGenericHelperNode.cs (6)

41encoder.EmitLDR(result, context, dictionarySlot * factory.Target.PointerSize); 78int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 110int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 140int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 156encoder.EmitLDR(encoder.TargetRegister.Arg1, encoder.TargetRegister.Arg1, factory.Target.PointerSize); 233int pointerSize = factory.Target.PointerSize;

Compiler\DependencyAnalysis\Target_ARM\ARMReadyToRunHelperNode.cs (8)

38encoder.EmitSUB(encoder.TargetRegister.Arg0, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 55encoder.EmitLDR(encoder.TargetRegister.Arg1, encoder.TargetRegister.Arg2, factory.Target.PointerSize); 64encoder.EmitSUB(encoder.TargetRegister.Arg2, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 85encoder.EmitSUB(encoder.TargetRegister.Arg0, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 107EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize)); 148(short)(EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize)));

Compiler\DependencyAnalysis\Target_ARM\ARMUnboxingStubNode.cs (1)

12encoder.EmitADD(encoder.TargetRegister.Arg0, (byte)factory.Target.PointerSize); // add r0, sizeof(void*);

Compiler\DependencyAnalysis\Target_ARM64\ARM64ReadyToRunGenericHelperNode.cs (6)

41encoder.EmitLDR(result, context, dictionarySlot * factory.Target.PointerSize); 77encoder.EmitSUB(encoder.TargetRegister.Arg3, encoder.TargetRegister.Arg0, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 109encoder.EmitSUB(encoder.TargetRegister.Arg2, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 138int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 154encoder.EmitLDR(encoder.TargetRegister.Arg1, encoder.TargetRegister.Arg1, factory.Target.PointerSize); 232int pointerSize = factory.Target.PointerSize;

Compiler\DependencyAnalysis\Target_ARM64\ARM64ReadyToRunHelperNode.cs (8)

38encoder.EmitSUB(encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg1, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 62encoder.EmitLDR(encoder.TargetRegister.Arg1, encoder.TargetRegister.Arg2, factory.Target.PointerSize); 72encoder.EmitSUB(encoder.TargetRegister.Arg2, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 100encoder.EmitSUB(encoder.TargetRegister.Arg0, NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 122EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize)); 163((short)(EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize))));

Compiler\DependencyAnalysis\Target_ARM64\ARM64UnboxingStubNode.cs (1)

12encoder.EmitADD(encoder.TargetRegister.Arg0, (byte)factory.Target.PointerSize); // add r0, sizeof(void*);

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64ReadyToRunGenericHelperNode.cs (7)

41encoder.EmitLD(result, context, dictionarySlot * factory.Target.PointerSize); 77encoder.EmitADD(encoder.TargetRegister.Arg3, encoder.TargetRegister.Arg0, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 110encoder.EmitADD(encoder.TargetRegister.Arg2, encoder.TargetRegister.Arg2, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 111encoder.EmitLD(encoder.TargetRegister.Arg3, encoder.TargetRegister.Arg2, factory.Target.PointerSize); 140int cctorContextSize = -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 156encoder.EmitLD(encoder.TargetRegister.Arg1, encoder.TargetRegister.Arg1, factory.Target.PointerSize); 234int pointerSize = factory.Target.PointerSize;

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64ReadyToRunHelperNode.cs (8)

38encoder.EmitADD(encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg1, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 56encoder.EmitLD(encoder.TargetRegister.Arg1, encoder.TargetRegister.Arg2, factory.Target.PointerSize); 65encoder.EmitADD(encoder.TargetRegister.Arg2, encoder.TargetRegister.Arg2, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 92encoder.EmitADD(encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg0, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 114EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize)); 155EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize));

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64UnboxingStubNode.cs (1)

13encoder.EmitADD(encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg0, factory.Target.PointerSize);

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64ReadyToRunGenericHelperNode.cs (6)

41encoder.EmitLD(result, context, dictionarySlot * factory.Target.PointerSize); 76encoder.EmitADDI(encoder.TargetRegister.Arg3, encoder.TargetRegister.Arg0, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 108encoder.EmitADDI(encoder.TargetRegister.Arg2, encoder.TargetRegister.Arg2, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 137int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 153encoder.EmitLD(encoder.TargetRegister.Arg1, encoder.TargetRegister.Arg1, factory.Target.PointerSize); 231int pointerSize = factory.Target.PointerSize;

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64ReadyToRunHelperNode.cs (8)

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64UnboxingStubNode.cs (1)

13encoder.EmitADDI(encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg0, factory.Target.PointerSize);

Compiler\DependencyAnalysis\Target_X64\X64ReadyToRunGenericHelperNode.cs (6)

42context, null, dictionarySlot * factory.Target.PointerSize, 0, AddrModeSize.Int64); 81int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 115int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 145int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 163AddrMode loadFromArg1AndDelta = new AddrMode(encoder.TargetRegister.Arg1, null, factory.Target.PointerSize, 0, AddrModeSize.Int64); 241int pointerSize = factory.Target.PointerSize;

Compiler\DependencyAnalysis\Target_X64\X64ReadyToRunHelperNode.cs (8)

38AddrMode loadCctor = new AddrMode(encoder.TargetRegister.Arg1, null, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target), 0, AddrModeSize.Int64); 65AddrMode loadFromArg2AndDelta = new AddrMode(encoder.TargetRegister.Arg2, null, factory.Target.PointerSize, 0, AddrModeSize.Int32); 75encoder.EmitLEAQ(encoder.TargetRegister.Arg2, factory.TypeNonGCStaticsSymbol(target), -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 104encoder.EmitLEAQ(encoder.TargetRegister.Arg0, factory.TypeNonGCStaticsSymbol(target), -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 126AddrMode loadFromSlot = new AddrMode(encoder.TargetRegister.Arg2, null, EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize), 0, AddrModeSize.Int64); 168AddrMode loadFromSlot = new AddrMode(encoder.TargetRegister.Result, null, EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize), 0, AddrModeSize.Int64);

Compiler\DependencyAnalysis\Target_X64\X64UnboxingStubNode.cs (1)

14encoder.EmitADD(ref thisPtr, (sbyte)factory.Target.PointerSize);

Compiler\DependencyAnalysis\Target_X86\X86ReadyToRunGenericHelperNode.cs (6)

34context, null, dictionarySlot * factory.Target.PointerSize, 0, AddrModeSize.Int32); 70int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 102int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 130int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextSize(factory.Target); 152AddrMode loadFromArg1AndDelta = new AddrMode(encoder.TargetRegister.Arg1, null, factory.Target.PointerSize, 0, AddrModeSize.Int32); 240int pointerSize = factory.Target.PointerSize;

Compiler\DependencyAnalysis\Target_X86\X86ReadyToRunHelperNode.cs (8)

37encoder.EmitMOV(encoder.TargetRegister.Arg0, factory.TypeNonGCStaticsSymbol(target), -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 62AddrMode loadFromEaxAndDelta = new AddrMode(encoder.TargetRegister.Result, null, factory.Target.PointerSize, 0, AddrModeSize.Int32); 72encoder.EmitMOV(encoder.TargetRegister.Result, factory.TypeNonGCStaticsSymbol(target), -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 106encoder.EmitMOV(encoder.TargetRegister.Arg0, factory.TypeNonGCStaticsSymbol(target), -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); 130AddrMode loadFromSlot = new AddrMode(encoder.TargetRegister.Result, null, EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize), 0, AddrModeSize.Int32); 177AddrMode loadFromSlot = new AddrMode(encoder.TargetRegister.Result, null, EETypeNode.GetVTableOffset(factory.Target.PointerSize) + (slot * factory.Target.PointerSize), 0, AddrModeSize.Int32);

Compiler\DependencyAnalysis\Target_X86\X86UnboxingStubNode.cs (1)

14encoder.EmitADD(ref thisPtr, (sbyte)factory.Target.PointerSize);

Compiler\DependencyAnalysis\ThreadStaticsNode.cs (2)

63factory.Target.PointerSize); 64bool requiresAlign8 = _type is not null && _type.ThreadGcStaticFieldAlignment.AsInt > factory.Target.PointerSize;

Compiler\DependencyAnalysis\TypeThreadStaticIndexNode.cs (2)

36if (factory.Target.IsWindows) 71typeTlsIndex = - (_inlinedThreadStatics.GetTypeStorageOffset(_type) + factory.Target.PointerSize);

Compiler\DependencyAnalysis\UnboxingStubNode.cs (1)

20return factory.Target.IsWindows ?

Compiler\ILScanner.cs (5)

916int nextDataOffset = factory.Target.PointerSize; 938Debug.Assert(t.ThreadGcStaticFieldAlignment.AsInt <= factory.Target.PointerSize); 942offsets.Add(t, nextDataOffset - factory.Target.PointerSize); 945int dataSize = t.ThreadGcStaticFieldSize.AsInt - factory.Target.PointerSize; 953_size = Math.Max(nextDataOffset, factory.Target.PointerSize * 3);

Compiler\ObjectWriter\CoffObjectWriter.Aot.cs (4)

178_nodeFactory.Target.Architecture, 184_nodeFactory.NameMangler, _nodeFactory.Target.PointerSize, 209debugSymbolsBuilder = new CodeViewSymbolsBuilder(_nodeFactory.Target.Architecture, sectionWriter); 248debugSymbolsBuilder = new CodeViewSymbolsBuilder(_nodeFactory.Target.Architecture, sectionWriter);

Compiler\ObjectWriter\UnixObjectWriter.Aot.cs (3)

59bool is64Bit = _nodeFactory.Target.Architecture switch 65_dwarfCie = new DwarfCie(_nodeFactory.Target.Architecture); 324_nodeFactory.Target,

Compiler\RuntimeConfigurationRootProvider.cs (1)

58factory.Target.IsWindows ? ObjectNodeSection.ReadOnlyDataSection : ObjectNodeSection.DataSection;

Compiler\TypePreinit.cs (1)

3571int pointerSize = factory.Target.PointerSize;

Compiler\UserDefinedTypeDescriptor.cs (6)

25private bool Is64Bit => NodeFactory.Target.PointerSize == 8; 27private TargetAbi Abi => NodeFactory.Target.Abi; 674if (NodeFactory.Target.OperatingSystem != TargetOS.Windows) 711if (NodeFactory.Target.OperatingSystem == TargetOS.Windows) 785Size = (ulong)NodeFactory.Target.PointerSize * 2ul, 813Offset = (ulong)NodeFactory.Target.PointerSize,

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\AssemblyStubNode.cs (3)

39factory.Target.MinimumFunctionAlignment : 40factory.Target.MinimumCodeAlignment; 42switch (factory.Target.Architecture)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\ObjectDataBuilder.cs (1)

20public ObjectDataBuilder(NodeFactory factory, bool relocsOnly) : this(factory.Target, relocsOnly)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\ObjectNode.cs (1)

71if (factory.Target.IsWasm && this is IMethodCodeNodeWithTypeSignature wasmMethodCodeNode)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_ARM\ARMEmitter.cs (1)

13TargetRegister = new TargetRegisterMap(factory.Target.OperatingSystem);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_ARM64\ARM64Emitter.cs (1)

14TargetRegister = new TargetRegisterMap(factory.Target.OperatingSystem);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64Emitter.cs (1)

14TargetRegister = new TargetRegisterMap(factory.Target.OperatingSystem);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_RiscV64\RiscV64Emitter.cs (1)

14TargetRegister = new TargetRegisterMap(factory.Target.OperatingSystem);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_Wasm\WasmEmitter.cs (1)

22public bool Is64Bit => factory.Target.PointerSize == 8;

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_X64\X64Emitter.cs (1)

14TargetRegister = new TargetRegisterMap(factory.Target.OperatingSystem);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_X86\X86Emitter.cs (1)

14TargetRegister = new TargetRegisterMap(factory.Target.OperatingSystem);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (1)

68_machine = factory.Target.Architecture switch

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ElfObjectWriter.cs (2)

59_machine = factory.Target.Architecture switch 70_useSoftFPAbi = _machine is EM_ARM && factory.Target.Abi == TargetAbi.NativeAotArmel;

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\MachObjectWriter.cs (2)

79switch (factory.Target.Architecture) 99_targetOS = factory.Target.OperatingSystem;

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ObjectWriter.cs (11)

59_insPaddingByte = factory.Target.Architecture switch 328if (_nodeFactory.Target.OperatingSystem == TargetOS.Windows) 413long thumbBit = _nodeFactory.Target.Architecture == TargetArchitecture.ARM && isMethod ? 1 : 0; 423if (node is INodeWithTypeSignature codeNode && _nodeFactory.Target.IsWasm) 480if (_nodeFactory.Target.Architecture is not TargetArchitecture.X86 and not TargetArchitecture.Wasm32) 485if ((reloc.RelocType is RelocType.IMAGE_REL_BASED_DIR64 && _nodeFactory.Target.PointerSize == 8) || 486(reloc.RelocType is RelocType.IMAGE_REL_BASED_HIGHLOW && _nodeFactory.Target.PointerSize == 4)) 489Debug.Assert(reloc.Offset % _nodeFactory.Target.PointerSize == 0); 492Debug.Assert(!hasPointerRelocs || (nodeContents.Alignment % _nodeFactory.Target.PointerSize) == 0); 710factory.Target.IsApplePlatform ? new MachObjectWriter(factory, options) : 711factory.Target.OperatingSystem == TargetOS.Windows ? new CoffObjectWriter(factory, options) :

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\PEObjectWriter.cs (6)

391textSection.EmitAlignment(_nodeFactory.Target.PointerSize); 406bool isWindowsOr32bit = _nodeFactory.Target.IsWindows || _nodeFactory.Target.PointerSize != 8; 450bool isPE32Plus = _nodeFactory.Target.PointerSize == 8; 518if (!_nodeFactory.Target.IsWindows) 729bool isPE32Plus = _nodeFactory.Target.PointerSize == 8;