Changeset 18e0a6c in mainline


Ignore:
Timestamp:
2005-06-09T23:43:45Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
74df77d
Parents:
d896525
Message:

Implement several assembler functions in gcc's asm notation instead of in .s or .S file.
Gain both better speed and size.

Files:
16 edited

Legend:

Unmodified
Added
Removed

  • arch/ia32/include/asm.h

    rd896525 r18e0a6c  
    3838
    3939extern void paging_on(void);
    40 extern __address cpu_read_dba(void);
    41 extern void cpu_write_dba(__address dba);
    42 
    43 extern __address cpu_read_cr2(void);
    4440
    4541extern void interrupt_handlers(void);
    … …  
    5551extern void enable_l_apic_in_msr(void);
    5652
    57 extern void halt_cpu(void);
    58 extern void cpu_sleep(void);
     53/** Halt CPU
     54 *
     55 * Halt the current CPU until interrupt event.
     56 */
     57static inline void cpu_halt(void) { __asm__("hlt"); };
     58static inline void cpu_sleep(void) { __asm__("hlt"); };
    5959
    60 static inline void write_dr0(__u32 v);
    61 static inline __u32 read_dr0(void);
     60/** Read CR2
     61 *
     62 * Return value in CR2
     63 *
     64 * @return Value read.
     65 */
     66static inline __u32 read_cr2(void) { __u32 v; __asm__ volatile ("movl %%cr2,%0" : "=r" (v)); return v; }
    6267
    63 inline void write_dr0(__u32 v) { __asm__ volatile ("movl %0,%%dr0\n" : : "r" (v)); }
    64 inline __u32 read_dr0(void) { __u32 v; __asm__ volatile ("movl %%dr0,%0" : "=r" (v)); return v; }
     68/** Write CR3
     69 *
     70 * Write value to CR3.
     71 *
     72 * @param v Value to be written.
     73 */
     74static inline void write_cr3(__u32 v) { __asm__ volatile ("movl %0,%%cr3\n" : : "r" (v)); }
     75
     76/** Read CR3
     77 *
     78 * Return value in CR3
     79 *
     80 * @return Value read.
     81 */
     82static inline __u32 read_cr3(void) { __u32 v; __asm__ volatile ("movl %%cr3,%0" : "=r" (v)); return v; }
     83
     84/** Write DR0
     85 *
     86 * Write value to DR0.
     87 *
     88 * @param v Value to be written.
     89 */
     90static inline void write_dr0(__u32 v) { __asm__ volatile ("movl %0,%%dr0\n" : : "r" (v)); }
     91
     92/** Read DR0
     93 *
     94 * Return value in DR0
     95 *
     96 * @return Value read.
     97 */
     98static inline __u32 read_dr0(void) { __u32 v; __asm__ volatile ("movl %%dr0,%0" : "=r" (v)); return v; }
     99
     100/** Set priority level low
     101 *
     102 * Enable interrupts and return previous
     103 * value of EFLAGS.
     104 */
     105static inline pri_t cpu_priority_low(void) {
     106        pri_t v;
     107        __asm__ volatile (
     108                "pushf\n"
     109                "popl %0\n"
     110                "sti\n"
     111                : "=r" (v)
     112        );
     113        return v;
     114}
     115
     116/** Set priority level high
     117 *
     118 * Disable interrupts and return previous
     119 * value of EFLAGS.
     120 */
     121static inline pri_t cpu_priority_high(void) {
     122        pri_t v;
     123        __asm__ volatile (
     124                "pushf\n"
     125                "popl %0\n"
     126                "cli\n"
     127                : "=r" (v)
     128        );
     129        return v;
     130}
     131
     132/** Restore priority level
     133 *
     134 * Restore EFLAGS.
     135 */
     136static inline void cpu_priority_restore(pri_t pri) {
     137        __asm__ volatile (
     138                "pushl %0\n"
     139                "popf\n"
     140                : : "r" (pri)
     141        );
     142}
     143
     144/** Return raw priority level
     145 *
     146 * Return EFLAFS.
     147 */
     148static inline pri_t cpu_priority_read(void) {
     149        pri_t v;
     150        __asm__ volatile (
     151                "pushf\n"
     152                "popl %0\n"
     153                : "=r" (v)
     154        );
     155        return v;
     156}
    65157
    66158#endif

  • arch/ia32/include/atomic.h

    rd896525 r18e0a6c  
    3232#include <arch/types.h>
    3333
    34 extern void atomic_inc(volatile int *val);
    35 extern void atomic_dec(volatile int *val);
     34static inline void atomic_inc(volatile int *val) {
     35#ifdef __SMP__
     36        __asm__ volatile ("lock incl (%0)\n" : : "r" (val));
     37#else
     38        __asm__ volatile ("incl (%0)\n" : : "r" (val));
     39#endif /* __SMP__ */
     40}
    3641
    37 extern int test_and_set(int *val);
     42static inline void atomic_dec(volatile int *val) {
     43#ifdef __SMP__
     44        __asm__ volatile ("lock decl (%0)\n" : : "r" (val));
     45#else
     46        __asm__ volatile ("decl (%0)\n" : : "r" (val));
     47#endif /* __SMP__ */
     48}
     49
     50static inline int test_and_set(int *val) {
     51        int v;
     52       
     53        __asm__ volatile (
     54                "movl $1, %0\n"
     55                "xchgl %0, (%1)\n"
     56                : "=r" (v)
     57                : "r" (val)
     58        );
     59       
     60        return v;
     61}
     62
     63
    3864extern void spinlock_arch(int *val);
    3965

  • arch/ia32/src/asm.s

    rd896525 r18e0a6c  
    3131.text
    3232
    33 .global cpu_priority_high
    34 .global cpu_priority_low
    35 .global cpu_priority_restore
    36 .global cpu_priority_read
    3733.global cpu_halt
    3834.global cpu_sleep
    3935.global paging_on
    40 .global cpu_read_dba
    41 .global cpu_write_dba
    42 .global cpu_read_cr2
    4336.global enable_l_apic_in_msr
    4437.global interrupt_handlers
    … …  
    5548
    5649
    57 ## Set priority level high
    58 #
    59 # Disable interrupts and return previous
    60 # EFLAGS in EAX.
    61 #
    62 cpu_priority_high:
    63         pushf
    64         pop %eax
    65         cli
    66         ret
    67 
    68 
    69 ## Set priority level low
    70 #
    71 # Enable interrupts and return previous
    72 # EFLAGS in EAX.
    73 #   
    74 cpu_priority_low:
    75         pushf
    76         pop %eax
    77         sti
    78         ret
    79 
    80 
    81 ## Restore priority level
    82 #
    83 # Restore EFLAGS.
    84 #
    85 cpu_priority_restore:
    86         push 4(%esp)
    87         popf
    88         ret
    89 
    90 ## Return raw priority level
    91 #
    92 # Return EFLAFS in EAX.
    93 #
    94 cpu_priority_read:
    95         pushf
    96         pop %eax
    97         ret
    98 
    99 
    100 ## Halt the CPU
    101 #
    102 # Halt the CPU using HLT.
    103 #
    104 cpu_halt:
    105 cpu_sleep:
    106         hlt
    107         ret
    108 
    109 
    11050## Turn paging on
    11151#
    … …  
    12464
    12565
    126 ## Read CR3
    127 #
    128 # Store CR3 in EAX.
    129 #
    130 cpu_read_dba:
    131         movl %cr3,%eax
    132         ret
    133 
    134 
    135 ## Write CR3
    136 #
    137 # Set CR3.
    138 #
    139 cpu_write_dba:
    140         pushl %eax
    141         movl 8(%esp),%eax
    142         movl %eax,%cr3
    143         popl %eax
    144         ret
    145 
    146 
    147 ## Read CR2
    148 #
    149 # Store CR2 in EAX.
    150 #
    151 cpu_read_cr2:
    152         movl %cr2,%eax
    153         ret
    154 
    155 
    15666## Enable local APIC
    15767#

  • arch/ia32/src/atomic.S

    rd896525 r18e0a6c  
    2929.text
    3030
    31 .global atomic_inc
    32 atomic_inc:
    33         pushl %ebx
    34         movl 8(%esp),%ebx
    35 #ifdef __SMP__ 
    36         lock incl (%ebx)
    37 #else
    38         incl (%ebx)
    39 #endif         
    40         popl %ebx
    41         ret
    42 
    43 .global atomic_dec
    44 atomic_dec:
    45         pushl %ebx
    46         movl 8(%esp),%ebx
    47 #ifdef __SMP__ 
    48         lock decl (%ebx)
    49 #else
    50         decl (%ebx)
    51 #endif
    52         popl %ebx
    53         ret
    54        
    55 
    5631#ifdef __SMP__
    5732
    58 
    59 .global test_and_set
    6033.global spinlock_arch
    61 
    62 test_and_set:
    63         pushl %ebx
    64    
    65         movl 8(%esp),%ebx
    66         movl $1,%eax
    67         xchgl %eax,(%ebx)       # xchg implicitly turns on the LOCK signal
    68    
    69         popl %ebx
    70         ret
    71 
    7234
    7335#

  • arch/ia32/src/interrupt.c

    rd896525 r18e0a6c  
    112112void page_fault(__u8 n, __u32 stack[])
    113113{
    114         printf("page fault address: %X\n", cpu_read_cr2());
     114        printf("page fault address: %X\n", read_cr2());
    115115        printf("stack[0]=%X, %%eip=%X, %%cs=%X, flags=%X\n", stack[0], stack[1], stack[2], stack[3]);
    116116        printf("%%eax=%L, %%ebx=%L, %%ecx=%L, %%edx=%L,\n%%edi=%L, %%esi=%L, %%ebp=%L, %%esp=%L\n", stack[-2], stack[-5], stack[-3], stack[-4], stack[-9], stack[-8], stack[-1], stack);

  • arch/ia32/src/mm/page.c

    rd896525 r18e0a6c  
    7070
    7171                trap_register(14, page_fault);
    72                 cpu_write_dba(KA2PA(dba));
     72                write_cr3(KA2PA(dba));
    7373        }
    7474        else {
    … …  
    8282                dba = frame_alloc(FRAME_KA | FRAME_PANIC);
    8383                memcopy(bootstrap_dba, dba, PAGE_SIZE);
    84                 cpu_write_dba(KA2PA(dba));
     84                write_cr3(KA2PA(dba));
    8585        }
    8686
    … …  
    108108
    109109        if (root) dba = root;
    110         else dba = cpu_read_dba();
     110        else dba = read_cr3();
    111111
    112112        pde = page >> 22;               /* page directory entry */

  • arch/ia32/src/mm/tlb.c

    rd896525 r18e0a6c  
    3232void tlb_invalidate(int asid)
    3333{
    34         cpu_write_dba(cpu_read_dba());
     34        write_cr3(read_cr3());
    3535}

  • arch/ia32/src/smp/apic.c

    rd896525 r18e0a6c  
    4545 * Tested on:
    4646 *      Bochs 2.0.2 - Bochs 2.2 with 2-8 CPUs
     47 *      Simics 2.0.28
    4748 *      ASUS P/I-P65UP5 + ASUS C-P55T2D REV. 1.41 with 2x 200Mhz Pentium CPUs
    4849 */

  • doc/requirements

    rd896525 r18e0a6c  
    22=========
    33
    4     HARDWARE REQUIREMENTS
    5     o IA-32 processor (Pentium and successors)
     4        HARDWARE REQUIREMENTS
     5        o IA-32 processor (Pentium and successors)
    66
    7     COMPILER REQUIREMENTS
    8     o binutils 2.15
    9     o gcc 2.95
    10     o gcc 3.3.2 - gcc 3.3.5
     7        COMPILER REQUIREMENTS
     8        o binutils 2.15
     9        o gcc 2.95
     10        o gcc 3.3.2 - gcc 3.3.5
    1111
    12     SMP COMPATIBILITY
    13     o Bochs 2.0.2 - Bochs 2.2
    14         o 2x-8x 686 CPU
    15     o ASUS P/I-P65UP5 + ASUS C-P55T2D REV. 1.41
    16         o 2x 200Mhz Pentium CPU
     12        SMP COMPATIBILITY
     13        o Bochs 2.0.2 - Bochs 2.2
     14                o 2x-8x 686 CPU
     15        o Simics 2.0.28
     16                o 4x Pentium 4 CPU
     17        o ASUS P/I-P65UP5 + ASUS C-P55T2D REV. 1.41
     18                o 2x 200Mhz Pentium CPU
    1719   
    18     EMULATORS AND VIRTUALIZERS
    19     o Bochs 2.0.2 - Bochs 2.2-cvs
    20     o VMware Workstation 4, VMware Workstation 5
     20        EMULATORS AND VIRTUALIZERS
     21        o Bochs 2.0.2 - Bochs 2.2
     22        o VMware Workstation 4, VMware Workstation 5
    2123
    2224
    … …  
    2426=========
    2527
    26     HARDWARE REQUIREMENTS
    27     o no real hardware supported
    28     o msim emulated MIPS R4000 CPU (see mips)
     28        HARDWARE REQUIREMENTS
     29        o no real hardware supported
     30        o msim emulated MIPS R4000 CPU (see mips)
    2931
    30     COMPILER REQUIREMENTS
    31     o binutils 2.14 mips cross binutils
    32     o gcc 2.8.1 mips cross compiler
    33     o gcc 3.2.3 mips cross compiler
     32        COMPILER REQUIREMENTS
     33        o binutils 2.14 mips cross binutils
     34        o gcc 2.8.1 mips cross compiler
     35        o gcc 3.2.3 mips cross compiler
    3436
    35     EMULATORS AND VIRTUALIZERS
    36     o msim
     37        EMULATORS AND VIRTUALIZERS
     38        o msim
    3739
    3840ia64 port
    3941=========
    4042
    41     HARDWARE REQUIREMENTS
    42     o no real hardware supported
     43        HARDWARE REQUIREMENTS
     44        o no real hardware supported
    4345
    44     EMULATORS AND VIRTUALIZERS
    45     o ski
     46        EMULATORS AND VIRTUALIZERS
     47        o ski

  • src/debug/print.c

    rd896525 r18e0a6c  
    3131#include <synch/spinlock.h>
    3232#include <arch/arg.h>
     33#include <arch/asm.h>
    3334
    3435

  • src/mm/frame.c

    rd896525 r18e0a6c  
    4242
    4343#include <synch/spinlock.h>
     44
     45#include <arch/asm.h>
    4446
    4547count_t frames = 0;

  • src/mm/heap.c

    rd896525 r18e0a6c  
    3333#include <panic.h>
    3434#include <arch/types.h>
     35#include <arch/asm.h>
    3536
    3637/*

  • src/mm/vm.c

    rd896525 r18e0a6c  
    3939#include <list.h>
    4040#include <panic.h>
     41#include <arch/asm.h>
    4142
    4243vm_t *vm_create(void)

  • src/proc/scheduler.c

    rd896525 r18e0a6c  
    132132                }
    133133       
    134                 /* avoid deadlock with relink_rq */
     134                /* avoid deadlock with relink_rq() */
    135135                if (!spinlock_trylock(&CPU->lock)) {
    136136                        /*
    … …  
    447447
    448448                        cpu = &cpus[(i + k) % config.cpu_active];
    449                         r = &cpu->rq[j];
    450449
    451450                        /*
    … …  
    454453                         */
    455454                        if (CPU == cpu)
    456                                 continue;
     455                                continue;                               
    457456
    458457restart:                pri = cpu_priority_high();
     458                        r = &cpu->rq[j];
    459459                        spinlock_lock(&r->lock);
    460460                        if (r->n == 0) {
    … …  
    471471                                 * We don't want to steal CPU-wired threads neither threads already stolen.
    472472                                 * The latter prevents threads from migrating between CPU's without ever being run.
    473                                  * We don't want to steal threads whose FPU context is still in CPU
     473                                 * We don't want to steal threads whose FPU context is still in CPU.
    474474                                 */
    475475                                spinlock_lock(&t->lock);
    476476                                if ( (!(t->flags & (X_WIRED | X_STOLEN))) && (!(t->fpu_context_engaged)) ) {
     477                               
    477478                                        /*
    478479                                         * Remove t from r.

  • src/proc/thread.c

    rd896525 r18e0a6c  
    177177                frame_ks = frame_alloc(FRAME_KA);
    178178                if (THREAD_USER_STACK & flags) {
    179                         frame_us = frame_alloc(0);
     179                        frame_us = frame_alloc(FRAME_KA);
    180180                }
    181181

  • src/synch/semaphore.c

    rd896525 r18e0a6c  
    3131#include <synch/waitq.h>
    3232#include <synch/spinlock.h>
     33#include <arch/asm.h>
    3334
    3435void semaphore_initialize(semaphore_t *s, int val)
Note: See TracChangeset for help on using the changeset viewer.