/*

  This Source Code Form is subject to the terms of the Mozilla Public

  License, v. 2.0. If a copy of the MPL was not distributed with this

  file, You can obtain one at http://mozilla.org/MPL/2.0/.

  Copyright (C) 2010 Michael Möller <mmoeller@openhardwaremonitor.org>

*/

using System;

using System.Runtime.InteropServices;

using System.Reflection;

namespace OpenHardwareMonitor.Hardware {

  internal static class Opcode {

    private static IntPtr codeBuffer;

    private static ulong size;

    public static void Open() {  

      int p = (int)Environment.OSVersion.Platform;

      byte[] rdtscCode;

      byte[] cpuidCode;

      if (IntPtr.Size == 4) {

        rdtscCode = RDTSC_32;

        cpuidCode = CPUID_32;

      } else {

        rdtscCode = RDTSC_64;

        if ((p == 4) || (p == 128)) { // Unix

          cpuidCode = CPUID_64_LINUX;

        } else { // Windows

          cpuidCode = CPUID_64_WINDOWS;

        }

      }

      size = (ulong)(rdtscCode.Length + cpuidCode.Length);

      if ((p == 4) || (p == 128)) { // Unix   

        Assembly assembly = 

          Assembly.Load("Mono.Posix, Version=2.0.0.0, Culture=neutral, " +

          "PublicKeyToken=0738eb9f132ed756");

        Type syscall = assembly.GetType("Mono.Unix.Native.Syscall");

        MethodInfo mmap = syscall.GetMethod("mmap");

        Type mmapProts = assembly.GetType("Mono.Unix.Native.MmapProts");

        object mmapProtsParam = Enum.ToObject(mmapProts,

          (int)mmapProts.GetField("PROT_READ").GetValue(null) |

          (int)mmapProts.GetField("PROT_WRITE").GetValue(null) |

          (int)mmapProts.GetField("PROT_EXEC").GetValue(null));

        Type mmapFlags = assembly.GetType("Mono.Unix.Native.MmapFlags");

        object mmapFlagsParam = Enum.ToObject(mmapFlags,

          (int)mmapFlags.GetField("MAP_ANONYMOUS").GetValue(null) |

          (int)mmapFlags.GetField("MAP_PRIVATE").GetValue(null));

        codeBuffer = (IntPtr)mmap.Invoke(null, new object[] { IntPtr.Zero, 

          size, mmapProtsParam, mmapFlagsParam, -1, 0 });        

      } else { // Windows

        codeBuffer = NativeMethods.VirtualAlloc(IntPtr.Zero,

          (UIntPtr)size, AllocationType.COMMIT | AllocationType.RESERVE, 

          MemoryProtection.EXECUTE_READWRITE);

      }

      Marshal.Copy(rdtscCode, 0, codeBuffer, rdtscCode.Length);

      Rdtsc = Marshal.GetDelegateForFunctionPointer(

        codeBuffer, typeof(RdtscDelegate)) as RdtscDelegate;

      IntPtr cpuidAddress = (IntPtr)((long)codeBuffer + rdtscCode.Length);

      Marshal.Copy(cpuidCode, 0, cpuidAddress, cpuidCode.Length);

      Cpuid = Marshal.GetDelegateForFunctionPointer(

        cpuidAddress, typeof(CpuidDelegate)) as CpuidDelegate;         

    }

    public static void Close() {

      Rdtsc = null;

      Cpuid = null;

      int p = (int)Environment.OSVersion.Platform;

      if ((p == 4) || (p == 128)) { // Unix

        Assembly assembly =

          Assembly.Load("Mono.Posix, Version=2.0.0.0, Culture=neutral, " +

          "PublicKeyToken=0738eb9f132ed756");

        Type syscall = assembly.GetType("Mono.Unix.Native.Syscall");

        MethodInfo munmap = syscall.GetMethod("munmap");

        munmap.Invoke(null, new object[] { codeBuffer, size });

      } else { // Windows

        NativeMethods.VirtualFree(codeBuffer, UIntPtr.Zero, 

          FreeType.RELEASE);        

      }

    }

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]

    public delegate ulong RdtscDelegate();

    public static RdtscDelegate Rdtsc;

    // unsigned __int64 __stdcall rdtsc() {

    //   return __rdtsc();

    // }

    private static readonly byte[] RDTSC_32 = new byte[] {

      0x0F, 0x31,                     // rdtsc   

      0xC3                            // ret  

    };

