GccInlinePriv.c

Go to the documentation of this file.

 
#include "BaseLibInternals.h"
#include <Library/RegisterFilterLib.h>
 
VOID
EFIAPI
EnableInterrupts (
  VOID
  )
{
  __asm__ __volatile__ ("sti"::: "memory");
}
 
VOID
EFIAPI
DisableInterrupts (
  VOID
  )
{
  __asm__ __volatile__ ("cli"::: "memory");
}
 
UINT64
EFIAPI
AsmReadMsr64 (
  IN      UINT32  Index
  )
{
  UINT32   LowData;
  UINT32   HighData;
  UINT64   Value;
  BOOLEAN  Flag;
 
  Flag = FilterBeforeMsrRead (Index, &Value);
  if (Flag) {
    __asm__ __volatile__ (
      "rdmsr"
      : "=a" (LowData),   // %0
        "=d" (HighData)   // %1
      : "c"  (Index)      // %2
    );
    Value = (((UINT64)HighData) << 32) | LowData;
  }
 
  FilterAfterMsrRead (Index, &Value);
 
  return Value;
}
 
UINT64
EFIAPI
AsmWriteMsr64 (
  IN      UINT32  Index,
  IN      UINT64  Value
  )
{
  UINT32   LowData;
  UINT32   HighData;
  BOOLEAN  Flag;
 
  Flag = FilterBeforeMsrWrite (Index, &Value);
  if (Flag) {
    LowData  = (UINT32)(Value);
    HighData = (UINT32)(Value >> 32);
    __asm__ __volatile__ (
      "wrmsr"
      :
      : "c" (Index),
        "a" (LowData),
        "d" (HighData)
    );
  }
 
  FilterAfterMsrWrite (Index, &Value);
 
  return Value;
}
 
UINTN
EFIAPI
AsmReadCr0 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%cr0,%0"
    : "=r" (Data)           // %0
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadCr2 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%cr2,  %0"
    : "=r" (Data)           // %0
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadCr3 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%cr3,  %0"
    : "=r" (Data)           // %0
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadCr4 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%cr4,  %0"
    : "=r" (Data)           // %0
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmWriteCr0 (
  UINTN  Cr0
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%cr0"
    :
    : "r" (Cr0)
  );
  return Cr0;
}
 
UINTN
EFIAPI
AsmWriteCr2 (
  UINTN  Cr2
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%cr2"
    :
    : "r" (Cr2)
  );
  return Cr2;
}
 
UINTN
EFIAPI
AsmWriteCr3 (
  UINTN  Cr3
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%cr3"
    :
    : "r" (Cr3)
  );
  return Cr3;
}
 
UINTN
EFIAPI
AsmWriteCr4 (
  UINTN  Cr4
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%cr4"
    :
    : "r" (Cr4)
  );
  return Cr4;
}
 
UINTN
EFIAPI
AsmReadDr0 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr0, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr1 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr1, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr2 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr2, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr3 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr3, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr4 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr4, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr5 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr5, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr6 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr6, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr7 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "mov  %%dr7, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmWriteDr0 (
  UINTN  Dr0
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr0"
    :
    : "r" (Dr0)
  );
  return Dr0;
}
 
UINTN
EFIAPI
AsmWriteDr1 (
  UINTN  Dr1
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr1"
    :
    : "r" (Dr1)
  );
  return Dr1;
}
 
UINTN
EFIAPI
AsmWriteDr2 (
  UINTN  Dr2
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr2"
    :
    : "r" (Dr2)
  );
  return Dr2;
}
 
UINTN
EFIAPI
AsmWriteDr3 (
  UINTN  Dr3
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr3"
    :
    : "r" (Dr3)
  );
  return Dr3;
}
 
UINTN
EFIAPI
AsmWriteDr4 (
  UINTN  Dr4
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr4"
    :
    : "r" (Dr4)
  );
  return Dr4;
}
 
UINTN
EFIAPI
AsmWriteDr5 (
  UINTN  Dr5
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr5"
    :
    : "r" (Dr5)
  );
  return Dr5;
}
 
UINTN
EFIAPI
AsmWriteDr6 (
  UINTN  Dr6
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr6"
    :
    : "r" (Dr6)
  );
  return Dr6;
}
 
