arch/x86_64: convert all asm() to __asm__()

asm() is not supported by -std=c99, __asm__() is more portable

Signed-off-by: p-szafonimateusz <[email protected]>

Author: szafonimateusz-mi

arch/x86_64/include/intel64/io.h

@@ -50,7 +50,7 @@
 
 static inline void outb(uint8_t regval, uint16_t port)
 {
-  asm volatile(
+  __asm__ volatile(
     "\toutb %0,%1\n"
     :
     : "a" (regval), "dN" (port)
@@ -60,17 +60,17 @@ static inline void outb(uint8_t regval, uint16_t port)
 static inline uint8_t inb(uint16_t port)
 {
   uint8_t regval;
-  asm volatile(
+  __asm__ volatile(
     "\tinb %1,%0\n"
     : "=a" (regval)
     : "dN" (port)
-  );
+    );
   return regval;
 }
 
 static inline void outw(uint16_t regval, uint16_t port)
 {
-  asm volatile(
+  __asm__ volatile(
     "\toutw %0,%1\n"
     :
     : "a" (regval), "dN" (port)
@@ -81,7 +81,7 @@ static inline uint16_t inw(uint16_t port)
 {
   uint16_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tinw %1,%0\n"
     : "=a" (regval)
     : "dN" (port)
@@ -91,7 +91,7 @@ static inline uint16_t inw(uint16_t port)
 
 static inline void outl(uint32_t regval, uint16_t port)
 {
-  asm volatile(
+  __asm__ volatile(
     "\toutl %0,%1\n"
     :
     : "a" (regval), "dN" (port)
@@ -101,7 +101,7 @@ static inline void outl(uint32_t regval, uint16_t port)
 static inline uint32_t inl(uint16_t port)
 {
   uint32_t regval;
-  asm volatile(
+  __asm__ volatile(
     "\tinl %1,%0\n"
     : "=a" (regval)
     : "dN" (port)
@@ -127,7 +127,7 @@ static inline uint32_t mmio_read32(void *address)
 
   /* Assembly-encoded to match the hypervisor MMIO parser support */
 
-  asm volatile("movl (%1),%0" : "=r" (value) : "r" (address));
+  __asm__ volatile("movl (%1),%0" : "=r" (value) : "r" (address));
   return value;
 }
 
@@ -150,7 +150,7 @@ static inline void mmio_write32(void *address, uint32_t value)
 {
   /* Assembly-encoded to match the hypervisor MMIO parser support */
 
-  asm volatile("movl %0,(%1)" : : "r" (value), "r" (address));
+  __asm__ volatile("movl %0,(%1)" : : "r" (value), "r" (address));
 }
 
 static inline void mmio_write64(void *address, uint64_t value)
@@ -162,10 +162,10 @@ static inline void up_trash_cpu(void)
 {
   for (; ; )
     {
-      asm volatile ("cli;hlt;");
+      __asm__ volatile ("cli;hlt;");
     }
 
-  asm("ud2":::"memory");
+  __asm__ volatile ("ud2":::"memory");
 }
 
 static inline void up_invalid_tlb(uintptr_t start, uintptr_t end)
@@ -177,7 +177,7 @@ static inline void up_invalid_tlb(uintptr_t start, uintptr_t end)
 
   for (i = start; i < end; i += PAGE_SIZE)
     {
-      asm("invlpg %0;":: "m"(i):"memory");
+      __asm__ volatile ("invlpg %0;":: "m"(i):"memory");
     }
 }
 

arch/x86_64/include/intel64/irq.h

@@ -518,7 +518,7 @@ static inline void setgdt(void *gdt, int size)
   gdt_ptr.limit = size;
   gdt_ptr.base = (uintptr_t)gdt;
 
-  asm volatile ("lgdt %0"::"m"(gdt_ptr):"memory");
+  __asm__ volatile ("lgdt %0"::"m"(gdt_ptr):"memory");
 }
 
 static inline void setidt(void *idt, int size)
@@ -527,15 +527,15 @@ static inline void setidt(void *idt, int size)
   idt_ptr.limit = size;
   idt_ptr.base = (uintptr_t)idt;
 
-  asm volatile ("lidt %0"::"m"(idt_ptr):"memory");
+  __asm__ volatile ("lidt %0"::"m"(idt_ptr):"memory");
 }
 
 static inline uint64_t rdtscp(void)
 {
   uint32_t lo;
   uint32_t hi;
 
-  asm volatile("rdtscp" : "=a" (lo), "=d" (hi)::"ecx", "memory");
+  __asm__ volatile("rdtscp" : "=a" (lo), "=d" (hi)::"ecx", "memory");
   return (uint64_t)lo | (((uint64_t)hi) << 32);
 }
 
@@ -544,29 +544,29 @@ static inline uint64_t rdtsc(void)
   uint32_t lo;
   uint32_t hi;
 
-  asm volatile("rdtsc" : "=a" (lo), "=d" (hi)::"memory");
+  __asm__ volatile("rdtsc" : "=a" (lo), "=d" (hi)::"memory");
   return (uint64_t)lo | (((uint64_t)hi) << 32);
 }
 
 static inline void set_pcid(uint64_t pcid)
 {
-    if (pcid < 4095)
-      {
-        asm volatile("mov %%cr3, %%rbx; andq $-4096, %%rbx; or %0, "
-                     "%%rbx; mov %%rbx, %%cr3;"
-                     ::"g"(pcid):"memory", "rbx", "rax");
-      }
+  if (pcid < 4095)
+    {
+      __asm__ volatile("mov %%cr3, %%rbx; andq $-4096, %%rbx; or %0, "
+                       "%%rbx; mov %%rbx, %%cr3;"
+                       ::"g"(pcid):"memory", "rbx", "rax");
+    }
 }
 
 static inline void set_cr3(uint64_t cr3)
 {
-  asm volatile("mov %0, %%cr3" : "=rm"(cr3) : : "memory");
+  __asm__ volatile("mov %0, %%cr3" : "=rm"(cr3) : : "memory");
 }
 
 static inline uint64_t get_cr3(void)
 {
   uint64_t cr3;
-  asm volatile("mov %%cr3, %0" : "=rm"(cr3) : : "memory");
+  __asm__ volatile("mov %%cr3, %0" : "=rm"(cr3) : : "memory");
   return cr3;
 }
 
@@ -582,54 +582,54 @@ static inline unsigned long read_msr(unsigned int msr)
   uint32_t low;
   uint32_t high;
 
-  asm volatile("rdmsr" : "=a" (low), "=d" (high) : "c" (msr));
+  __asm__ volatile("rdmsr" : "=a" (low), "=d" (high) : "c" (msr));
   return low | ((unsigned long)high << 32);
 }
 
 static inline void write_msr(unsigned int msr, unsigned long val)
 {
-  asm volatile("wrmsr"
-    : /* no output */
-    : "c" (msr), "a" (val), "d" (val >> 32)
-    : "memory");
+  __asm__ volatile("wrmsr"
+                   : /* no output */
+                   : "c" (msr), "a" (val), "d" (val >> 32)
+                   : "memory");
 }
 
 static inline uint64_t read_fsbase(void)
 {
-    uint64_t val;
-  asm volatile("rdfsbase %0"
-    : "=r" (val)
-    : /* no output */
-    : "memory");
+  uint64_t val;
+  __asm__ volatile("rdfsbase %0"
+                   : "=r" (val)
+                   : /* no output */
+                   : "memory");
 
-    return val;
+  return val;
 }
 
 static inline void write_fsbase(unsigned long val)
 {
-  asm volatile("wrfsbase %0"
-    : /* no output */
-    : "r" (val)
-    : "memory");
+  __asm__ volatile("wrfsbase %0"
+                   : /* no output */
+                   : "r" (val)
+                   : "memory");
 }
 
 static inline uint64_t read_gsbase(void)
 {
-    uint64_t val;
-  asm volatile("rdgsbase %0"
-    : "=r" (val)
-    : /* no output */
-    : "memory");
+  uint64_t val;
+  __asm__ volatile("rdgsbase %0"
+                   : "=r" (val)
+                   : /* no output */
+                   : "memory");
 
-    return val;
+  return val;
 }
 
 static inline void write_gsbase(unsigned long val)
 {
-  asm volatile("wrgsbase %0"
-    : /* no output */
-    : "r" (val)
-    : "memory");
+  __asm__ volatile("wrgsbase %0"
+                   : /* no output */
+                   : "r" (val)
+                   : "memory");
 }
 
 /* Return stack pointer */
@@ -638,7 +638,7 @@ static inline uint64_t up_getsp(void)
 {
   uint64_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmovq %%rsp, %0\n"
     : "=rm" (regval)
     :
@@ -652,7 +652,7 @@ static inline uint32_t up_getds(void)
 {
   uint32_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmov %%ds, %0\n"
     : "=rm" (regval)
     :
@@ -664,7 +664,7 @@ static inline uint32_t up_getcs(void)
 {
   uint32_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmov %%cs, %0\n"
     : "=rm" (regval)
     :
@@ -676,7 +676,7 @@ static inline uint32_t up_getss(void)
 {
   uint32_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmov %%ss, %0\n"
     : "=rm" (regval)
     :
@@ -688,7 +688,7 @@ static inline uint32_t up_getes(void)
 {
   uint32_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmov %%es, %0\n"
     : "=rm" (regval)
     :
@@ -700,7 +700,7 @@ static inline uint32_t up_getfs(void)
 {
   uint32_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmov %%fs, %0\n"
     : "=rm" (regval)
     :
@@ -712,7 +712,7 @@ static inline uint32_t up_getgs(void)
 {
   uint32_t regval;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmov %%gs, %0\n"
     : "=rm" (regval)
     :
@@ -735,7 +735,7 @@ static inline irqstate_t irqflags()
 {
   irqstate_t flags;
 
-  asm volatile(
+  __asm__ volatile(
     "\tpushfq\n"
     "\tpopq %0\n"
     : "=rm" (flags)
@@ -763,14 +763,14 @@ static inline bool up_irq_enabled(irqstate_t flags)
 
 static inline void up_irq_disable(void)
 {
-  asm volatile("cli": : :"memory");
+  __asm__ volatile("cli": : :"memory");
 }
 
 /* Enable interrupts unconditionally */
 
 static inline void up_irq_enable(void)
 {
-  asm volatile("sti": : :"memory");
+  __asm__ volatile("sti": : :"memory");
 }
 
 /* Disable interrupts, but return previous interrupt state */

arch/x86_64/include/irq.h

@@ -100,7 +100,7 @@ static inline_function int up_cpu_index(void)
 {
   int cpu;
 
-  asm volatile(
+  __asm__ volatile(
     "\tmovl %%gs:(%c1), %0\n"
     : "=r" (cpu)
     : "i" (offsetof(struct intel64_cpu_s, id))
@@ -119,17 +119,17 @@ static inline_function int up_cpu_index(void)
 static inline_function uint64_t *up_current_regs(void)
 {
   uint64_t *regs;
-  asm volatile("movq %%gs:(%c1), %0"
-               : "=rm" (regs)
-               : "i" (offsetof(struct intel64_cpu_s, current_regs)));
+  __asm__ volatile("movq %%gs:(%c1), %0"
+                   : "=rm" (regs)
+                   : "i" (offsetof(struct intel64_cpu_s, current_regs)));
   return regs;
 }
 
 static inline_function void up_set_current_regs(uint64_t *regs)
 {
-  asm volatile("movq %0, %%gs:(%c1)"
-               :: "r" (regs), "i" (offsetof(struct intel64_cpu_s,
-                                            current_regs)));
+  __asm__ volatile("movq %0, %%gs:(%c1)"
+                   :: "r" (regs), "i" (offsetof(struct intel64_cpu_s,
+                                                current_regs)));
 }
 
 /****************************************************************************