    private static readonly byte[] RDTSC_64 = new byte[] {

      0x0F, 0x31,                     // rdtsc  

      0x48, 0xC1, 0xE2, 0x20,         // shl rdx, 20h  

      0x48, 0x0B, 0xC2,               // or rax, rdx  

      0xC3                            // ret  

    };

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]

    public delegate bool CpuidDelegate(uint index, uint ecxValue,

      out uint eax, out uint ebx, out uint ecx, out uint edx);

    public static CpuidDelegate Cpuid;

    // void __stdcall cpuidex(unsigned int index, unsigned int ecxValue, 

    //   unsigned int* eax, unsigned int* ebx, unsigned int* ecx, 

    //   unsigned int* edx)

    // {

    //   int info[4];	

    //   __cpuidex(info, index, ecxValue);

    //   *eax = info[0];

    //   *ebx = info[1];

    //   *ecx = info[2];

    //   *edx = info[3];

    // }

    private static readonly byte[] CPUID_32 = new byte[] {

      0x55,                           // push ebp  

      0x8B, 0xEC,                     // mov ebp, esp  

      0x83, 0xEC, 0x10,               // sub esp, 10h  

      0x8B, 0x45, 0x08,               // mov eax, dword ptr [ebp+8]  

      0x8B, 0x4D, 0x0C,               // mov ecx, dword ptr [ebp+0Ch]  

      0x53,                           // push ebx  

      0x0F, 0xA2,                     // cpuid  

      0x56,                           // push esi  

      0x8D, 0x75, 0xF0,               // lea esi, [info]  

      0x89, 0x06,                     // mov dword ptr [esi],eax  

      0x8B, 0x45, 0x10,               // mov eax, dword ptr [eax]  

      0x89, 0x5E, 0x04,               // mov dword ptr [esi+4], ebx  

      0x89, 0x4E, 0x08,               // mov dword ptr [esi+8], ecx  

      0x89, 0x56, 0x0C,               // mov dword ptr [esi+0Ch], edx  

      0x8B, 0x4D, 0xF0,               // mov ecx, dword ptr [info]  

      0x89, 0x08,                     // mov dword ptr [eax], ecx  

      0x8B, 0x45, 0x14,               // mov eax, dword ptr [ebx]  

      0x8B, 0x4D, 0xF4,               // mov ecx, dword ptr [ebp-0Ch]  

      0x89, 0x08,                     // mov dword ptr [eax], ecx  

      0x8B, 0x45, 0x18,               // mov eax, dword ptr [ecx]  

      0x8B, 0x4D, 0xF8,               // mov ecx, dword ptr [ebp-8]  

      0x89, 0x08,                     // mov dword ptr [eax], ecx  

      0x8B, 0x45, 0x1C,               // mov eax, dword ptr [edx]  

      0x8B, 0x4D, 0xFC,               // mov ecx, dword ptr [ebp-4]  

      0x5E,                           // pop esi  

      0x89, 0x08,                     // mov dword ptr [eax], ecx  

      0x5B,                           // pop ebx  

      0xC9,                           // leave  

      0xC2, 0x18, 0x00                // ret 18h  

    };

    private static readonly byte[] CPUID_64_WINDOWS = new byte[] {

      0x48, 0x89, 0x5C, 0x24, 0x08,   // mov qword ptr [rsp+8], rbx  

      0x8B, 0xC1,                     // mov eax, ecx  

      0x8B, 0xCA,                     // mov ecx, edx        

      0x0F, 0xA2,                     // cpuid        

      0x41, 0x89, 0x00,               // mov dword ptr [r8], eax        

      0x48, 0x8B, 0x44, 0x24, 0x28,   // mov rax, qword ptr [rsp+28h]       

      0x41, 0x89, 0x19,               // mov dword ptr [r9], ebx        

      0x48, 0x8B, 0x5C, 0x24, 0x08,   // mov rbx, qword ptr [rsp+8]      

      0x89, 0x08,                     // mov dword ptr [rax], ecx        

      0x48, 0x8B, 0x44, 0x24, 0x30,   // mov rax, qword ptr [rsp+30h]  

      0x89, 0x10,                     // mov dword ptr [rax], edx  

      0xC3                            // ret  

    };

    private static readonly byte[] CPUID_64_LINUX = new byte[] {

      0x49, 0x89, 0xD2,               // mov r10, rdx

      0x49, 0x89, 0xCB,               // mov r11, rcx

      0x53,                           // push rbx

      0x89, 0xF8,                     // mov eax, edi

      0x89, 0xF1,                     // mov ecx, esi

      0x0F, 0xA2,                     // cpuid

      0x41, 0x89, 0x02,               // mov dword ptr [r10], eax

      0x41, 0x89, 0x1B,               // mov dword ptr [r11], ebx

      0x41, 0x89, 0x08,               // mov dword ptr [r8], ecx

      0x41, 0x89, 0x11,               // mov dword ptr [r9], edx

      0x5B,                           // pop rbx

      0xC3,                           // ret

    };

    public static bool CpuidTx(uint index, uint ecxValue, 

      out uint eax, out uint ebx, out uint ecx, out uint edx, 

      ulong threadAffinityMask) {

      ulong mask = ThreadAffinity.Set(threadAffinityMask);

      if (mask == 0) {

        eax = ebx = ecx = edx = 0;

        return false;

      } 

      Cpuid(index, ecxValue, out eax, out ebx, out ecx, out edx);

      ThreadAffinity.Set(mask);      

      return true;

    }

    [Flags()]

    public enum AllocationType : uint {

      COMMIT = 0x1000,

      RESERVE = 0x2000,

      RESET = 0x80000,

      LARGE_PAGES = 0x20000000,

      PHYSICAL = 0x400000,

      TOP_DOWN = 0x100000,

      WRITE_WATCH = 0x200000

    }

    [Flags()]

    public enum MemoryProtection : uint {

      EXECUTE = 0x10,

      EXECUTE_READ = 0x20,

      EXECUTE_READWRITE = 0x40,

      EXECUTE_WRITECOPY = 0x80,

      NOACCESS = 0x01,

      READONLY = 0x02,

      READWRITE = 0x04,

      WRITECOPY = 0x08,

      GUARD = 0x100,

      NOCACHE = 0x200,

      WRITECOMBINE = 0x400

    }

    [Flags]

    public enum FreeType {

      DECOMMIT = 0x4000,

      RELEASE = 0x8000

    }

    private static class NativeMethods {      

      private const string KERNEL = "kernel32.dll";

      [DllImport(KERNEL, CallingConvention = CallingConvention.Winapi)]

      public static extern IntPtr VirtualAlloc(IntPtr lpAddress, UIntPtr dwSize,

        AllocationType flAllocationType, MemoryProtection flProtect);

      [DllImport(KERNEL, CallingConvention = CallingConvention.Winapi)]

      public static extern bool VirtualFree(IntPtr lpAddress, UIntPtr dwSize,

        FreeType dwFreeType);                 

    }

  }

}