Return to segment.h CVS log

Up to [Early Linux] / linux / include / asm

Annotation of linux/include/asm/segment.h, revision 1.1.1.5

1.1       root        1: extern inline unsigned char get_fs_byte(const char * addr)
                      2: {
                      3:        unsigned register char _v;
                      4: 
1.1.1.4   root        5:        __asm__ ("movb %%fs:%1,%0":"=q" (_v):"m" (*addr));
1.1       root        6:        return _v;
                      7: }
                      8: 
                      9: extern inline unsigned short get_fs_word(const unsigned short *addr)
                     10: {
                     11:        unsigned short _v;
                     12: 
                     13:        __asm__ ("movw %%fs:%1,%0":"=r" (_v):"m" (*addr));
                     14:        return _v;
                     15: }
                     16: 
                     17: extern inline unsigned long get_fs_long(const unsigned long *addr)
                     18: {
                     19:        unsigned long _v;
                     20: 
                     21:        __asm__ ("movl %%fs:%1,%0":"=r" (_v):"m" (*addr)); \
                     22:        return _v;
                     23: }
                     24: 
                     25: extern inline void put_fs_byte(char val,char *addr)
                     26: {
1.1.1.4   root       27: __asm__ ("movb %0,%%fs:%1"::"q" (val),"m" (*addr));
1.1       root       28: }
                     29: 
                     30: extern inline void put_fs_word(short val,short * addr)
                     31: {
                     32: __asm__ ("movw %0,%%fs:%1"::"r" (val),"m" (*addr));
                     33: }
                     34: 
                     35: extern inline void put_fs_long(unsigned long val,unsigned long * addr)
                     36: {
                     37: __asm__ ("movl %0,%%fs:%1"::"r" (val),"m" (*addr));
                     38: }
1.1.1.2   root       39: 
1.1.1.5 ! root       40: extern inline void memcpy_tofs(void * to, void * from, unsigned long n)
        !            41: {
        !            42: __asm__("cld\n\t"
        !            43:        "push %%es\n\t"
        !            44:        "push %%fs\n\t"
        !            45:        "pop %%es\n\t"
        !            46:        "testb $1,%%cl\n\t"
        !            47:        "je 1f\n\t"
        !            48:        "movsb\n"
        !            49:        "1:\ttestb $2,%%cl\n\t"
        !            50:        "je 2f\n\t"
        !            51:        "movsw\n"
        !            52:        "2:\tshrl $2,%%ecx\n\t"
        !            53:        "rep ; movsl\n\t"
        !            54:        "pop %%es"
        !            55:        ::"c" (n),"D" ((long) to),"S" ((long) from)
        !            56:        :"cx","di","si");
        !            57: }
        !            58: 
        !            59: extern inline void memcpy_fromfs(void * to, void * from, unsigned long n)
        !            60: {
        !            61: __asm__("cld\n\t"
        !            62:        "testb $1,%%cl\n\t"
        !            63:        "je 1f\n\t"
        !            64:        "fs ; movsb\n"
        !            65:        "1:\ttestb $2,%%cl\n\t"
        !            66:        "je 2f\n\t"
        !            67:        "fs ; movsw\n"
        !            68:        "2:\tshrl $2,%%ecx\n\t"
        !            69:        "rep ; fs ; movsl"
        !            70:        ::"c" (n),"D" ((long) to),"S" ((long) from)
        !            71:        :"cx","di","si");
        !            72: }
        !            73: 
1.1.1.2   root       74: /*
                     75:  * Someone who knows GNU asm better than I should double check the followig.
                     76:  * It seems to work, but I don't know if I'm doing something subtly wrong.
                     77:  * --- TYT, 11/24/91
1.1.1.4   root       78:  * [ nothing wrong here, Linus: I just changed the ax to be any reg ]
1.1.1.2   root       79:  */
                     80: 
                     81: extern inline unsigned long get_fs() 
                     82: {
                     83:        unsigned short _v;
1.1.1.4   root       84:        __asm__("mov %%fs,%0":"=r" (_v):);
1.1.1.2   root       85:        return _v;
                     86: }
                     87: 
                     88: extern inline unsigned long get_ds() 
                     89: {
                     90:        unsigned short _v;
1.1.1.4   root       91:        __asm__("mov %%ds,%0":"=r" (_v):);
1.1.1.2   root       92:        return _v;
                     93: }
                     94: 
                     95: extern inline void set_fs(unsigned long val)
                     96: {
1.1.1.4   root       97:        __asm__("mov %0,%%fs"::"r" ((unsigned short) val));
1.1.1.2   root       98: }
                     99: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.