symm/rijndael-x86ish-aesni.S: Move setup of endswap table after prologue.

[catacomb] / base / asm-common.h

/// -*- mode: asm; asm-comment-char: ?/ -*-
///
/// Fancy SIMD implementation of Salsa20
///
/// (c) 2015 Straylight/Edgeware
///

///----- Licensing notice ---------------------------------------------------
///
/// This file is part of Catacomb.
///
/// Catacomb is free software; you can redistribute it and/or modify
/// it under the terms of the GNU Library General Public License as
/// published by the Free Software Foundation; either version 2 of the
/// License, or (at your option) any later version.
///
/// Catacomb is distributed in the hope that it will be useful,
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
/// GNU Library General Public License for more details.
///
/// You should have received a copy of the GNU Library General Public
/// License along with Catacomb; if not, write to the Free
/// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
/// MA 02111-1307, USA.

///--------------------------------------------------------------------------
/// General definitions.

// Some useful variables.
	.L$_subsec = 0

// Literal pools done the hard way.
#define _LIT .text .L$_subsec + 1
#define _ENDLIT .text .L$_subsec
#define _LTORG .L$_subsec = .L$_subsec + 2; .text .L$_subsec

// Announcing an external function.
#define FUNC(name)							\
	.globl	F(name);						\
	TYPE_FUNC(name);						\
	.macro ENDFUNC; _ENDFUNC(name); .endm;				\
	FUNC_PREHOOK(name);						\
F(name):								\
	FUNC_POSTHOOK(name)

// Marking the end of a function.
#define _ENDFUNC(name)							\
	.purgem	ENDFUNC;						\
	SIZE_OBJ(name);							\
	ENDFUNC_HOOK(name);						\
	_LTORG

// Make a helper function, if necessary.
#define AUXFN(name)							\
  .ifndef .L$_auxfn_def.name;						\
	.text 7128;							\
	.macro _ENDAUXFN; _ENDAUXFN_TAIL(name); .endm;			\
	FUNC_PREHOOK(name);						\
name:
#define _ENDAUXFN_TAIL(name)						\
	.purgem _ENDAUXFN;						\
	.text .L$_subsec;						\
	.L$_auxfn_def.name = 1
#define ENDAUXFN _ENDAUXFN; .endif

///--------------------------------------------------------------------------
/// ELF-specific hacking.

#if __ELF__

#if __PIC__ || __PIE__
#  define WANT_PIC 1
#endif

#define TYPE_FUNC(name) .type name, STT_FUNC

#define SIZE_OBJ(name) .size name, . - name

#endif

///--------------------------------------------------------------------------
/// Windows-specific hacking.

#if ABI_WIN

#if CPUFAM_X86
#  define F(name) _##name
#endif

#endif

///--------------------------------------------------------------------------
/// x86- and amd64-specific hacking.
///
/// It's (slightly) easier to deal with both of these in one go.

#if CPUFAM_X86 || CPUFAM_AMD64

// Set the function hooks.
#define FUNC_PREHOOK(_) .balign 16

// Don't use the wretched AT&T syntax.  It's festooned with pointless
// punctuation, and all of the data movement is backwards.  Ugh!
	.intel_syntax noprefix

// Call external subroutine at ADDR, possibly via PLT.
.macro	callext addr
#if WANT_PIC
	call	\addr@PLT
#else
	call	\addr
#endif
.endm

// Do I need to arrange a spare GOT register?
#if WANT_PIC && CPUFAM_X86
#  define NEED_GOT 1
#endif
#define GOTREG ebx			// Not needed in AMD64 so don't care.

// Maybe load GOT address into GOT.
.macro	ldgot got=GOTREG
#if WANT_PIC && CPUFAM_X86
  AUXFN(_ldgot.\got)
	mov	\got, [esp]
	ret
  ENDAUXFN
	call	_ldgot.\got
	add	\got, offset _GLOBAL_OFFSET_TABLE_
#endif
.endm

// Load address of external symbol ADDR into REG, maybe using GOT.
.macro	leaext reg, addr, got=GOTREG
#if WANT_PIC
#  if CPUFAM_X86
	mov	\reg, [\got + \addr@GOT]
