1                 : /*
       2                 :  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
       3                 :  * Use of this source code is governed by a BSD-style license that can be
       4                 :  * found in the LICENSE file.
       5                 :  */
       6                 : 
       7                 : /*
       8                 :  * NaCl Runtime.
       9                 :  */
      10                 : 
      11                 : #include <stdint.h>
      12                 : 
      13                 : #include "native_client/src/trusted/service_runtime/arch/x86/sel_rt.h"
      14                 : #include "native_client/src/trusted/service_runtime/sel_util.h"
      15                 : 
      16                 : uint16_t NaClGetCs(void) {
      17               0 :   uint16_t seg1;
      18                 : 
      19               0 :   __asm__("mov %%cs, %0;" : "=r" (seg1) : );
      20               0 :   return seg1;
      21                 : }
      22                 : 
      23                 : /* NOTE: there is no SetCS -- this is done via far jumps/calls */
      24                 : 
      25                 : 
      26                 : uint16_t NaClGetDs(void) {
      27               0 :   uint16_t seg1;
      28                 : 
      29               0 :   __asm__("mov %%ds, %0" : "=r" (seg1) : );
      30               0 :   return seg1;
      31                 : }
      32                 : 
      33                 : 
      34               0 : void NaClSetDs(uint16_t   seg1) {
      35               0 :   __asm__("movw %0, %%ds;" : : "r" (seg1));
      36               0 : }
      37                 : 
      38                 : 
      39                 : uint16_t NaClGetEs(void) {
      40               0 :   uint16_t seg1;
      41                 : 
      42               0 :   __asm__("mov %%es, %0" : "=r" (seg1) : );
      43               0 :   return seg1;
      44                 : }
      45                 : 
      46                 : 
      47               0 : void NaClSetEs(uint16_t   seg1) {
      48               0 :   __asm__("movw %0, %%es;" : : "r" (seg1));
      49               0 : }
      50                 : 
      51                 : 
      52                 : uint16_t NaClGetFs(void) {
      53               0 :   uint16_t seg1;
      54                 : 
      55               0 :   __asm__("mov %%fs, %0" : "=r" (seg1) : );
      56               0 :   return seg1;
      57                 : }
      58                 : 
      59                 : 
      60               0 : void NaClSetFs(uint16_t seg1) {
      61               0 :   __asm__("movw %0, %%fs;" : : "r" (seg1));
      62               0 : }
      63                 : 
      64                 : 
      65                 : uint16_t NaClGetGs(void) {
      66               0 :   uint16_t seg1;
      67                 : 
      68               0 :   __asm__("mov %%gs, %0" : "=r" (seg1) : );
      69               0 :   return seg1;
      70                 : }
      71                 : 
      72                 : 
      73               0 : void NaClSetGs(uint16_t seg1) {
      74               0 :   __asm__("movw %0, %%gs;" : : "r" (seg1));
      75               0 : }
      76                 : 
      77                 : 
      78                 : uint16_t NaClGetSs(void) {
      79               0 :   uint16_t seg1;
      80                 : 
      81               0 :   __asm__("mov %%ss, %0" : "=r" (seg1) : );
      82               0 :   return seg1;
      83                 : }
      84                 : 
      85                 : 
      86                 : #if NACL_BUILD_SUBARCH == 32
      87                 : nacl_reg_t NaClGetStackPtr(void) {
      88                 :   nacl_reg_t esp;
      89                 : 
      90                 :   __asm__("movl %%esp, %0" : "=r" (esp) : );
      91                 :   return esp;
      92                 : }
      93                 : #elif NACL_BUILD_SUBARCH == 64
      94                 : 
      95                 : nacl_reg_t NaClGetStackPtr(void) {
      96           20878 :   nacl_reg_t rsp;
      97                 : 
      98           20878 :   __asm__("mov %%rsp, %0" : "=r" (rsp) : );
      99           20878 :   return rsp;
     100                 : }
     101                 : 
     102                 : #else
     103                 : # error "Woe to the service runtime.  Is it running on a 128-bit machine?!?"
     104                 : #endif