#91 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
#103 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
#133 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#146 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
#1 "/opt/Xilinx/Vivado_HLS/2015.1/lnx64/tools/gcc/bin/../lib/gcc/x86_64-unknown-linux-gnu/4.6.3/include/stddef.h" 1 3 4
#147 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
#194 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
#219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
#1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
#30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
#1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
Esempio n. 2
0
typedef int i16 __attribute__ ((__mode__ (__HI__))), i32;
/*typedef int i16;*/

int size16 = sizeof(i16);
/*int size32 = sizeof(i32); */

i16 p16;
short *ps16 = &p16;

int main(void) {
	return size16 != 2;
}
Esempio n. 3
0
/* { dg-do compile { target { powerpc*-*-darwin* powerpc*-*-aix* rs6000-*-* powerpc*-*-linux* } } } */
/* { dg-options "-O2 -mlong-double-128 -fpic" } */

typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned char uint8_t;
typedef unsigned int uint32_t;
typedef struct REGS REGS;
typedef union { uint32_t F; } FW;
typedef union { struct { FW L; } F; } DW;
typedef struct _PSW {
  DW ia;
} PSW;
struct REGS {
  PSW psw;
  DW cr[16];
};
struct ebfp {
  long double v;
};
void put_ebfp (struct ebfp *);

void s390_convert_fix32_to_bfp_ext_reg (REGS *regs)
{
  struct ebfp op1;
  int32_t op2;
  ((regs))->psw.ia.F.L.F += (4);
  if(!((regs)->cr[(0)].F.L.F & 0x00040000))
    op1.v = (long double)op2;
  put_ebfp(&op1);
}
Esempio n. 4
0
 * documentation, and that the name of M.I.T. not be used in
 * advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.
 * M.I.T. makes no representations about the suitability of
 * this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 */

#ifdef HOST_X86_WINDOWS
// Cygwin headers don't define some types, so we define them here
typedef unsigned char u_char;
typedef unsigned short int u_short;
typedef unsigned int u_int;
typedef unsigned long int u_long;

typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
#endif

#include <assert.h>
#include <netinet/tcp.h>
#include <init_instance.h>
#include <open_socket.h>
#include <netsocket.h>
#include <memsocket.h>

#ifdef ARM

void init_instance::add_incoming(int from, int to, int type) {assert(1==0);}
Esempio n. 5
0
/* PR tree-optimization/47477 */
/* { dg-do compile } */
/* { dg-options "-O2 -fdump-tree-optimized -w" } */
/* { dg-require-effective-target ilp32 } */

typedef int int64_t __attribute__ ((__mode__ (__DI__)));
typedef int * intptr_t;

typedef struct toto_s *toto_t;
toto_t add (toto_t a, toto_t b) {
  int64_t tmp = (int64_t)(intptr_t)a + ((int64_t)(intptr_t)b&~1L);
  return (toto_t)(intptr_t) tmp;
}

/* For an ILP32 target there'll be 6 casts when we start, but just 4
   if the match.pd pattern is successfully matched.  */
/* { dg-final { scan-tree-dump-times "= \\(int\\)" 1 "optimized" } } */
/* { dg-final { scan-tree-dump-times "= \\(unsigned int\\)" 2 "optimized" } } */
/* { dg-final { scan-tree-dump-times "= \\(struct toto_s \\*\\)" 1 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */


Esempio n. 6
0
    int __count;
    union   {
	unsigned int __wch;
	char __wchb[4];
    }
    __value;
} __mbstate_t;
typedef struct {
    __off_t __pos;
    __mbstate_t __state;
} _G_fpos_t;
typedef struct {
    __off64_t __pos;
    __mbstate_t __state;
} _G_fpos64_t;
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef struct _IO_FILE _IO_FILE;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
extern int fputs (__const char *__restrict __s, FILE * __restrict __stream);
extern char *strstr (__const char *__haystack, __const char *__needle)
     __attribute__ ((__nonnull__ (1, 2)));
     extern char *rindex (__const char *__s, int __c)   __attribute__ ((__nonnull__ (1)));
extern size_t strlen (__const char *__s) __attribute__ ((__nothrow__))
     __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
     char *mystrlwr (char *string);
     char *m_replace_filename (const char *path, const char *filename);
     typedef struct LINE {
	 char *text;
	 struct LINE *next;
	 int flags;
     } LINE;
Esempio n. 7
0
// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin9 %s -DHAVE
// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-gnu %s -DHAVE_NOT

#ifdef HAVE
typedef int i128 __attribute__((__mode__(TI)));
typedef unsigned u128 __attribute__((__mode__(TI)));

int a[((i128)-1 ^ (i128)-2) == 1 ? 1 : -1];
int a[(u128)-1 > 1LL ? 1 : -1];
int a[__SIZEOF_INT128__ == 16 ? 1 : -1];

// PR5435
__uint128_t b = (__uint128_t)-1;

// PR11916: Support for libstdc++ 4.7
__int128 i = (__int128)0;
unsigned __int128 u = (unsigned __int128)-1;