#  endif
#  if CPUFAM_AMD64
	mov	\reg, \addr@GOTPCREL[rip]
#  endif
#else
#  if CPUFAM_X86
	mov	\reg, offset \addr
#  endif
#  if CPUFAM_AMD64
	lea	\reg, \addr[rip]
#  endif
#endif
.endm

// Address expression (possibly using a base register, and a displacement)
// referring to ADDR, which is within our module, maybe using GOT.
#define INTADDR(...) INTADDR__0(__VA_ARGS__, GOTREG, dummy)
#define INTADDR__0(addr, got, ...) INTADDR__1(addr, got)
#if CPUFAM_AMD64
#  define INTADDR__1(addr, got) addr + rip
#elif WANT_PIC
#  define INTADDR__1(addr, got) got + addr@GOTOFF
#else
#  define INTADDR__1(addr, got) addr
#endif

#endif

///--------------------------------------------------------------------------
/// ARM-specific hacking.

#if CPUFAM_ARMEL

// ARM/Thumb mode things.  Use ARM by default.
#define ARM .arm; .L$_pcoff = 8
#define THUMB .thumb; .L$_pcoff = 4
	ARM

// Set the function hooks.
#define FUNC_PREHOOK(_) .balign 4
#define ENDFUNC_HOOK(name) .ltorg

// Call external subroutine at ADDR, possibly via PLT.
.macro	callext addr, cond=
#if WANT_PIC
	bl\cond	\addr(PLT)
#else
	bl\cond	\addr
#endif
.endm

// Do I need to arrange a spare GOT register?
#if WANT_PIC
#  define NEED_GOT 1
#endif
#define GOTREG r9

// Maybe load GOT address into GOT.
.macro	ldgot	cond=, got=GOTREG
#if WANT_PIC
	ldr\cond \got, .L$_ldgot$\@
.L$_ldgot_pc$\@:
	add\cond \got, pc, \got
  _LIT
	.balign	4
.L$_ldgot$\@:
	.word	_GLOBAL_OFFSET_TABLE_ - .L$_ldgot_pc$\@ - .L$_pcoff
  _ENDLIT
#endif
.endm

// Load address of external symbol ADDR into REG, maybe using GOT.
.macro	leaext	reg, addr, cond=, got=GOTREG
#if WANT_PIC
	ldr\cond \reg, .L$_leaext$\@
	ldr\cond \reg, [\got, \reg]
  _LIT
	.balign	4
.L$_leaext$\@:
	.word	\addr(GOT)
  _ENDLIT
#else
	ldr\cond \reg, =\addr
#endif
.endm

// Load address of external symbol ADDR into REG directly.
.macro	leaextq	reg, addr, cond=
#if WANT_PIC
	ldr\cond \reg, .L$_leaextq$\@
.L$_leaextq_pc$\@:
	.if	.L$_pcoff == 8
	ldr\cond \reg, [pc, \reg]
	.else
	add\cond \reg, pc
	ldr\cond \reg, [\reg]
	.endif
  _LIT
	.balign	4
.L$_leaextq$\@:
	.word	\addr(GOT_PREL) + (. - .L$_leaextq_pc$\@ - .L$_pcoff)
  _ENDLIT
#else
	ldr\cond \reg, =\addr
#endif
.endm

#endif

///--------------------------------------------------------------------------
/// Final stuff.

// Default values for the various hooks.
#ifndef FUNC_PREHOOK
#  define FUNC_PREHOOK(name)
#endif
#ifndef FUNC_POSTHOOK
#  define FUNC_POSTHOOK(name)
#endif
#ifndef ENDFUNC_HOOK
#  define ENDFUNC_HOOK(name)
#endif

#ifndef F
#  define F(name) name
#endif

#ifndef TYPE_FUNC
#  define TYPE_FUNC(name)
#endif

#ifndef SIZE_OBJ
#  define SIZE_OBJ(name)
#endif

///----- That's all, folks --------------------------------------------------