altivec.h

gcc-you can use this code to learn something about gcc, and inquire further into linux,

/* PowerPC AltiVec include file.
   Copyright (C) 2002 Free Software Foundation, Inc.
   Contributed by Aldy Hernandez ([e-mail]).

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

/* As a special exception, if you include this header file into source
   files compiled by GCC, this header file does not by itself cause
   the resulting executable to be covered by the GNU General Public
   License.  This exception does not however invalidate any other
   reasons why the executable file might be covered by the GNU General
   Public License.  */

/* Implemented to conform to the specification included in the AltiVec
   Technology Programming Interface Manual (ALTIVECPIM/D 6/1999 Rev 0).  */

#ifndef _ALTIVEC_H
#define _ALTIVEC_H 1

/* Required by Motorola specs.  */
#define __VEC__ 10206

#ifndef __ALTIVEC__
#define __ALTIVEC__ 1
#endif

#define __vector __attribute__((vector_size(16)))

/* You are allowed to undef this for C++ compatability.  */
#define vector __vector

#define bool signed
#define pixel unsigned short
#define __pixel unsigned short

/* Dummy prototype.  */
extern int __altivec_link_error_invalid_argument ();

/* Helper macros.  */

#define __CR6_EQ		0
#define __CR6_EQ_REV		1
#define __CR6_LT		2
#define __CR6_LT_REV		3

#define __bin_args_eq(xtype, x, ytype, y)				\
	(__builtin_types_compatible_p (xtype, typeof (x))		\
	 && __builtin_types_compatible_p (ytype, typeof (y)))

#define __un_args_eq(xtype, x)						\
	__builtin_types_compatible_p (xtype, typeof (x))

#define __tern_args_eq(xtype, x, ytype, y, ztype, z)                    \
        (__builtin_types_compatible_p (xtype, typeof (x))               \
         && __builtin_types_compatible_p (ytype, typeof (y))		\
	 && __builtin_types_compatible_p (ztype, typeof (z)))

#define __ch(x, y, z)	__builtin_choose_expr (x, y, z)

/* These are easy... Same exact arguments.  */

#define vec_vaddcuw vec_addc
#define vec_vand vec_and
#define vec_vandc vec_andc
#define vec_vrfip vec_ceil
#define vec_vcmpbfp vec_cmpb
#define vec_vcmpgefp vec_cmpge
#define vec_vctsxs vec_cts
#define vec_vctuxs vec_ctu
#define vec_vexptefp vec_expte
#define vec_vrfim vec_floor
#define vec_lvx vec_ld
#define vec_lvxl vec_ldl
#define vec_vlogefp vec_loge
#define vec_vmaddfp vec_madd
#define vec_vmhaddshs vec_madds
#define vec_vmladduhm vec_mladd
#define vec_vmhraddshs vec_mradds
#define vec_vnmsubfp vec_nmsub
#define vec_vnor vec_nor
#define vec_vor vec_or
#define vec_vpkpx vec_packpx
#define vec_vperm vec_perm
#define vec_vrefp vec_re
#define vec_vrfin vec_round
#define vec_vrsqrtefp vec_rsqrte
#define vec_vsel vec_sel
#define vec_vsldoi vec_sld
#define vec_vsl vec_sll
#define vec_vslo vec_slo
#define vec_vspltisb vec_splat_s8
#define vec_vspltish vec_splat_s16
#define vec_vspltisw vec_splat_s32
#define vec_vsr vec_srl
#define vec_vsro vec_sro
#define vec_stvx vec_st
#define vec_stvxl vec_stl
#define vec_vsubcuw vec_subc
#define vec_vsum2sws vec_sum2s
#define vec_vsumsws vec_sums
#define vec_vrfiz vec_trunc
#define vec_vxor vec_xor

#ifdef __cplusplus

/* Prototypes for builtins that take literals and must always be
   inlined.  */
inline vector float vec_ctf (vector unsigned int, const char) __attribute__ ((always_inline));
inline vector float vec_ctf (vector signed int, const char) __attribute__ ((always_inline));
inline vector float vec_vcfsx (vector signed int a1, const char a2) __attribute__ ((always_inline));
inline vector float vec_vcfux (vector unsigned int a1, const char a2) __attribute__ ((always_inline));
inline vector signed int vec_cts (vector float, const char) __attribute__ ((always_inline));
inline vector unsigned int vec_ctu (vector float, const char) __attribute__ ((always_inline));
inline void vec_dss (const char) __attribute__ ((always_inline));