long long SignedTooBig = 123456789012345678901234567890; // expected-error {{integer literal is too large to be represented in any integer type}}
unsigned long long UnsignedTooBig = 123456789012345678901234567890; // expected-error {{integer literal is too large to be represented in any integer type}}

void MPI_Send(void *buf, int datatype) __attribute__(( pointer_with_type_tag(mpi,1,2) ));

static const int mpi_int __attribute__(( type_tag_for_datatype(mpi,int) )) = 10;

void test(int *buf)
{
}
#else

__int128 n; // expected-error {{__int128 is not supported on this target}}
Esempio n. 8
0
#include <_mingw.h>

#ifdef _WIN64
#ifndef __SIZEOF_INT128__
typedef signed int __xint128 __attribute__ ((__mode__ (TI)));
#else
typedef signed __int128 __xint128;
#endif

__int64 _mul128(__int64, __int64, __int64 *);

__int64 _mul128(__int64 a, __int64 b, __int64 *hi)
{
  union { __xint128 v; __int64 sv[2]; } var;
  var.v = ((__xint128) a) * ((__xint128) b);
  if (hi) *hi = var.sv[1];
  return var.sv[0];
}

#endif /* _WIN64 */


Esempio n. 9
0
// RUN: %clang_cc1 -triple i686-pc-linux-gnu -DTEST_32BIT_X86 -fsyntax-only \
// RUN:   -verify %s
// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -DTEST_64BIT_X86 -fsyntax-only \
// RUN:   -verify %s
// RUN: %clang_cc1 -triple powerpc64-pc-linux-gnu -DTEST_64BIT_PPC64 -fsyntax-only \
// RUN:   -verify %s

typedef int i16_1 __attribute((mode(HI)));
int i16_1_test[sizeof(i16_1) == 2 ? 1 : -1];
typedef int i16_2 __attribute((__mode__(__HI__)));
int i16_2_test[sizeof(i16_1) == 2 ? 1 : -1];

typedef float f64 __attribute((mode(DF)));
int f64_test[sizeof(f64) == 8 ? 1 : -1];

typedef int invalid_1 __attribute((mode)); // expected-error{{'mode' attribute takes one argument}}
typedef int invalid_2 __attribute((mode())); // expected-error{{'mode' attribute takes one argument}}
typedef int invalid_3 __attribute((mode(II))); // expected-error{{unknown machine mode}}
typedef struct {int i,j,k;} invalid_4 __attribute((mode(SI))); // expected-error{{mode attribute only supported for integer and floating-point types}}
typedef float invalid_5 __attribute((mode(SI))); // expected-error{{type of machine mode does not match type of base type}}
typedef int invalid_6 __attribute__((mode(12)));  // expected-error{{'mode' attribute requires an identifier}}

typedef unsigned unwind_word __attribute((mode(unwind_word)));

int **__attribute((mode(QI)))* i32;  // expected-error{{mode attribute}}

__attribute__((mode(QI))) int invalid_func() { return 1; } // expected-error{{'mode' attribute only applies to variables, fields and typedefs}}
enum invalid_enum { A1 __attribute__((mode(QI))) }; // expected-error{{'mode' attribute only applies to variables, fields and typedefs}}

typedef _Complex double c32 __attribute((mode(SC)));
int c32_test[sizeof(c32) == 8 ? 1 : -1];
Esempio n. 10
0
 * Author: "Salvador Fandiño <[email protected]>, Dave Rolsky <[email protected]>"
 *
 * Generated on: 2015-01-05 09:05:46
 * Math::Int128 version: 0.18
 */

#include "EXTERN.h"
#include "perl.h"
#include "ppport.h"

#if ((LONGSIZE >= 8) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)))

#if ((__GNUC__ == 4) && (__GNUC_MINOR__ < 6))

/* workaroung for gcc 4.4/4.5 - see http://gcc.gnu.org/gcc-4.4/changes.html */
typedef int int128_t __attribute__ ((__mode__ (TI)));
typedef unsigned int uint128_t __attribute__ ((__mode__ (TI)));

#else

typedef __int128 int128_t;
typedef unsigned __int128 uint128_t;

#endif


HV *math_int128_c_api_hash = NULL;
int math_int128_c_api_min_version = 0;
int math_int128_c_api_max_version = 0;

int128_t  (*math_int128_c_api_SvI128)(pTHX_ SV *sv) = NULL;
Esempio n. 11
0
 typedef signed int signed16 __attribute__ ((__mode__ (__HI__)));
 typedef unsigned int unsigned16 __attribute__ ((__mode__ (__HI__)));
 typedef signed16 HI;
 typedef unsigned16 UHI;
unsigned short f(int y)
{
  HI tmp_b4;
  tmp_b4 = y;
  UHI opval;
  if (tmp_b4 == -32768)
    opval = 32767;
  else
   opval = -tmp_b4;
 return opval;
}

Esempio n. 12
0
   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <stdint.h>
#include <shlib-compat.h>

#if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_2_6)

typedef int int128_t __attribute__((__mode__(TI)));

extern int128_t __multi3 (int128_t, int128_t);
int128_t INTUSE (__multi3) (int128_t x, int128_t y)
{
  return __multi3 (x, y);
}
symbol_version (INTUSE (__multi3), __multi3, GLIBC_2.0);

#endif