/// Creates a mock context from a given Lambda handler and event
public MockLambdaContext(string handler, string eventBody)
{
RequestId = Guid.NewGuid().ToString();
StartTime = DateTime.Now;
InputStream = new MemoryStream();
var eventData = Encoding.UTF8.GetBytes(eventBody);
InputStream.Write(eventData, 0, eventData.Length);
InputStream.Position = 0;
Environment.SetEnvironmentVariable("AWS_LAMBDA_FUNCTION_NAME", FunctionName);
Environment.SetEnvironmentVariable("AWS_LAMBDA_FUNCTION_VERSION", FunctionVersion);
Environment.SetEnvironmentVariable("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", MemorySize.ToString());
Environment.SetEnvironmentVariable("AWS_LAMBDA_LOG_GROUP_NAME", LogGroup);
Environment.SetEnvironmentVariable("AWS_LAMBDA_LOG_STREAM_NAME", LogStream);
Environment.SetEnvironmentVariable("AWS_REGION", Region);
Environment.SetEnvironmentVariable("AWS_DEFAULT_REGION", Region);
Environment.SetEnvironmentVariable("_HANDLER", handler);
}
void WriteMemorySize(MemorySize memorySize)
{
if (codeMemorySize is object)
{
sb.Append(codeMemorySize);
}
else
{
int memSize = GetSizeInBytes(memorySize);
if (memSize != 0)
{
sb.Append(memSize * 8);
}
}
if (codeMemorySizeSuffix is object)
{
sb.Append(codeMemorySizeSuffix);
}
}
void VerifyMemorySizeProperties(MemorySize memorySize, int size, int elementSize, MemorySize elementType, int elementCount, MemorySizeFlags flags)
{
var info = memorySize.GetInfo();
Assert.Equal(memorySize, info.MemorySize);
Assert.Equal(size, info.Size);
Assert.Equal(elementSize, info.ElementSize);
Assert.Equal(elementType, info.ElementType);
Assert.Equal((flags & MemorySizeFlags.Signed) != 0, info.IsSigned);
Assert.Equal((flags & MemorySizeFlags.Broadcast) != 0, info.IsBroadcast);
Assert.Equal((flags & MemorySizeFlags.Packed) != 0, info.IsPacked);
Assert.Equal(elementCount, info.ElementCount);
Assert.Equal(size, memorySize.GetSize());
Assert.Equal(elementSize, memorySize.GetElementSize());
Assert.Equal(elementType, memorySize.GetElementType());
Assert.Equal((flags & MemorySizeFlags.Signed) != 0, memorySize.IsSigned());
Assert.Equal((flags & MemorySizeFlags.Packed) != 0, memorySize.IsPacked());
Assert.Equal((flags & MemorySizeFlags.Broadcast) != 0, memorySize.IsBroadcast());
Assert.Equal(elementCount, memorySize.GetElementCount());
}
void Test32_Prefetch_M_1(string hexBytes, int byteLength, Code code, MemorySize memSize)
{
var decoder = CreateDecoder32(hexBytes);
var instr = decoder.Decode();
Assert.Equal(code, instr.Code);
Assert.Equal(1, instr.OpCount);
Assert.Equal(byteLength, instr.ByteLength);
Assert.False(instr.HasPrefixRepe);
Assert.False(instr.HasPrefixRepne);
Assert.False(instr.HasPrefixLock);
Assert.Equal(Register.None, instr.PrefixSegment);
Assert.Equal(OpKind.Memory, instr.Op0Kind);
Assert.Equal(Register.DS, instr.MemorySegment);
Assert.Equal(Register.EAX, instr.MemoryBase);
Assert.Equal(Register.None, instr.MemoryIndex);
Assert.Equal(0U, instr.MemoryDisplacement);
Assert.Equal(1, instr.MemoryIndexScale);
Assert.Equal(memSize, instr.MemorySize);
Assert.Equal(0, instr.MemoryDisplSize);
}
private static int HandleFileCheck(FileCheckOptions options)
{
_logger.Info($"Starting to check file '{options.FileName}' for lines order...");
try
{
var fileBufferSize = (int)MemorySize.Parse(options.FileBuffer);
var streamBufferSize = (int)MemorySize.Parse(options.StreamBuffer);
var fileCheck = new FileCheck(fileBufferSize, streamBufferSize, options.OnlyCheckFormat);
var checkResult = fileCheck.Check(options.FileName);
_logger.Info($"File '{options.FileName}' has been successfully checked for lines order.");
return(checkResult ? 0 : 1);
}
catch (Exception ex)
{
_logger.Error($"Failed to parse file '{options.FileName}' for sorted lines.", ex);
return(-1);
}
}
public static void InitializeResourceLimit(KResourceLimit resourceLimit, MemorySize size)
{
void EnsureSuccess(KernelResult result)
{
if (result != KernelResult.Success)
{
throw new InvalidOperationException($"Unexpected result \"{result}\".");
}
}
ulong ramSize = KSystemControl.GetDramSize(size);
EnsureSuccess(resourceLimit.SetLimitValue(LimitableResource.Memory, (long)ramSize));
EnsureSuccess(resourceLimit.SetLimitValue(LimitableResource.Thread, 800));
EnsureSuccess(resourceLimit.SetLimitValue(LimitableResource.Event, 700));
EnsureSuccess(resourceLimit.SetLimitValue(LimitableResource.TransferMemory, 200));
EnsureSuccess(resourceLimit.SetLimitValue(LimitableResource.Session, 900));
if (!resourceLimit.Reserve(LimitableResource.Memory, 0) ||
!resourceLimit.Reserve(LimitableResource.Memory, 0x60000))
{
throw new InvalidOperationException("Unexpected failure reserving memory on resource limit.");
}
}
public Info(MemorySize memorySize, string[] names, string bcstTo)
{
this.memorySize = memorySize;
this.names = names;
this.bcstTo = bcstTo;
}
public static MemorySize operator *(MemorySize memorySize, ItemCount count)
{
var newSize = new MemorySize(memorySize.SizeInBits * count.Count);
return(newSize);
}
public MifareClassic(MemorySize memorySize, byte[] authentificationKey, KeyType authentificationKeyType)
{
this.memorySize = memorySize;
this.authentificationKey = authentificationKey;
this.authentificationKeyType = authentificationKeyType;
}
void Test16_Cmov_GVEV_1(string hexBytes, int byteLength, Code code, Register reg1, MemorySize memSize)
{
var decoder = CreateDecoder16(hexBytes);
var instr = decoder.Decode();
Assert.Equal(code, instr.Code);
Assert.Equal(2, instr.OpCount);
Assert.Equal(byteLength, instr.ByteLength);
Assert.False(instr.HasPrefixRepe);
Assert.False(instr.HasPrefixRepne);
Assert.False(instr.HasPrefixLock);
Assert.Equal(Register.None, instr.PrefixSegment);
Assert.Equal(OpKind.Register, instr.Op0Kind);
Assert.Equal(reg1, instr.Op0Register);
Assert.Equal(OpKind.Memory, instr.Op1Kind);
Assert.Equal(Register.DS, instr.MemorySegment);
Assert.Equal(Register.BX, instr.MemoryBase);
Assert.Equal(Register.SI, instr.MemoryIndex);
Assert.Equal(0U, instr.MemoryDisplacement);
Assert.Equal(1, instr.MemoryIndexScale);
Assert.Equal(memSize, instr.MemorySize);
Assert.Equal(0, instr.MemoryDisplSize);
}
public MifareClassic(MemorySize memorySize)
: this(memorySize, new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, KeyType.B)
{
}
MvexLutData(TupleType tupleType, MvexConvDecorator decorator, MemorySize memorySize)
{
TupleType = tupleType;
Decorator = decorator;
MemorySize = memorySize;
}
void Test32_AesV_VX_WX_Ib_1(string hexBytes, int byteLength, Code code, Register reg, MemorySize memSize, byte immediate8)
{
var decoder = CreateDecoder32(hexBytes);
var instr = decoder.Decode();
Assert.Equal(code, instr.Code);
Assert.Equal(3, instr.OpCount);
Assert.Equal(byteLength, instr.ByteLength);
Assert.False(instr.HasPrefixRepe);
Assert.False(instr.HasPrefixRepne);
Assert.False(instr.HasPrefixLock);
Assert.Equal(Register.None, instr.PrefixSegment);
Assert.Equal(OpKind.Register, instr.Op0Kind);
Assert.Equal(reg, instr.Op0Register);
Assert.Equal(OpKind.Memory, instr.Op1Kind);
Assert.Equal(Register.DS, instr.MemorySegment);
Assert.Equal(Register.EAX, instr.MemoryBase);
Assert.Equal(Register.None, instr.MemoryIndex);
Assert.Equal(0U, instr.MemoryDisplacement);
Assert.Equal(1, instr.MemoryIndexScale);
Assert.Equal(memSize, instr.MemorySize);
Assert.Equal(0, instr.MemoryDisplSize);
Assert.Equal(OpKind.Immediate8, instr.Op2Kind);
Assert.Equal(immediate8, instr.Immediate8);
}
void Test64_VpmultishiftqbV_VX_k1_HX_WX_1(string hexBytes, int byteLength, Code code, Register reg1, Register reg2, Register kreg, MemorySize memSize, uint displ, bool z)
{
var decoder = CreateDecoder64(hexBytes);
var instr = decoder.Decode();
Assert.Equal(code, instr.Code);
Assert.Equal(3, instr.OpCount);
Assert.Equal(byteLength, instr.ByteLength);
Assert.False(instr.HasRepePrefix);
Assert.False(instr.HasRepnePrefix);
Assert.False(instr.HasLockPrefix);
Assert.Equal(Register.None, instr.SegmentPrefix);
Assert.Equal(OpKind.Register, instr.Op0Kind);
Assert.Equal(reg1, instr.Op0Register);
Assert.Equal(OpKind.Register, instr.Op1Kind);
Assert.Equal(reg2, instr.Op1Register);
Assert.Equal(OpKind.Memory, instr.Op2Kind);
Assert.Equal(Register.DS, instr.MemorySegment);
Assert.Equal(Register.RAX, instr.MemoryBase);
Assert.Equal(Register.None, instr.MemoryIndex);
Assert.Equal(displ, instr.MemoryDisplacement);
Assert.Equal(1, instr.MemoryIndexScale);
Assert.Equal(memSize, instr.MemorySize);
Assert.Equal(1, instr.MemoryDisplSize);
Assert.Equal(kreg, instr.OpMask);
Assert.Equal(z, instr.ZeroingMasking);
Assert.Equal(RoundingControl.None, instr.RoundingControl);
Assert.False(instr.SuppressAllExceptions);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="segReg">Effective segment register or <see cref="Register.None"/> if the segment register is ignored</param>
/// <param name="baseReg">Base register</param>
/// <param name="indexReg">Index register</param>
/// <param name="scale">1, 2, 4 or 8</param>
/// <param name="displ">Displacement</param>
/// <param name="memorySize">Memory size</param>
/// <param name="access">Access</param>
/// <param name="addressSize">Address size</param>
/// <param name="vsibSize">VSIB size (<c>0</c>, <c>4</c> or <c>8</c>)</param>
public UsedMemory(Register segReg, Register baseReg, Register indexReg, int scale, ulong displ, MemorySize memorySize, OpAccess access, CodeSize addressSize, int vsibSize)
{
this.displ = displ;
Debug.Assert((uint)segReg <= byte.MaxValue);
this.segReg = (byte)segReg;
Debug.Assert((uint)baseReg <= byte.MaxValue);
this.baseReg = (byte)baseReg;
Debug.Assert((uint)indexReg <= byte.MaxValue);
this.indexReg = (byte)indexReg;
Debug.Assert((uint)memorySize <= byte.MaxValue);
this.memorySize = (byte)memorySize;
Debug.Assert(scale == 1 || scale == 2 || scale == 4 || scale == 8);
this.scale = (byte)scale;
Debug.Assert((uint)access <= byte.MaxValue);
this.access = (byte)access;
Debug.Assert((uint)addressSize <= byte.MaxValue);
this.addressSize = (byte)addressSize;
Debug.Assert(vsibSize == 0 || vsibSize == 4 || vsibSize == 8);
this.vsibSize = (byte)vsibSize;
}
/// <summary>
/// Read data from main memory
/// </summary>
/// <param name="address">address to read</param>
/// <param name="ms">size to read</param>
/// <returns>read value</returns>
uint IARMHost.GetMemory(uint address, MemorySize ms)
{
return(_simulatorInterface.MainMemory.GetMemory(address, ms));
}
public KMemoryManager(MemorySize size, MemoryArrange arrange)
{
MemoryRegions = KernelInit.GetMemoryRegions(size, arrange);
}
int GetSizeInBytes(MemorySize memSize) => (int)memSizeTbl.Defs[(int)memSize].Size;
/// <summary>
/// MemoryAccessReadEventArgs ctor
/// </summary>
/// <param name="address">address being read</param>
/// <param name="size">read size</param>
public MemoryAccessReadEventArgs(uint address, MemorySize size)
{
Address = address;
Size = size;
}
/// <summary>
/// MemoryAccessWriteArgs ctor
/// </summary>
/// <param name="address">address being written</param>
/// <param name="size">memory size</param>
/// <param name="value">data value being written</param>
public MemoryAccessWriteEventArgs(uint address, MemorySize size, uint value)
: base(address, size)
{
Value = value;
}
/// <summary>
/// Write data to main memory
/// </summary>
/// <param name="address">address to read</param>
/// <param name="ms">size to read</param>
/// <param name="data">data to write</param>
void IARMHost.SetMemory(uint address, MemorySize ms, uint data)
{
_simulatorInterface.MainMemory.SetMemory(address, ms, data);
}
void Verify_FirstBroadcastMemorySize_value(MemorySize memorySize)
{
Assert.Equal(memorySize.IsBroadcast(), memorySize.GetInfo().IsBroadcast);
}
/// <summary> /// Checks if <paramref name="memorySize"/> is a broadcast memory type /// </summary> /// <param name="memorySize">Memory size</param> /// <returns></returns> public static bool IsBroadcast(this MemorySize memorySize) => memorySize >= FirstBroadcastMemorySize;
/// <summary> /// Gets the size in bytes of the memory location or 0 if it's not accessed by the instruction or unknown or variable sized /// </summary> /// <param name="memorySize">Memory size</param> /// <returns></returns> public static int GetSize(this MemorySize memorySize) => memorySize.GetInfo().Size;
/// <summary>
/// Constructor
/// </summary>
/// <param name="segReg">Effective segment register or <see cref="Register.None"/> if the segment register is ignored</param>
/// <param name="baseReg">Base register</param>
/// <param name="indexReg">Index register</param>
/// <param name="scale">1, 2, 4 or 8</param>
/// <param name="displ">Displacement</param>
/// <param name="memorySize">Memory size</param>
/// <param name="access">Access</param>
public UsedMemory(Register segReg, Register baseReg, Register indexReg, int scale, long displ, MemorySize memorySize, OpAccess access)
{
this.displ = (ulong)displ;
Debug.Assert((uint)segReg <= byte.MaxValue);
this.segReg = (byte)segReg;
Debug.Assert((uint)baseReg <= byte.MaxValue);
this.baseReg = (byte)baseReg;
Debug.Assert((uint)indexReg <= byte.MaxValue);
this.indexReg = (byte)indexReg;
Debug.Assert((uint)memorySize <= byte.MaxValue);
this.memorySize = (byte)memorySize;
Debug.Assert(scale == 1 || scale == 2 || scale == 4 || scale == 8);
this.scale = (byte)scale;
Debug.Assert((uint)access <= byte.MaxValue);
this.access = (byte)access;
addressSize = (byte)CodeSize.Unknown;
vsibSize = 0;
}
/// <summary> /// Gets the element type info if it's packed data or <paramref name="memorySize"/> if it's not packed data /// </summary> /// <param name="memorySize">Memory size</param> /// <returns></returns> public static MemorySizeInfo GetElementTypeInfo(this MemorySize memorySize) => memorySize.GetInfo().ElementType.GetInfo();
void WriteMemorySize(MemorySize memorySize)
{
switch (opCode.Code)
{
case Code.Fldcw_m16:
case Code.Fnstcw_m16:
case Code.Fstcw_m16:
case Code.Fnstsw_m16:
case Code.Fstsw_m16:
sb.Append("2byte");
return;
}
switch (memorySize)
{
case MemorySize.Bound16_WordWord:
sb.Append("16&16");
break;
case MemorySize.Bound32_DwordDword:
sb.Append("32&32");
break;
case MemorySize.FpuEnv14:
sb.Append("14byte");
break;
case MemorySize.FpuEnv28:
sb.Append("28byte");
break;
case MemorySize.FpuState94:
sb.Append("94byte");
break;
case MemorySize.FpuState108:
sb.Append("108byte");
break;
case MemorySize.Fxsave_512Byte:
case MemorySize.Fxsave64_512Byte:
sb.Append("512byte");
break;
case MemorySize.Xsave:
case MemorySize.Xsave64:
// 'm' has already been appended
sb.Append("em");
break;
case MemorySize.SegPtr16:
sb.Append("16:16");
break;
case MemorySize.SegPtr32:
sb.Append("16:32");
break;
case MemorySize.SegPtr64:
sb.Append("16:64");
break;
case MemorySize.Fword5:
if (!IsSgdtOrSidt())
{
sb.Append("16&24");
}
break;
case MemorySize.Fword6:
if (!IsSgdtOrSidt())
{
sb.Append("16&32");
}
break;
case MemorySize.Fword10:
if (!IsSgdtOrSidt())
{
sb.Append("16&64");
}
break;
default:
int memSize = memorySize.GetSize();
if (memSize != 0)
{
sb.Append(memSize * 8);
}
break;
}
if (IsFpuInstruction(opCode.Code))
{
switch (memorySize)
{
case MemorySize.Int16:
case MemorySize.Int32:
case MemorySize.Int64:
sb.Append("int");
break;
case MemorySize.Float32:
case MemorySize.Float64:
case MemorySize.Float80:
sb.Append("fp");
break;
case MemorySize.Bcd:
sb.Append("bcd");
break;
}
}
}
/// <summary> /// <see langword="true"/> if this is a packed data type, eg. <see cref="MemorySize.Packed128_Float32"/> /// </summary> /// <param name="memorySize">Memory size</param> /// <returns></returns> public static bool IsPacked(this MemorySize memorySize) => memorySize.GetInfo().IsPacked;
public static bool TryMemorySize(string value, out MemorySize memorySize) => memorySizeDict.TryGetValue(value, out memorySize);
/// <summary> /// Gets the number of elements in the packed data type or 1 if it's not packed data (<see cref="IsPacked"/>) /// </summary> /// <param name="memorySize">Memory size</param> /// <returns></returns> public static int GetElementCount(this MemorySize memorySize) => memorySize.GetInfo().ElementCount;
void Test64_D3NOW_1(string hexBytes, int byteLength, Code code, Register reg, MemorySize memSize)
{
var decoder = CreateDecoder64(hexBytes);
var instr = decoder.Decode();
Assert.Equal(code, instr.Code);
Assert.Equal(2, instr.OpCount);
Assert.Equal(byteLength, instr.ByteLength);
Assert.False(instr.HasPrefixRepe);
Assert.False(instr.HasPrefixRepne);
Assert.False(instr.HasPrefixLock);
Assert.Equal(Register.None, instr.PrefixSegment);
Assert.Equal(OpKind.Register, instr.Op0Kind);
Assert.Equal(reg, instr.Op0Register);
Assert.Equal(OpKind.Memory, instr.Op1Kind);
Assert.Equal(Register.DS, instr.MemorySegment);
Assert.Equal(Register.RAX, instr.MemoryBase);
Assert.Equal(Register.None, instr.MemoryIndex);
Assert.Equal(0xA55A1234, instr.MemoryDisplacement);
Assert.Equal(1, instr.MemoryIndexScale);
Assert.Equal(memSize, instr.MemorySize);
Assert.Equal(8, instr.MemoryDisplSize);
}
/// <summary> /// Checks if <paramref name="memorySize"/> is a broadcast memory type /// </summary> /// <param name="memorySize">Memory size</param> /// <returns></returns> public static bool IsBroadcast(this MemorySize memorySize) => memorySize >= IcedConstants.FirstBroadcastMemorySize;
