Annotation of OpenXM_contrib/pari/src/kernel/ix86/l0asm.txt, Revision 1.1
1.1 ! maekawa 1: // Assembly language support for i386 CPU.
! 2: // Bruno Haible 21.6.1997
! 3:
! 4: // An assembly language file for the i386/i486/i586/i686 CPUs:
! 5: // On Unix, it is preprocessed and then assembled. NB: This file requires
! 6: // an ANSI C or C++ preprocessor which understands C++ comments.
! 7: // On Windows, with MSVC, it is preprocessed and then compiled with
! 8: // optimization. (The MSVC development environment does not have a separate
! 9: // assembler, we must use the C compiler's inline asm extension. Compiling
! 10: // without optimization pushes the registers %ebx,%esi,%edi onto the stack
! 11: // at function entry and pops them at function exit, which is not what we
! 12: // want because it affects the %esp offsets of the function arguments.)
! 13:
! 14: // The assembly language file should
! 15: // 1. include a configuration file which defines ASM_UNDERSCORE if appropriate.
! 16: // #ifndef _MSC_VER
! 17: // #include "config.h"
! 18: // #endif
! 19: // 2. include this file.
! 20: // #include "level0asm.h"
! 21: // 3. define all assembly language code.
! 22:
! 23: // The three different assembler syntaxes for this CPU are a MAJOR annoyance.
! 24: // In order not to have to maintain several copies of the assembly language
! 25: // code, we use lots of macros which expand into the correct syntax.
! 26: // These macros are:
! 27: // C(name)
! 28: // This expands to the name of the C variable or function `name'.
! 29: // On Unix BSD systems, this prepends an underscore.
! 30: // L(label)
! 31: // This expands to the name of a local label, having the name `label'.
! 32: // On Unix ELF systems, where there is no underscore, names beginning
! 33: // with an alphabetic character are automatically exported, so this
! 34: // prepends a dot. Note that when defining a label, the `:' must
! 35: // be inside the parentheses, not outside, because otherwise some
! 36: // ANSI C preprocessor inserts a space between the label and the `:',
! 37: // and some assemblers don't like this.
! 38: // R(reg)
! 39: // This expands to a reference to register `reg'. On Unix, this
! 40: // prepends a % charater.
! 41: // NUM(value)
! 42: // This expands to an immediate value. On Unix, this prepends a $
! 43: // character.
! 44: // ADDR(variable)
! 45: // This expands to an immediate value, the address of some variable
! 46: // or function. On Unix, this prepends a $ character. With MSVC,
! 47: // this prepends the keyword "OFFSET".
! 48: // About operand sizes: On Unix, a suffix to the instruction specifies the
! 49: // size of the operands (for example "movb", "movw", "movl"). With
! 50: // MSVC, there is no such suffix. Instead, the assembler infers the
! 51: // operand size from the names of the registers ("al" vs. "ax" vs.
! 52: // "eax"). This works well in most cases, but in instructions like
! 53: // "mul [esi]" the assembler guesses the operand size: "byte" by
! 54: // default. So it is better to explicitly specify the operand size
! 55: // of memory operands (prefix X1, X2, X4, X8).
! 56: // (Side note about Unix assemblers: Some Unix assemblers allow you
! 57: // to write "testb %eax,%eax" but silently treat this as
! 58: // "testb %al,%al".)
! 59: // X1
! 60: // This prefixes a memory reference of 1 byte.
! 61: // X2
! 62: // This prefixes a memory reference of 2 bytes.
! 63: // X4
! 64: // This prefixes a memory reference of 4 bytes.
! 65: // X8
! 66: // This prefixes a memory reference of 8 bytes.
! 67: // MEM(base)
! 68: // This expands to a memory reference at address `base'.
! 69: // MEM_DISP(base,displacement)
! 70: // This expands to a memory reference at address `base+displacement'.
! 71: // MEM_INDEX(base,index)
! 72: // This expands to a memory reference at address `base+index'.
! 73: // MEM_SHINDEX(base,index,size)
! 74: // This expands to a memory reference at address
! 75: // `base+index*size', where `size' is 1, 2, 4, or 8.
! 76: // MEM_DISP_SHINDEX0(displacement,index,size)
! 77: // This expands to a memory reference at address
! 78: // `displacement+index*size', where `size' is 1, 2, 4, or 8.
! 79: // MEM_DISP_SHINDEX(base,displacement,index,size)
! 80: // This expands to a memory reference at address
! 81: // `base+displacement+index*size', where `size' is 1, 2, 4, or 8.
! 82: // INDIR(value)
! 83: // This expands to an implicit indirection. On Unix, this prepends
! 84: // a * character.
! 85: // INSN1(mnemonic,size_suffix,dst)
! 86: // This expands to an instruction with one operand.
! 87: // INSN2(mnemonic,size_suffix,src,dst)
! 88: // This expands to an instruction with two operands. In our notation,
! 89: // `src' comes first and `dst' second, but they are reversed when
! 90: // expanding to Intel syntax.
! 91: // INSN2MOVX(mnemonic,size_suffix,src,dst)
! 92: // This expands to an instruction with two operands, of type
! 93: // movsbl/movzbl, which in some syntaxes requires a second suffix.
! 94: // INSN2SHCL(mnemonic,size_suffix,src,dst)
! 95: // This expands to an instruction with two operands, of type
! 96: // shrd/shld, which in some syntaxes requires an additional operand
! 97: // %cl.
! 98: // REP, REPZ
! 99: // This expands to a prefix for string instructions.
! 100: // _
! 101: // For instructions which don't have a size suffix, like jump
! 102: // instructions. Expands to nothing. Needed for MSVC, which has
! 103: // problems with empty macro arguments.
! 104: // TEXT()
! 105: // Switch to the code section.
! 106: // ALIGN(log)
! 107: // Align to 2^log bytes.
! 108: // GLOBL(name)
! 109: // Declare `name' to be a global symbol.
! 110: // FUNBEGIN(name)
! 111: // Start the assembly language code for the C function `name'.
! 112: // FUNEND()
! 113: // End the assembly language code for a function.
! 114:
! 115: // Define the C(name) and L(label) macros.
! 116: #ifdef _MSC_VER
! 117: # define C(entrypoint) entrypoint
! 118: # define L(label) L##label
! 119: #else
! 120: # ifdef ASM_UNDERSCORE
! 121: # if defined(__STDC__) || defined(__cplusplus)
! 122: # define C(entrypoint) _##entrypoint
! 123: # define L(label) L##label
! 124: # else
! 125: # define C(entrypoint) _/**/entrypoint
! 126: # define L(label) L/**/label
! 127: # endif
! 128: # else
! 129: # define C(entrypoint) entrypoint
! 130: # if defined(__STDC__) || defined(__cplusplus)
! 131: # define L(label) .L##label
! 132: # else
! 133: # define L(label) .L/**/label
! 134: # endif
! 135: # endif
! 136: #endif
! 137:
! 138: // Define one of these.
! 139: // BSD_SYNTAX for GNU assembler version 2.
! 140: // ELF_SYNTAX for SVR4 and Solaris assemblers.
! 141: // INTEL_SYNTAX for MS assembler.
! 142: #ifdef _MSC_VER
! 143: # define INTEL_SYNTAX
! 144: #else
! 145: // On Unix, it happens that the ELF systems (ASM_UNDERSCORE not defined) use
! 146: // the ELF syntax, while the BSD systems (ASM_UNDERSCORE defined) use the
! 147: // BSD syntax. Neat to know, this saves us from enumerating all the systems.
! 148: # ifdef ASM_UNDERSCORE
! 149: # define BSD_SYNTAX
! 150: # else
! 151: # define ELF_SYNTAX
! 152: # endif
! 153: #endif
! 154:
! 155: #if defined (BSD_SYNTAX) || defined (ELF_SYNTAX)
! 156: # define R(r) %r
! 157: # define NUM(n) $##n
! 158: # define ADDR(a) $##a
! 159: # define X1
! 160: # define X2
! 161: # define X4
! 162: # define X8
! 163: # define MEM(base)(R(base))
! 164: # define MEM_DISP(base,displacement)displacement(R(base))
! 165: # define MEM_INDEX(base,index)(R(base),R(index))
! 166: # define MEM_SHINDEX(base,index,size)(R(base),R(index),size)
! 167: # define MEM_DISP_SHINDEX0(displacement,index,size)displacement(,R(index),size)
! 168: # define MEM_DISP_SHINDEX(base,displacement,index,size)displacement(R(base),R(index),size)
! 169: # define INDIR(value)*value
! 170: # define INSNCONC(mnemonic,size_suffix)mnemonic##size_suffix
! 171: # define INSN1(mnemonic,size_suffix,dst)INSNCONC(mnemonic,size_suffix) dst
! 172: # define INSN2(mnemonic,size_suffix,src,dst)INSNCONC(mnemonic,size_suffix) src,dst
! 173: # define INSN2MOVX(mnemonic,size_suffix,src,dst)INSNCONC(INSNCONC(mnemonic,size_suffix),l) src,dst
! 174: # if defined(BSD_SYNTAX) || defined(COHERENT)
! 175: # define INSN2SHCL(mnemonic,size_suffix,src,dst)INSNCONC(mnemonic,size_suffix) R(cl),src,dst
! 176: # define REPZ repe ;
! 177: # else
! 178: # define INSN2SHCL(mnemonic,size_suffix,src,dst)INSNCONC(mnemonic,size_suffix) src,dst
! 179: # define REPZ repz ;
! 180: # endif
! 181: # define REP rep ;
! 182: # if defined(BSD_SYNTAX) && !(defined(__CYGWIN32__) || defined(__MINGW32__))
! 183: # define ALIGN(log) .align log,0x90
! 184: # endif
! 185: # if defined(ELF_SYNTAX) || defined(__CYGWIN32__) || defined(__MINGW32__)
! 186: # define ALIGN(log) .align 1<<(log)
! 187: # endif
! 188: #endif
! 189: #ifdef INTEL_SYNTAX
! 190: # define R(r) r
! 191: # define NUM(n) n
! 192: # define ADDR(a) OFFSET a
! 193: # define X1 BYTE PTR
! 194: # define X2 WORD PTR
! 195: # define X4 DWORD PTR
! 196: # define X8 QWORD PTR
! 197: # define MEM(base) [base]
! 198: # define MEM_DISP(base,displacement) [base+(displacement)]
! 199: # define MEM_INDEX(base,index) [base+index]
! 200: # define MEM_SHINDEX(base,index,size) [base+index*size]
! 201: # define MEM_DISP_SHINDEX0(displacement,index,size) [(displacement)+index*size]
! 202: # define MEM_DISP_SHINDEX(base,displacement,index,size) [base+(displacement)+index*size]
! 203: # define INDIR(value)value
! 204: # define INSNCONC(mnemonic,suffix)mnemonic##suffix
! 205: # define INSN1(mnemonic,size_suffix,dst)mnemonic dst
! 206: # define INSN2(mnemonic,size_suffix,src,dst)mnemonic dst,src
! 207: # define INSN2MOVX(mnemonic,size_suffix,src,dst)INSNCONC(mnemonic,x) dst,src
! 208: # define INSN2SHCL(mnemonic,size_suffix,src,dst)mnemonic dst,src,R(cl)
! 209: # define REPZ repz
! 210: # define REP rep
! 211: # define movsl movs R(eax)
! 212: # define stosl stos R(eax)
! 213: # define scasl scas R(eax)
! 214: # define cmpsl cmpsd
! 215: # ifdef _MSC_VER
! 216: // No pseudo-ops available in MS inline assembler.
! 217: # define ALIGN(log)
! 218: # else
! 219: # define ALIGN(log) .align log
! 220: # endif
! 221: #endif
! 222:
! 223: #ifdef _MSC_VER
! 224: // No pseudo-ops available in MS inline assembler.
! 225: # define TEXT()
! 226: #else
! 227: # define TEXT() .text
! 228: #endif
! 229:
! 230: #ifdef _MSC_VER
! 231: # define GLOBL(name)
! 232: #else
! 233: # define GLOBL(name) .globl name
! 234: #endif
! 235:
! 236: // Define the FUNBEGIN(name) and FUNEND() macros.
! 237: #ifdef _MSC_VER
! 238: // The "naked" attribute avoids the compiler generated prologue and epilogue
! 239: // (which saves the registers %ebx,%esi,%edi if no optimization is enabled,
! 240: // and those registers among %ebx,%esi,%edi which occur in the asm code
! 241: // if optimization is enabled).
! 242: # define FUNBEGIN(name) __declspec(naked) void name () { __asm {
! 243: # define FUNEND() } }
! 244: #else
! 245: # define FUNBEGIN(name) C(name##:)
! 246: # define FUNEND()
! 247: #endif
! 248:
! 249: #define _
! 250:
! 251: // Here we go!
! 252:
! 253: TEXT()
! 254:
! 255: // Rules about registers:
! 256: // Registers %eax,%edx,%ecx may be freely used.
! 257: // Registers %ebx,%esi,%edi must be saved before being used.
! 258: // Don't fiddle with register %ebp - some platforms don't like this.
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to l0asm.txt CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / pari / src / kernel / ix86