/// <summary>
/// Initializes a new instance of the <see cref="Neg"/> class.
/// </summary>
/// <param name="value">The value.</param>
public Neg(EffectiveAddress value)
: this((Operand)value)
{
#region Contract
Contract.Requires<ArgumentNullException>(value != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Inc"/> class.
/// </summary>
/// <param name="subject">The subject memory operand.</param>
public Inc(EffectiveAddress subject)
: this((Operand)subject)
{
#region Contract
Contract.Requires<ArgumentNullException>(subject != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Mul"/> class.
/// </summary>
/// <param name="multiplier">The multiplier.</param>
public Mul(EffectiveAddress multiplier)
: this((Operand)multiplier)
{
#region Contract
Contract.Requires<ArgumentNullException>(multiplier != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="JmpFar"/> class.
/// </summary>
/// <param name="target">The memory location containing the new far jump target address and segment.</param>
public JmpFar(EffectiveAddress target)
: this((Operand)target)
{
#region Contract
Contract.Requires<ArgumentNullException>(target != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Xadd"/> class.
/// </summary>
/// <param name="destination">The destination memory operand.</param>
/// <param name="source">The source immediate register operand.</param>
public Xadd(EffectiveAddress destination, RegisterOperand source)
: this((Operand)destination, source)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Movsxd"/> class.
/// </summary>
/// <param name="destination">The destination register.</param>
/// <param name="source">The source memory operand.</param>
public Movsxd(RegisterOperand destination, EffectiveAddress source)
: this(destination, (Operand)source)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Btc"/> class.
/// </summary>
/// <param name="subject">The memory operand whose bit is copied and toggled.</param>
/// <param name="bitIndex">The index of the bit to copy.</param>
public Btc(EffectiveAddress subject, RegisterOperand bitIndex)
: this((Operand)subject, (Operand)bitIndex)
{
#region Contract
Contract.Requires<ArgumentNullException>(subject != null);
Contract.Requires<ArgumentNullException>(bitIndex != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="ArithmeticInstruction"/> class.
/// </summary>
/// <param name="destination">The destination memory operand.</param>
/// <param name="source">The source immediate operand.</param>
protected ArithmeticInstruction(EffectiveAddress destination, Immediate source)
: this((IRegisterOrMemoryOperand)destination, (ISourceOperand)source)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Cmpxchg8b"/> class.
/// </summary>
/// <param name="destination">The operand being compared and written to.</param>
public Cmpxchg8b(EffectiveAddress destination)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
#endregion
this.destination = destination;
}
/// <summary>
/// Initializes a new instance of the <see cref="Clflush"/> class.
/// </summary>
/// <param name="address">The linear address to flush.</param>
public Clflush(EffectiveAddress address)
{
#region Contract
Contract.Requires<ArgumentNullException>(address != null);
#endregion
this.address = address;
}
/// <summary>
/// Initializes a new instance of the <see cref="Popcnt"/> class.
/// </summary>
/// <param name="destination">The register in which the bit's index will be stored.</param>
/// <param name="subject">The memory operand which is checked.</param>
public Popcnt(RegisterOperand destination, EffectiveAddress subject)
: this(destination, (Operand)subject)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentNullException>(subject != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Cmpxchg"/> class.
/// </summary>
/// <param name="compared">The memory operand being compared.</param>
/// <param name="source">The source operand.</param>
public Cmpxchg(EffectiveAddress compared, RegisterOperand source)
: this((Operand)compared, source)
{
#region Contract
Contract.Requires<ArgumentNullException>(compared != null);
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Lea"/> class.
/// </summary>
/// <param name="destination">The destination register operand.</param>
/// <param name="address">The address.</param>
public Lea(RegisterOperand destination, EffectiveAddress address)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentNullException>(address != null);
#endregion
this.destination = destination;
this.address = address;
}
/// <summary>
/// Initializes a new instance of the <see cref="Bound"/> class.
/// </summary>
/// <param name="index">The array index to check.</param>
/// <param name="bounds">Memory address of two (double)words specifying the lower and upper limits of the
/// array.</param>
public Bound(RegisterOperand index, EffectiveAddress bounds)
{
#region Contract
Contract.Requires<ArgumentNullException>(index != null);
Contract.Requires<ArgumentNullException>(bounds != null);
#endregion
this.index = index;
this.bounds = bounds;
}
/// <summary>
/// Initializes a new instance of the <see cref="Lds"/> class.
/// </summary>
/// <param name="destination">The destination operand.</param>
/// <param name="source">The source operand.</param>
public Lds(RegisterOperand destination, EffectiveAddress source)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentNullException>(source != null);
#endregion
this.destination = destination;
this.source = source;
}
/// <summary>
/// Initializes a new instance of the <see cref="Prefetchl"/> class.
/// </summary>
/// <param name="address">The address to prefetch.</param>
/// <param name="level">The prefetch level.</param>
public Prefetchl(EffectiveAddress address, PrefetchLevel level)
{
#region Contract
Contract.Requires<ArgumentNullException>(address != null);
Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(PrefetchLevel), level));
Contract.Requires<ArgumentException>(level != PrefetchLevel.None);
#endregion
this.address = address;
this.level = level;
}
/// <summary>
/// Initializes a new instance of the <see cref="Imul"/> class.
/// </summary>
/// <param name="destination">The destination operand.</param>
/// <param name="source">The source operand.</param>
/// <param name="multiplier">The multiplier.</param>
public Imul(RegisterOperand destination, EffectiveAddress source, Immediate multiplier)
: this(destination, (Operand)source, (Operand)multiplier)
{
#region Contract
Contract.Requires<ArgumentNullException>(multiplier != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Adc"/> class.
/// </summary>
/// <param name="destination">The destination register operand.</param>
/// <param name="source">The source register or memory operand.</param>
public Adc(RegisterOperand destination, EffectiveAddress source)
: base(destination, source)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentException>(destination.Register.IsGeneralPurposeRegister());
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Bound"/> class.
/// </summary>
/// <param name="index">The array index to check.</param>
/// <param name="bounds">Memory address of two (double)words specifying the lower and upper limits of the
/// array.</param>
public Bound(RegisterOperand index, EffectiveAddress bounds)
{
this.index = index;
this.bounds = bounds;
}
/// <summary>
/// Initializes a new instance of the <see cref="Set"/> class.
/// </summary>
/// <param name="destination">The destination memory operand.</param>
/// <param name="condition">The condition on which this instruction executes.</param>
public Set(EffectiveAddress destination, InstructionCondition condition)
: this((Operand)destination, condition)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(InstructionCondition), condition));
Contract.Requires<ArgumentException>(condition != InstructionCondition.None);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Bt"/> class.
/// </summary>
/// <param name="subject">The memory operand whose bit is copied.</param>
/// <param name="bitindex">The index of the bit to copy.</param>
public Bt(EffectiveAddress subject, Immediate bitindex)
: this((Operand)subject, (Operand)bitindex)
{
#region Contract
Contract.Requires<ArgumentNullException>(subject != null);
Contract.Requires<ArgumentNullException>(bitindex != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="ArithmeticInstruction"/> class.
/// </summary>
/// <param name="destination">The destination register operand.</param>
/// <param name="source">The source register or memory operand.</param>
protected ArithmeticInstruction(RegisterOperand destination, EffectiveAddress source)
: this((IRegisterOrMemoryOperand)destination, (ISourceOperand)source)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Push"/> class.
/// </summary>
/// <param name="source">The source memory operand.</param>
public Push(EffectiveAddress source)
: this((Operand)source)
{
#region Contract
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Xchg"/> class.
/// </summary>
/// <param name="first">The first operand.</param>
/// <param name="second">The second operand.</param>
public Xchg(EffectiveAddress first, RegisterOperand second)
: this((Operand)first, second)
{
#region Contract
Contract.Requires<ArgumentNullException>(first != null);
Contract.Requires<ArgumentNullException>(second != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Imul"/> class.
/// </summary>
/// <param name="value">The destination and source operand.</param>
/// <param name="multiplier">The multiplier.</param>
public Imul(RegisterOperand value, EffectiveAddress multiplier)
: this(value, null, (Operand)multiplier)
{
#region Contract
Contract.Requires<ArgumentNullException>(multiplier != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Shr"/> class.
/// </summary>
/// <param name="value">The value to change.</param>
/// <param name="positions">The number of positions to adjust.</param>
public Shr(EffectiveAddress value, Immediate positions)
: this((Operand)value, (Operand)positions)
{
#region Contract
Contract.Requires<ArgumentNullException>(value != null);
Contract.Requires<ArgumentNullException>(positions != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Pop"/> class.
/// </summary>
/// <param name="destination">The destination memory operand.</param>
public Pop(EffectiveAddress destination)
: this((Operand)destination)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Shrd"/> class.
/// </summary>
/// <param name="value">The value to shift.</param>
/// <param name="source">The bits to shift in.</param>
/// <param name="positions">The register with number of positions to adjust.
/// May only be the CL register; or <see langword="null"/> to use the CL register.</param>
public Shrd(EffectiveAddress value, RegisterOperand source, RegisterOperand positions = null)
: this((Operand)value, source, (Operand)positions)
{
#region Contract
Contract.Requires<ArgumentNullException>(value != null);
Contract.Requires<ArgumentNullException>(source != null);
Contract.Requires<ArgumentNullException>(positions != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Sbb"/> class.
/// </summary>
/// <param name="destination">The destination memory operand.</param>
/// <param name="source">The source immediate value.</param>
public Sbb(EffectiveAddress destination, Immediate source)
: this((Operand)destination, (Operand)source)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="ArithmeticInstruction"/> class.
/// </summary>
/// <param name="destination">The destination register operand.</param>
/// <param name="source">The source register or memory operand.</param>
protected ArithmeticInstruction(RegisterOperand destination, EffectiveAddress source)
: this((IRegisterOrMemoryOperand)destination, (ISourceOperand)source)
{
#region Contract
Contract.Requires<ArgumentNullException>(destination != null);
Contract.Requires<ArgumentException>(destination.Register.IsGeneralPurposeRegister());
Contract.Requires<ArgumentNullException>(source != null);
#endregion
}
