--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/liboil/src/liboilfunction.h	Tue Aug 31 16:54:36 2010 +0300
@@ -0,0 +1,432 @@
+/*
+ * LIBOIL - Library of Optimized Inner Loops
+ * Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//Portions Copyright (c)  2008-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 
+
+#ifndef _LIBOIL_FUNCTION_H_
+#define _LIBOIL_FUNCTION_H_
+
+#include "liboil/liboilutils.h"
+#include "liboil/liboiltypes.h"
+
+/**
+ * OIL_CHECK_PROTOTYPE:
+ * @a:
+ *
+ * Macro used internally to implement the --enable-prototype-checking
+ * configure option.
+ */
+#ifdef LIBOIL_STRICT_PROTOTYPES
+#include <liboil/liboilfuncs.h>
+#define OIL_CHECK_PROTOTYPE(a) a
+#else
+#define OIL_CHECK_PROTOTYPE(a)
+#endif
+
+OIL_BEGIN_DECLS
+
+/**
+ * OilImplFlag:
+ *
+ * Implementation flags.
+ *
+ * @OIL_IMPL_FLAG_REF: is the reference implementation for the class.
+ *
+ * @OIL_IMPL_FLAG_OPT: was compiled with alternate CFLAGS as specified
+ * by --enable-alternate-optimization.
+ *
+ * @OIL_IMPL_FLAG_ASM: is written in assembly code.
+ *
+ * @OIL_IMPL_FLAG_DISABLED: is disabled.  This can be set either in the
+ * source code or during library initialization.
+ *
+ * @OIL_IMPL_FLAG_CMOV: uses the i386 instruction cmov or its variants.
+ *
+ * @OIL_IMPL_FLAG_MMX: uses MMX instructions.
+ *
+ * @OIL_IMPL_FLAG_SSE: uses SSE instructions.
+ *
+ * @OIL_IMPL_FLAG_MMXEXT: uses AMD's extended MMX instructions.  These
+ * are a subset of what Intel calls SSE2.  If an implementation uses
+ * only AMD's extended MMX instructions, it should set this flag, and
+ * not @OIL_IMPL_FLAG_SSE2.
+ *
+ * @OIL_IMPL_FLAG_SSE2: uses SSE2 instructions.  This flag implies
+ * @OIL_IMPL_FLAG_SSE and @OIL_IMPL_FLAG_MMXEXT.
+ *
+ * @OIL_IMPL_FLAG_3DNOW: uses 3DNow! instructions.
+ *
+ * @OIL_IMPL_FLAG_3DNOWEXT: uses extended 3DNow! instructions.
+ *
+ * @OIL_IMPL_FLAG_SSE3: uses SSE3 instructions.  This flag implies
+ * @OIL_IMPL_FLAG_SSE2.
+ *
+ * @OIL_IMPL_FLAG_SSSE3: uses SSSE3 instructions.  This flag implies
+ * @OIL_IMPL_FLAG_SSE3.
+ *
+ * @OIL_IMPL_FLAG_ALTIVEC: uses Altivec instructions.
+ *
+ */
+typedef enum {
+  OIL_IMPL_FLAG_REF = (1<<0),
+  OIL_IMPL_FLAG_OPT = (1<<1),
+  OIL_IMPL_FLAG_ASM = (1<<2),
+  OIL_IMPL_FLAG_DISABLED = (1<<3),
+  OIL_IMPL_FLAG_CMOV = (1<<16),
+  OIL_IMPL_FLAG_MMX = (1<<17),
+  OIL_IMPL_FLAG_SSE = (1<<18),
+  OIL_IMPL_FLAG_MMXEXT = (1<<19),
+  OIL_IMPL_FLAG_SSE2 = (1<<20),
+  OIL_IMPL_FLAG_3DNOW = (1<<21),
+  OIL_IMPL_FLAG_3DNOWEXT = (1<<22),
+  OIL_IMPL_FLAG_SSE3 = (1<<23),
+  OIL_IMPL_FLAG_ALTIVEC = (1<<24),
+  OIL_IMPL_FLAG_EDSP = (1<<25),
+  OIL_IMPL_FLAG_ARM6 = (1<<26),
+  OIL_IMPL_FLAG_VFP = (1<<27),
+  OIL_IMPL_FLAG_SSSE3 = (1<<28)
+} OilImplFlag;
+
+#ifdef OIL_ENABLE_UNSTABLE_API
+
+/**
+ * OIL_OPT_MANGLE:
+ *
+ * Used internally to implement the --enable-alternate-optimizations
+ * configure option.
+ */
+/**
+ * OIL_OPT_FLAG_MANGLE:
+ *
+ * Used internally to implement the --enable-alternate-optimizations
+ * configure option.
+ */
+/**
+ * OIL_NO_CLASSES:
+ *
+ * Used internally to implement the --enable-alternate-optimizations
+ * configure option.
+ */
+/**
+ * OIL_OPT_SUFFIX:
+ *
+ * Used internally to implement the --enable-alternate-optimizations
+ * configure option.
+ */
+#ifndef OIL_OPT_MANGLE
+#define OIL_OPT_MANGLE(a) a
+#define OIL_OPT_FLAG_MANGLE(a) a
+#else
+#define OIL_NO_CLASSES
+#define OIL_OPT_FLAG_MANGLE(a) (((a)&(~OIL_IMPL_FLAG_REF)) | OIL_IMPL_FLAG_OPT)
+#endif
+#ifndef OIL_OPT_SUFFIX
+#define OIL_OPT_SUFFIX
+#endif
+
+/**
+ * OilFunctionClass:
+ *
+ * An opaque structure representing a function class.
+ *
+ */
+struct _OilFunctionClass {
+  /*< private >*/
+    void *func;
+    const char *name;
+    const char *desc;
+    OilTestFunction test_func;
+
+    OilFunctionImpl *first_impl;
+    OilFunctionImpl *reference_impl;
+
+    OilFunctionImpl *chosen_impl;
+
+    const char *prototype;
+};
+
+/**
+ * OilFunctionImpl:
+ *
+ * An opaque structure representing a function implementation.
+ *
+ */
+struct _OilFunctionImpl {
+  /*< private >*/
+    void *next;
+    OilFunctionClass *klass;
+    void *func;
+    unsigned int flags;
+    const char *name;
+        double profile_ave;
+        double profile_std;
+};
+
+/**
+ * OIL_GET:
+ * @ptr:
+ * @offset:
+ * @type:
+ *
+ * Offsets @ptr by @offset number of bytes, and dereferences it
+ * as type @type.  Note that the offset is in bytes, and not in
+ * the size of the pointer type.
+ */
+#define OIL_GET(ptr, offset, type) (*(type *)((uint8_t *)(ptr) + (offset)) )
+/**
+ * OIL_OFFSET:
+ * @ptr:
+ * @offset:
+ *
+ * Add @offset bytes to the pointer @ptr.
+ */
+#define OIL_OFFSET(ptr, offset) ((void *)((uint8_t *)(ptr) + (offset)) )
+/**
+ * OIL_INCREMENT:
+ * @ptr:
+ * @offset:
+ *
+ * Increments the pointer @ptr by @offset number of bytes.
+ */
+#define OIL_INCREMENT(ptr, offset) (ptr = (void *)((uint8_t *)ptr + (offset)) )
+
+/**
+ * OIL_CPU_FLAG_MASK:
+ *
+ * Mask describing which bits in #OilImplFlag depend on the current
+ * CPU.
+ */
+#define OIL_CPU_FLAG_MASK 0xffff0000
+
+/**
+ * OIL_DECLARE_CLASS:
+ * @klass: the name of a function class (without the oil_ prefix)
+ *
+ * Declares the Liboil function class @klass.
+ */
+#define OIL_DECLARE_CLASS(klass) \
+    extern OilFunctionClass _oil_function_class_ ## klass
+
+/**
+ * SECTION:liboilmacros
+ * @title: Macros
+ * @short_description: Macros
+ */
+
+#ifndef OIL_NO_CLASSES
+/**
+ * OIL_DEFINE_CLASS_FULL:
+ * @klass: name of class to declare (without oil_ prefix)
+ * @string: prototype of class
+ * @test: test function
+ *
+ * Defines a #OilFunctionClass structure for @klass.  Classes
+ * defined this way will be automatically at Liboil initialization
+ * time.
+ */
+#define OIL_DEFINE_CLASS_FULL(klass, string, test) \
+OilFunctionClass _oil_function_class_ ## klass = { \
+    NULL, \
+    #klass , \
+    NULL, \
+        test, \
+        NULL, \
+        NULL, \
+        NULL, \
+        string \
+}; \
+OilFunctionClass *oil_function_class_ptr_ ## klass = \
+  &_oil_function_class_ ## klass
+#else
+#define OIL_DEFINE_CLASS_FULL(klass, string, test) \
+  OIL_DECLARE_CLASS(klass)
+#endif
+
+/**
+ * OIL_DEFINE_CLASS:
+ * @klass: name of class to declare (without oil_ prefix)
+ * @string: prototype of class
+ *
+ * Defines a #OilFunctionClass structure for @klass.  Classes
+ * defined this way will be automatically at Liboil initialization
+ * time.
+ */
+#define OIL_DEFINE_CLASS(klass, string) \
+  OIL_DEFINE_CLASS_FULL (klass, string, NULL)
+
+/**
+ * OIL_DEFINE_IMPL_FULL:
+ * @function: name of function
+ * @klass: name of class to declare (without oil_ prefix)
+ * @flags: implementation flags and CPU requirements
+ *
+ * Defines a #OilFunctionImpl structure for the function @function
+ * and class @klass.  CPU-dependent flags in @flags will indicate
+ * that this implementation requires the given CPU flags.
+ */
+
+#define OIL_DEFINE_IMPL_FULL(function,klass,flags) \
+OilFunctionImpl OIL_OPT_MANGLE(_oil_function_impl_ ## function) = { \
+    NULL, \
+    &_oil_function_class_ ## klass , \
+    (void *)function, \
+    OIL_OPT_FLAG_MANGLE(flags), \
+        #function OIL_OPT_SUFFIX \
+} \
+
+
+
+
+OIL_CHECK_PROTOTYPE(;_oil_type_ ## klass _ignore_me_ ## function = function)
+
+/**
+ * OIL_DEFINE_IMPL:
+ * @function: name of function
+ * @klass: name of class to declare (without oil_ prefix)
+ *
+ * Shorthand for defining a C implementation.  See OIL_DEFINE_IMPL_FULL().
+ */
+#define OIL_DEFINE_IMPL(function,klass) \
+    OIL_DEFINE_IMPL_FULL(function,klass,0)
+/**
+ * OIL_DEFINE_IMPL_REF:
+ * @function: name of function
+ * @klass: name of class to declare (without oil_ prefix)
+ *
+ * Shorthand for defining a reference implementation.  See OIL_DEFINE_IMPL_FULL().
+ */
+#define OIL_DEFINE_IMPL_REF(function,klass) \
+    OIL_DEFINE_IMPL_FULL(function,klass,OIL_IMPL_FLAG_REF)
+/**
+ * OIL_DEFINE_IMPL_ASM:
+ * @function: name of function
+ * @klass: name of class to declare (without oil_ prefix)
+ *
+ * Shorthand for defining an implementation written in inline
+ * assembly code.  See OIL_DEFINE_IMPL_FULL().
+ */
+#define OIL_DEFINE_IMPL_ASM(function,klass) \
+    OIL_DEFINE_IMPL_FULL(function,klass,OIL_IMPL_FLAG_ASM)
+/**
+ * OIL_DEFINE_IMPL_DEPENDS
+ * @function: name of function
+ * @klass: name of class to declare (without oil_ prefix)
+ * @...: other classes this implementation uses
+ *
+ * Shorthand for defining an implementation that uses another Liboil
+ * function class.  This is not currently used.  See
+ * OIL_DEFINE_IMPL_FULL().
+ */
+#ifndef __SYMBIAN32__
+#define OIL_DEFINE_IMPL_DEPENDS(function,klass,...) \
+    OIL_DEFINE_IMPL_FULL(function,klass,0)
+#else
+#define OIL_DEFINE_IMPL_DEPENDS(function,klass,args...) \
+    OIL_DEFINE_IMPL_FULL(function,klass,0)
+#endif
+
+
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_optimize_all (void);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_optimize (const char *class_name);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+OilFunctionClass * oil_class_get_by_index (int i);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+OilFunctionClass *oil_class_get (const char *class_name);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_class_optimize (OilFunctionClass *klass);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+int oil_class_get_n_classes (void);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+OilFunctionImpl * oil_impl_get_by_index (int i);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+int oil_impl_is_runnable (OilFunctionImpl *impl);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+int oil_impl_is_usable (OilFunctionImpl *impl);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_class_choose_by_name (OilFunctionClass * klass, const char *name);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_class_register_impl_full (OilFunctionClass * klass,
+void (*func)(void), const char *name, unsigned int flags);
+
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_class_register_impl (OilFunctionClass * klass, OilFunctionImpl *impl);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_class_register_impl_by_name (const char *klass_name,
+    OilFunctionImpl *impl);
+
+#ifdef __SYMBIAN32__
+IMPORT_C
+#endif
+void oil_init_no_optimize(void);
+
+#endif
+
+OIL_END_DECLS
+
+#endif
+