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)));
}
