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
  )
{
  UINT64   Data;
  BOOLEAN  Flag;
 
  Flag = FilterBeforeMsrRead (Index, &Data);
  if (Flag) {
    __asm__ __volatile__ (
      "rdmsr"
      : "=A" (Data)   // %0
      : "c"  (Index)  // %1
    );
  }
 
  FilterAfterMsrRead (Index, &Data);
 
  return Data;
}
 
UINT64
EFIAPI
AsmWriteMsr64 (
  IN      UINT32  Index,
  IN      UINT64  Value
  )
{
  BOOLEAN  Flag;
 
  Flag = FilterBeforeMsrWrite (Index, &Value);
  if (Flag) {
    __asm__ __volatile__ (
      "wrmsr"
      :
      : "c" (Index),
        "A" (Value)
    );
  }
 
  FilterAfterMsrWrite (Index, &Value);
 
  return Value;
}
 
UINTN
EFIAPI
AsmReadCr0 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%cr0,%0"
    : "=a" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadCr2 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%cr2, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadCr3 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%cr3, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadCr4 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%cr4, %0"
    : "=a" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmWriteCr0 (
  UINTN  Cr0
  )
{
  __asm__ __volatile__ (
    "movl %0, %%cr0"
    :
    : "r" (Cr0)
  );
  return Cr0;
}
 
UINTN
EFIAPI
AsmWriteCr2 (
  UINTN  Cr2
  )
{
  __asm__ __volatile__ (
    "movl %0, %%cr2"
    :
    : "r" (Cr2)
  );
  return Cr2;
}
 
UINTN
EFIAPI
AsmWriteCr3 (
  UINTN  Cr3
  )
{
  __asm__ __volatile__ (
    "movl %0, %%cr3"
    :
    : "r" (Cr3)
  );
  return Cr3;
}
 
UINTN
EFIAPI
AsmWriteCr4 (
  UINTN  Cr4
  )
{
  __asm__ __volatile__ (
    "movl %0, %%cr4"
    :
    : "r" (Cr4)
  );
  return Cr4;
}
 
UINTN
EFIAPI
AsmReadDr0 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr0, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr1 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr1, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr2 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr2, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr3 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr3, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr4 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr4, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr5 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr5, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr6 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr6, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmReadDr7 (
  VOID
  )
{
  UINTN  Data;
 
  __asm__ __volatile__ (
    "movl %%dr7, %0"
    : "=r" (Data)
  );
 
  return Data;
}
 
UINTN
EFIAPI
AsmWriteDr0 (
  UINTN  Dr0
  )
{
  __asm__ __volatile__ (
    "movl %0, %%dr0"
    :
    : "r" (Dr0)
  );
  return Dr0;
}
 
UINTN
EFIAPI
AsmWriteDr1 (
  UINTN  Dr1
  )
{
  __asm__ __volatile__ (
    "movl %0, %%dr1"
    :
    : "r" (Dr1)
  );
  return Dr1;
}
 
UINTN
EFIAPI
AsmWriteDr2 (
  UINTN  Dr2
  )
{
  __asm__ __volatile__ (
    "movl %0, %%dr2"
    :
    : "r" (Dr2)
  );
  return Dr2;
}
 
UINTN
EFIAPI
AsmWriteDr3 (
  UINTN  Dr3
  )
{
  __asm__ __volatile__ (
    "movl %0, %%dr3"
    :
    : "r" (Dr3)
  );
  return Dr3;
}
 
UINTN
EFIAPI
AsmWriteDr4 (
  UINTN  Dr4
  )
{
  __asm__ __volatile__ (
    "movl %0, %%dr4"
    :
    : "r" (Dr4)
  );
  return Dr4;
}
 
UINTN
EFIAPI
AsmWriteDr5 (
  UINTN  Dr5
  )
{
  __asm__ __volatile__ (
    "movl %0, %%dr5"
    :
    : "r" (Dr5)
  );
  return Dr5;
}
 
UINTN
EFIAPI
AsmWriteDr6 (
  UINTN  Dr6
  )
{
  __asm__ __volatile__ (
    "movl %0, %%dr6"
    :
    : "r" (Dr6)
  );
  return Dr6;
}
 
UINTN
EFIAPI
AsmWriteDr7 (
  UINTN  Dr7
  )
{
  __asm__ __volatile__ (
    "movl %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"
    : "=a" (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
  )
{
  UINT64  Data;
 
  __asm__ __volatile__ (
    "rdpmc"
    : "=A" (Data)
    : "c"  (Index)
  );
 
  return Data;
}
 
VOID
EFIAPI
AsmWbinvd (
  VOID
  )
{
  __asm__ __volatile__ ("wbinvd":::"memory");
}
 
VOID
EFIAPI
AsmInvd (
  VOID
  )
{
  __asm__ __volatile__ ("invd":::"memory");
}
 
VOID *
EFIAPI
AsmFlushCacheLine (
  IN      VOID  *LinearAddress
  )
{
  UINT32  RegEdx;
 
  //
  // If the CPU does not support CLFLUSH instruction,
  // then promote flush range to flush entire cache.
  //
  AsmCpuid (0x01, NULL, NULL, NULL, &RegEdx);
  if ((RegEdx & BIT19) == 0) {
    __asm__ __volatile__ ("wbinvd":::"memory");
    return LinearAddress;
  }
 
  __asm__ __volatile__ (
    "clflush (%0)"
    : "+a" (LinearAddress)
    :
    : "memory"
  );
 
  return LinearAddress;
}