UINTN
EFIAPI
AsmWriteDr7 (
  UINTN  Dr7
  )
{
  __asm__ __volatile__ (
    "mov  %0, %%dr7"
    :
    : "r" (Dr7)
  );
  return Dr7;
}
 
UINT16
EFIAPI
AsmReadCs (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "mov   %%cs, %0"
    :"=a" (Data)
  );
 
  return Data;
}
 
UINT16
EFIAPI
AsmReadDs (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "mov  %%ds, %0"
    :"=a" (Data)
  );
 
  return Data;
}
 
UINT16
EFIAPI
AsmReadEs (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "mov  %%es, %0"
    :"=a" (Data)
  );
 
  return Data;
}
 
UINT16
EFIAPI
AsmReadFs (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "mov  %%fs, %0"
    :"=a" (Data)
  );
 
  return Data;
}
 
UINT16
EFIAPI
AsmReadGs (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "mov  %%gs, %0"
    :"=a" (Data)
  );
 
  return Data;
}
 
UINT16
EFIAPI
AsmReadSs (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "mov  %%ss, %0"
    :"=a" (Data)
  );
 
  return Data;
}
 
UINT16
EFIAPI
AsmReadTr (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "str  %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
VOID
EFIAPI
InternalX86ReadGdtr (
  OUT     IA32_DESCRIPTOR  *Gdtr
  )
{
  __asm__ __volatile__ (
    "sgdt %0"
    : "=m" (*Gdtr)
  );
}
 
VOID
EFIAPI
InternalX86WriteGdtr (
  IN      CONST IA32_DESCRIPTOR  *Gdtr
  )
{
  __asm__ __volatile__ (
    "lgdt %0"
    :
    : "m" (*Gdtr)
  );
}
 
VOID
EFIAPI
InternalX86ReadIdtr (
  OUT     IA32_DESCRIPTOR  *Idtr
  )
{
  __asm__ __volatile__ (
    "sidt  %0"
    : "=m" (*Idtr)
  );
}
 
VOID
EFIAPI
InternalX86WriteIdtr (
  IN      CONST IA32_DESCRIPTOR  *Idtr
  )
{
  __asm__ __volatile__ (
    "lidt %0"
    :
    : "m" (*Idtr)
  );
}
 
UINT16
EFIAPI
AsmReadLdtr (
  VOID
  )
{
  UINT16  Data;
 
  __asm__ __volatile__ (
    "sldt  %0"
    : "=g" (Data)   // %0
  );
 
  return Data;
}
 
VOID
EFIAPI
AsmWriteLdtr (
  IN      UINT16  Ldtr
  )
{
  __asm__ __volatile__ (
    "lldtw  %0"
    :
    : "g" (Ldtr)   // %0
  );
}
 
UINT64
EFIAPI
AsmReadPmc (
  IN      UINT32  Index
  )
{
  UINT32  LowData;
  UINT32  HiData;
 
  __asm__ __volatile__ (
    "rdpmc"
    : "=a" (LowData),
      "=d" (HiData)
    : "c"  (Index)
  );
 
  return (((UINT64)HiData) << 32) | LowData;
}
 
UINTN
EFIAPI
AsmMonitor (
  IN      UINTN  Eax,
  IN      UINTN  Ecx,
  IN      UINTN  Edx
  )
{
  __asm__ __volatile__ (
    "monitor"
    :
    : "a" (Eax),
      "c" (Ecx),
      "d" (Edx)
  );
 
  return Eax;
}
 
UINTN
EFIAPI
AsmMwait (
  IN      UINTN  Eax,
  IN      UINTN  Ecx
  )
{
  __asm__ __volatile__ (
    "mwait"
    :
    : "a"  (Eax),
      "c"  (Ecx)
  );
 
  return Eax;
}
 
VOID
EFIAPI
AsmWbinvd (
  VOID
  )
{
  __asm__ __volatile__ ("wbinvd":::"memory");
}
 
VOID
EFIAPI
AsmInvd (
  VOID
  )
{
  __asm__ __volatile__ ("invd":::"memory");
}
 
VOID *
EFIAPI
AsmFlushCacheLine (
  IN      VOID  *LinearAddress
  )
{
  __asm__ __volatile__ (
    "clflush (%0)"
    :
    : "r" (LinearAddress)
    : "memory"
  );
 
  return LinearAddress;
}