inline void vec_dst (vector unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (vector signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (vector unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (vector signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (vector unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (vector signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (vector float *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (unsigned long *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (signed long *, int, const char) __attribute__ ((always_inline));
inline void vec_dst (float *, int, const char) __attribute__ ((always_inline));

inline void vec_dstst (vector unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (vector signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (vector unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (vector signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (vector unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (vector signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (vector float *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (unsigned long *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (signed long *, int, const char) __attribute__ ((always_inline));
inline void vec_dstst (float *, int, const char) __attribute__ ((always_inline));

inline void vec_dststt (vector unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (vector signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (vector unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (vector signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (vector unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (vector signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (vector float *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (unsigned long *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (signed long *, int, const char) __attribute__ ((always_inline));
inline void vec_dststt (float *, int, const char) __attribute__ ((always_inline));

inline void vec_dstt (vector unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (vector signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (vector unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (vector signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (vector unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (vector signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (vector float *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (unsigned char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (signed char *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (unsigned short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (signed short *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (unsigned int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (signed int *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (unsigned long *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (signed long *, int, const char) __attribute__ ((always_inline));
inline void vec_dstt (float *, int, const char) __attribute__ ((always_inline));

inline vector float vec_sld (vector float, vector float, const char) __attribute__ ((always_inline));
inline vector signed int vec_sld (vector signed int, vector signed int, const char) __attribute__ ((always_inline));
inline vector unsigned int vec_sld (vector unsigned int, vector unsigned int, const char) __attribute__ ((always_inline));
inline vector signed short vec_sld (vector signed short, vector signed short, const char) __attribute__ ((always_inline));
inline vector unsigned short vec_sld (vector unsigned short, vector unsigned short, const char) __attribute__ ((always_inline));
inline vector signed char vec_sld (vector signed char, vector signed char, const char) __attribute__ ((always_inline));
inline vector unsigned char vec_sld (vector unsigned char, vector unsigned char, const char) __attribute__ ((always_inline));
inline vector signed char vec_splat (vector signed char, const char) __attribute__ ((always_inline));
inline vector unsigned char vec_splat (vector unsigned char, const char) __attribute__ ((always_inline));
inline vector signed short vec_splat (vector signed short, const char) __attribute__ ((always_inline));
inline vector unsigned short vec_splat (vector unsigned short, const char) __attribute__ ((always_inline));
inline vector float vec_splat (vector float, const char) __attribute__ ((always_inline));
inline vector signed int vec_splat (vector signed int, const char) __attribute__ ((always_inline));
inline vector unsigned int vec_splat (vector unsigned int, const char) __attribute__ ((always_inline));
inline vector signed char vec_splat_s8 (const char) __attribute__ ((always_inline));
inline vector signed short vec_splat_s16 (const char) __attribute__ ((always_inline));
inline vector signed int vec_splat_s32 (const char) __attribute__ ((always_inline));
inline vector unsigned char vec_splat_u8 (const char) __attribute__ ((always_inline));
inline vector unsigned short vec_splat_u16 (const char) __attribute__ ((always_inline));
inline vector unsigned int vec_splat_u32 (const char) __attribute__ ((always_inline));
inline vector float vec_vspltw (vector float a1, const char a2) __attribute__ ((always_inline));
inline vector signed int vec_vspltw (vector signed int a1, const char a2) __attribute__ ((always_inline));
inline vector unsigned int vec_vspltw (vector unsigned int a1, const char a2) __attribute__ ((always_inline));
inline vector signed short vec_vsplth (vector signed short a1, const char a2) __attribute__ ((always_inline));
inline vector unsigned short vec_vsplth (vector unsigned short a1, const char a2) __attribute__ ((always_inline));
inline vector signed char vec_vspltb (vector signed char a1, const char a2) __attribute__ ((always_inline));
inline vector unsigned char vec_vspltb (vector unsigned char a1, const char a2) __attribute__ ((always_inline));

/* vec_abs */

inline vector signed char
vec_abs (vector signed char a1)
{
  return __builtin_altivec_abs_v16qi (a1);
}

inline vector signed short
vec_abs (vector signed short a1)
{
  return __builtin_altivec_abs_v8hi (a1);
}

inline vector signed int
vec_abs (vector signed int a1)
{
  return __builtin_altivec_abs_v4si (a1);
}

inline vector float
vec_abs (vector float a1)
{
  return __builtin_altivec_abs_v4sf (a1);
}

/* vec_abss */

inline vector signed char
vec_abss (vector signed char a1)
{
  return __builtin_altivec_abss_v16qi (a1);
}

inline vector signed short
vec_abss (vector signed short a1)
{
  return __builtin_altivec_abss_v8hi (a1);
}

inline vector signed int
vec_abss (vector signed int a1)
{
  return __builtin_altivec_abss_v4si (a1);
}

/* vec_add */

inline vector signed char
vec_add (vector signed char a1, vector signed char a2)
{
  return (vector signed char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

inline vector unsigned char
vec_add (vector signed char a1, vector unsigned char a2)
{
  return (vector unsigned char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

inline vector unsigned char
vec_add (vector unsigned char a1, vector signed char a2)
{
  return (vector unsigned char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

inline vector unsigned char
vec_add (vector unsigned char a1, vector unsigned char a2)
{
  return (vector unsigned char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

inline vector signed short
vec_add (vector signed short a1, vector signed short a2)
{
  return (vector signed short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

inline vector unsigned short
vec_add (vector signed short a1, vector unsigned short a2)
{
  return (vector unsigned short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

inline vector unsigned short
vec_add (vector unsigned short a1, vector signed short a2)
{
  return (vector unsigned short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

inline vector unsigned short
vec_add (vector unsigned short a1, vector unsigned short a2)
{
  return (vector unsigned short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

inline vector signed int
vec_add (vector signed int a1, vector signed int a2)
{
  return (vector signed int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

inline vector unsigned int
vec_add (vector signed int a1, vector unsigned int a2)
{
  return (vector unsigned int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

inline vector unsigned int
vec_add (vector unsigned int a1, vector signed int a2)
{
  return (vector unsigned int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

inline vector unsigned int
vec_add (vector unsigned int a1, vector unsigned int a2)
{
  return (vector unsigned int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

inline vector float
vec_add (vector float a1, vector float a2)
{
  return (vector float) __builtin_altivec_vaddfp ((vector float) a1, (vector float) a2);
}

/* vec_vaddfp */

inline vector float
vec_vaddfp (vector float a1, vector float a2)
{
  return (vector float) __builtin_altivec_vaddfp ((vector float) a1, (vector float) a2);
}

/* vec_vadduwm */

inline vector signed int
vec_vadduwm (vector signed int a1, vector signed int a2)
{
  return (vector signed int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

inline vector unsigned int
vec_vadduwm (vector signed int a1, vector unsigned int a2)
{
  return (vector unsigned int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

inline vector unsigned int
vec_vadduwm (vector unsigned int a1, vector signed int a2)
{
  return (vector unsigned int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

inline vector unsigned int
vec_vadduwm (vector unsigned int a1, vector unsigned int a2)
{
  return (vector unsigned int) __builtin_altivec_vadduwm ((vector signed int) a1, (vector signed int) a2);
}

/* vec_vadduhm */

inline vector signed short
vec_vadduhm (vector signed short a1, vector signed short a2)
{
  return (vector signed short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

inline vector unsigned short
vec_vadduhm (vector signed short a1, vector unsigned short a2)
{
  return (vector unsigned short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

inline vector unsigned short
vec_vadduhm (vector unsigned short a1, vector signed short a2)
{
  return (vector unsigned short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

inline vector unsigned short
vec_vadduhm (vector unsigned short a1, vector unsigned short a2)
{
  return (vector unsigned short) __builtin_altivec_vadduhm ((vector signed short) a1, (vector signed short) a2);
}

/* vec_vaddubm */

inline vector signed char
vec_vaddubm (vector signed char a1, vector signed char a2)
{
  return (vector signed char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

inline vector unsigned char
vec_vaddubm (vector signed char a1, vector unsigned char a2)
{
  return (vector unsigned char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

inline vector unsigned char
vec_vaddubm (vector unsigned char a1, vector signed char a2)
{
  return (vector unsigned char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

inline vector unsigned char
vec_vaddubm (vector unsigned char a1, vector unsigned char a2)
{
  return (vector unsigned char) __builtin_altivec_vaddubm ((vector signed char) a1, (vector signed char) a2);
}

/* vec_addc */

inline vector unsigned int
vec_addc (vector unsigned int a1, vector unsigned int a2)
{
  return (vector unsigned int) __builtin_altivec_vaddcuw ((vector signed int) a1, (vector signed int) a2);
}

/* vec_adds */

inline vector unsigned char
vec_adds (vector signed char a1, vector unsigned char a2)
{