protected override void readStruct(Stream stream) { using BinaryReader reader = new BinaryReader(stream); frameIndex = reader.ReadUInt32(); geometryIndex = reader.ReadUInt32(); flags = EnumUtils.intToFlags <AtomicFlags>(reader.ReadUInt32()); }
public AtomicIntrinsicAttribute( AtomicIntrinsicKind intrinsicKind, AtomicFlags intrinsicFlags) { IntrinsicKind = intrinsicKind; IntrinsicFlags = intrinsicFlags; }
public AtomicIntrinsicAttribute( AtomicIntrinsicKind kind, AtomicFlags flags) { IntrinsicKind = kind; IntrinsicFlags = flags; }
public AtomicStruct_0001 Read(BinaryReader binaryReader) { sectionIdentifier = Section.Atomic; sectionSize = binaryReader.ReadInt32(); renderWareVersion = binaryReader.ReadInt32(); frameIndex = binaryReader.ReadInt32(); geometryIndex = binaryReader.ReadInt32(); flags = (AtomicFlags)binaryReader.ReadInt32(); unused = binaryReader.ReadInt32(); return(this); }
/// <summary> /// Constructs a new abstract atomic value. /// </summary> /// <param name="basicBlock">The parent basic block.</param> /// <param name="target">The target.</param> /// <param name="value">The value to store.</param> /// <param name="arguments">Additional arguments.</param> /// <param name="flags">The operation flags.</param> internal AtomicValue( BasicBlock basicBlock, ValueReference target, ValueReference value, ImmutableArray <ValueReference> arguments, AtomicFlags flags) : base( basicBlock, ImmutableArray.Create(target, value).AddRange(arguments), ComputeType(value)) { Flags = flags; }
/// <summary> /// Constructs a new atomic compare-and-swap operation. /// </summary> /// <param name="basicBlock">The parent basic block.</param> /// <param name="target">The target.</param> /// <param name="value">The value to store.</param> /// <param name="compareValue">The comparison value.</param> /// <param name="flags">The operation flags.</param> internal AtomicCAS( BasicBlock basicBlock, ValueReference target, ValueReference value, ValueReference compareValue, AtomicFlags flags) : base( basicBlock, target, value, ImmutableArray.Create(compareValue), flags) { Debug.Assert(value.Type == (target.Type as PointerType).ElementType); Debug.Assert(value.Type == compareValue.Type); }
/// <summary> /// Constructs a new generic atomic operation. /// </summary> /// <param name="basicBlock">The parent basic block.</param> /// <param name="target">The target.</param> /// <param name="value">The value to store.</param> /// <param name="kind">The operation kind.</param> /// <param name="flags">The operation flags.</param> internal GenericAtomic( BasicBlock basicBlock, ValueReference target, ValueReference value, AtomicKind kind, AtomicFlags flags) : base( basicBlock, target, value, ImmutableArray <ValueReference> .Empty, flags) { Debug.Assert(value.Type == (target.Type as PointerType).ElementType); Kind = kind; }
public MemoryValue CreateAtomic( Location location, Value target, Value value, AtomicKind kind, AtomicFlags flags) { location.Assert( target.Type is PointerType type && type.ElementType == value.Type); return(Append(new GenericAtomic( GetInitializer(location), target, value, kind, flags))); }
public MemoryValue CreateAtomicCAS( Location location, Value target, Value value, Value compareValue, AtomicFlags flags) { location.Assert( target.Type is PointerType type && type.ElementType == value.Type && value.Type == compareValue.Type); return(Append(new AtomicCAS( GetInitializer(location), target, value, compareValue, flags))); }
public MemoryValue CreateAtomic( Value target, Value value, AtomicKind kind, AtomicFlags flags) { Debug.Assert(target != null, "Invalid target node"); Debug.Assert(value != null, "Invalid value node"); Debug.Assert( target.Type is PointerType type && type.ElementType == value.Type, "Incompatible pointer and element types"); return(Append(new GenericAtomic( BasicBlock, target, value, kind, flags))); }