mirror of
https://github.com/verilator/verilator.git
synced 2025-01-19 12:54:02 +00:00
96a4b3e5a5
- Regroup and sort #include directives (like we used to, but automatic) - Set AlwaysBreakTemplateDeclarations to true
827 lines
26 KiB
C++
827 lines
26 KiB
C++
// -*- mode: C++; c-file-style: "cc-mode" -*-
|
|
//*************************************************************************
|
|
//
|
|
// Copyright 2020 by Yutetsu TAKATSUKASA. This program is free software; you can
|
|
// redistribute it and/or modify it under the terms of either the GNU
|
|
// Lesser General Public License Version 3 or the Perl Artistic License
|
|
// Version 2.0.
|
|
// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
|
|
//
|
|
//*************************************************************************
|
|
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <vector>
|
|
|
|
// clang-format off
|
|
#if defined(NCSC)
|
|
// Used by NC's svdpi.h to pick up svLogicVecVal with _.aval and _.bval fields,
|
|
// rather than the IEEE 1800-2005 version which has _.a and _.b fields.
|
|
# define DPI_COMPATIBILITY_VERSION_1800v2012
|
|
#endif
|
|
|
|
#include "svdpi.h"
|
|
|
|
#if defined(VERILATOR) // Verilator
|
|
# include "Vt_dpi_arg_input_unpack__Dpi.h"
|
|
typedef long long sv_longint_t;
|
|
typedef unsigned long long sv_longint_unsigned_t;
|
|
typedef const void** sv_chandle_array_ptr_t;
|
|
# define NO_SHORTREAL
|
|
# define NO_UNPACK_STRUCT
|
|
# define CONSTARG const
|
|
#elif defined(VCS) // VCS
|
|
# include "../vc_hdrs.h"
|
|
typedef long long sv_longint_t;
|
|
typedef unsigned long long sv_longint_unsigned_t;
|
|
typedef void** sv_chandle_array_ptr_t;
|
|
# define NO_TIME
|
|
# define CONSTARG const
|
|
#elif defined(NCSC) // NC
|
|
# include "dpi-exp.h"
|
|
# include "dpi-imp.h"
|
|
typedef long long sv_longint_t;
|
|
typedef unsigned long long sv_longint_unsigned_t;
|
|
typedef void** sv_chandle_array_ptr_t;
|
|
# define NO_TIME
|
|
# define NO_INTEGER
|
|
# define NO_SHORTREAL
|
|
// Sadly NC does not declare pass-by reference input arguments as const
|
|
# define CONSTARG
|
|
#elif defined(MS) // ModelSim
|
|
# include "dpi.h"
|
|
typedef int64_t sv_longint_t;
|
|
typedef uint64_t sv_longint_unsigned_t;
|
|
typedef const void** sv_chandle_array_ptr_t;
|
|
# define CONSTARG const
|
|
#else
|
|
# error "Unknown simulator for DPI test"
|
|
#endif
|
|
// clang-format on
|
|
|
|
//======================================================================
|
|
// Implementations of imported functions
|
|
//======================================================================
|
|
|
|
namespace { // unnamed namespace
|
|
|
|
const bool VERBOSE_MESSAGE = false;
|
|
|
|
#define stop() \
|
|
do { \
|
|
printf(__FILE__ ":%d Bad value\n", __LINE__); \
|
|
abort(); \
|
|
} while (0)
|
|
|
|
template <typename T>
|
|
bool compare(const T& act, const T& exp) {
|
|
if (exp == act) {
|
|
if (VERBOSE_MESSAGE) std::cout << "OK Exp:" << exp << " actual:" << act << std::endl;
|
|
return true;
|
|
} else {
|
|
std::cout << "NG Exp:" << exp << " actual:" << act << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool compare(const svLogicVecVal* v0, sv_longint_unsigned_t val, int bitwidth) {
|
|
for (int i = 0; i < bitwidth; ++i) {
|
|
const bool act_bit = svGetBitselLogic(v0, i);
|
|
const bool exp_bit = (i < 64) ? ((val >> i) & 1) : false;
|
|
if (act_bit != exp_bit) {
|
|
std::cout << "Mismatch at bit:" << i << " exp:" << exp_bit << " act:" << act_bit;
|
|
return false;
|
|
}
|
|
}
|
|
if (VERBOSE_MESSAGE) {
|
|
std::cout << "OK " << val << " as expected (width:" << bitwidth << ")" << std::endl;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool compare(const svBitVecVal* v0, sv_longint_unsigned_t val, int bitwidth) {
|
|
for (int i = 0; i < bitwidth; ++i) {
|
|
const bool act_bit = svGetBitselBit(v0, i);
|
|
const bool exp_bit = (i < 64) ? ((val >> i) & 1) : false;
|
|
if (act_bit != exp_bit) {
|
|
std::cout << "Mismatch at bit:" << i << " exp:" << exp_bit << " act:" << act_bit;
|
|
return false;
|
|
}
|
|
}
|
|
if (VERBOSE_MESSAGE) {
|
|
std::cout << "OK " << val << " as expected (width:" << bitwidth << ")" << std::endl;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename T>
|
|
bool check_0d(T v) {
|
|
return compare<T>(v, 42);
|
|
}
|
|
template <typename T>
|
|
bool check_1d(const T* v) {
|
|
return compare<T>(v[0], 43) && compare<T>(v[1], 44);
|
|
}
|
|
template <typename T>
|
|
bool check_2d(const T* v) {
|
|
return compare<T>(v[0 * 2 + 1], 45) && compare<T>(v[1 * 2 + 1], 46)
|
|
&& compare<T>(v[2 * 2 + 1], 47);
|
|
}
|
|
template <typename T>
|
|
bool check_3d(const T* v) {
|
|
return compare<T>(v[(0 * 3 + 0) * 2 + 0], 48) && compare<T>(v[(1 * 3 + 0) * 2 + 0], 49)
|
|
&& compare<T>(v[(2 * 3 + 0) * 2 + 0], 50) && compare<T>(v[(3 * 3 + 0) * 2 + 0], 51);
|
|
}
|
|
|
|
bool check_0d(const svLogicVecVal* v, int bitwidth) { return compare(v, 42, bitwidth); }
|
|
bool check_1d(const svLogicVecVal* v, int bitwidth) {
|
|
const int unit = (bitwidth + 31) / 32;
|
|
return compare(v + unit * 0, 43, bitwidth) && compare(v + unit * 1, 44, bitwidth);
|
|
}
|
|
bool check_2d(const svLogicVecVal* v, int bitwidth) {
|
|
const int unit = (bitwidth + 31) / 32;
|
|
return compare(v + unit * (0 * 2 + 1), 45, bitwidth)
|
|
&& compare(v + unit * (1 * 2 + 1), 46, bitwidth)
|
|
&& compare(v + unit * (2 * 2 + 1), 47, bitwidth);
|
|
}
|
|
bool check_3d(const svLogicVecVal* v, int bitwidth) {
|
|
const int unit = (bitwidth + 31) / 32;
|
|
return compare(v + unit * ((0 * 3 + 0) * 2 + 0), 48, bitwidth)
|
|
&& compare(v + unit * ((1 * 3 + 0) * 2 + 0), 49, bitwidth)
|
|
&& compare(v + unit * ((2 * 3 + 0) * 2 + 0), 50, bitwidth)
|
|
&& compare(v + unit * ((3 * 3 + 0) * 2 + 0), 51, bitwidth);
|
|
}
|
|
|
|
bool check_0d(const svBitVecVal* v, int bitwidth) { return compare(v, 42, bitwidth); }
|
|
bool check_1d(const svBitVecVal* v, int bitwidth) {
|
|
const int unit = (bitwidth + 31) / 32;
|
|
return compare(v + unit * 0, 43, bitwidth) && compare(v + unit * 1, 44, bitwidth);
|
|
}
|
|
bool check_2d(const svBitVecVal* v, int bitwidth) {
|
|
const int unit = (bitwidth + 31) / 32;
|
|
return compare(v + unit * (0 * 2 + 1), 45, bitwidth)
|
|
&& compare(v + unit * (1 * 2 + 1), 46, bitwidth)
|
|
&& compare(v + unit * (2 * 2 + 1), 47, bitwidth);
|
|
}
|
|
bool check_3d(const svBitVecVal* v, int bitwidth) {
|
|
const int unit = (bitwidth + 31) / 32;
|
|
return compare(v + unit * ((0 * 3 + 0) * 2 + 0), 48, bitwidth)
|
|
&& compare(v + unit * ((1 * 3 + 0) * 2 + 0), 49, bitwidth)
|
|
&& compare(v + unit * ((2 * 3 + 0) * 2 + 0), 50, bitwidth)
|
|
&& compare(v + unit * ((3 * 3 + 0) * 2 + 0), 51, bitwidth);
|
|
}
|
|
|
|
bool check_0d(const char* v) { return compare<std::string>(v, "42"); }
|
|
bool check_1d(const char** v) {
|
|
return compare<std::string>(v[0], "43") && compare<std::string>(v[1], "44");
|
|
}
|
|
bool check_2d(const char** v) {
|
|
return compare<std::string>(v[0 * 2 + 1], "45") && compare<std::string>(v[1 * 2 + 1], "46")
|
|
&& compare<std::string>(v[2 * 2 + 1], "47");
|
|
}
|
|
bool check_3d(const char** v) {
|
|
return compare<std::string>(v[(0 * 3 + 0) * 2 + 0], "48")
|
|
&& compare<std::string>(v[(1 * 3 + 0) * 2 + 0], "49")
|
|
&& compare<std::string>(v[(2 * 3 + 0) * 2 + 0], "50")
|
|
&& compare<std::string>(v[(3 * 3 + 0) * 2 + 0], "51");
|
|
}
|
|
|
|
template <typename T>
|
|
void set_values(T (&v)[4][3][2]) {
|
|
for (int i = 0; i < 4; ++i)
|
|
for (int j = 0; j < 3; ++j)
|
|
for (int k = 0; k < 2; ++k) v[i][j][k] = 0;
|
|
v[3][2][1] = 42;
|
|
v[2][1][0] = 43;
|
|
v[2][1][1] = 44;
|
|
v[1][0][1] = 45;
|
|
v[1][1][1] = 46;
|
|
v[1][2][1] = 47;
|
|
v[0][0][0] = 48;
|
|
v[1][0][0] = 49;
|
|
v[2][0][0] = 50;
|
|
v[3][0][0] = 51;
|
|
}
|
|
|
|
void set_uint(svLogicVecVal* v0, sv_longint_unsigned_t val, int bitwidth) {
|
|
for (int i = 0; i < bitwidth; ++i) {
|
|
if (i < 64)
|
|
svPutBitselLogic(v0, i, (val >> i) & 1);
|
|
else
|
|
svPutBitselLogic(v0, i, 0);
|
|
}
|
|
}
|
|
|
|
void set_uint(svBitVecVal* v0, sv_longint_unsigned_t val, int bitwidth) {
|
|
for (int i = 0; i < bitwidth; ++i) {
|
|
if (i < 64)
|
|
svPutBitselBit(v0, i, (val >> i) & 1);
|
|
else
|
|
svPutBitselBit(v0, i, 0);
|
|
}
|
|
}
|
|
|
|
template <size_t N>
|
|
void set_values(svLogicVecVal (&v)[4][3][2][N], int bitwidth) {
|
|
for (int i = 0; i < 4; ++i)
|
|
for (int j = 0; j < 3; ++j)
|
|
for (int k = 0; k < 2; ++k) set_uint(v[i][j][k], 0, bitwidth);
|
|
set_uint(v[3][2][1], 42, bitwidth);
|
|
|
|
set_uint(v[2][1][0], 43, bitwidth);
|
|
set_uint(v[2][1][1], 44, bitwidth);
|
|
|
|
set_uint(v[1][0][1], 45, bitwidth);
|
|
set_uint(v[1][1][1], 46, bitwidth);
|
|
set_uint(v[1][2][1], 47, bitwidth);
|
|
|
|
set_uint(v[0][0][0], 48, bitwidth);
|
|
set_uint(v[1][0][0], 49, bitwidth);
|
|
set_uint(v[2][0][0], 50, bitwidth);
|
|
set_uint(v[3][0][0], 51, bitwidth);
|
|
}
|
|
|
|
template <size_t N>
|
|
void set_values(svBitVecVal (&v)[4][3][2][N], int bitwidth) {
|
|
for (int i = 0; i < 4; ++i)
|
|
for (int j = 0; j < 3; ++j)
|
|
for (int k = 0; k < 2; ++k) set_uint(v[i][j][k], 0, bitwidth);
|
|
set_uint(v[3][2][1], 42, bitwidth);
|
|
|
|
set_uint(v[2][1][0], 43, bitwidth);
|
|
set_uint(v[2][1][1], 44, bitwidth);
|
|
|
|
set_uint(v[1][0][1], 45, bitwidth);
|
|
set_uint(v[1][1][1], 46, bitwidth);
|
|
set_uint(v[1][2][1], 47, bitwidth);
|
|
|
|
set_uint(v[0][0][0], 48, bitwidth);
|
|
set_uint(v[1][0][0], 49, bitwidth);
|
|
set_uint(v[2][0][0], 50, bitwidth);
|
|
set_uint(v[3][0][0], 51, bitwidth);
|
|
}
|
|
|
|
sv_chandle_array_ptr_t add_const(void** ptr) {
|
|
return static_cast<sv_chandle_array_ptr_t>(static_cast<void*>(ptr));
|
|
}
|
|
|
|
} // unnamed namespace
|
|
|
|
void* get_non_null() {
|
|
static int v;
|
|
return &v;
|
|
}
|
|
|
|
void i_byte_0d(char v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_byte_1d(const char* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_byte_2d(const char* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_byte_3d(const char* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_byte_unsigned_0d(unsigned char v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_byte_unsigned_1d(const unsigned char* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_byte_unsigned_2d(const unsigned char* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_byte_unsigned_3d(const unsigned char* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_shortint_0d(short v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_shortint_1d(const short* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_shortint_2d(const short* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_shortint_3d(const short* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_shortint_unsigned_0d(unsigned short v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_shortint_unsigned_1d(const unsigned short* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_shortint_unsigned_2d(const unsigned short* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_shortint_unsigned_3d(const unsigned short* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_int_0d(int v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_int_1d(const int* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_int_2d(const int* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_int_3d(const int* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_int_unsigned_0d(unsigned v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_int_unsigned_1d(const unsigned* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_int_unsigned_2d(const unsigned* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_int_unsigned_3d(const unsigned* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_longint_0d(sv_longint_t v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_longint_1d(const sv_longint_t* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_longint_2d(const sv_longint_t* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_longint_3d(const sv_longint_t* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_longint_unsigned_0d(sv_longint_unsigned_t v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_longint_unsigned_1d(const sv_longint_unsigned_t* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_longint_unsigned_2d(const sv_longint_unsigned_t* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_longint_unsigned_3d(const sv_longint_unsigned_t* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
#ifndef NO_TIME
|
|
void i_time_0d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_0d(v, 64)) stop();
|
|
}
|
|
void i_time_1d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_1d(v, 64)) stop();
|
|
}
|
|
void i_time_2d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_2d(v, 64)) stop();
|
|
}
|
|
void i_time_3d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_3d(v, 64)) stop();
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_INTEGER
|
|
void i_integer_0d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_0d(v, 32)) stop();
|
|
}
|
|
void i_integer_1d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_1d(v, 32)) stop();
|
|
}
|
|
void i_integer_2d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_2d(v, 32)) stop();
|
|
}
|
|
void i_integer_3d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_3d(v, 32)) stop();
|
|
}
|
|
#endif
|
|
|
|
void i_real_0d(double v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_real_1d(CONSTARG double* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_real_2d(CONSTARG double* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_real_3d(CONSTARG double* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
#ifndef NO_SHORTREAL
|
|
void i_shortreal_0d(float v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_shortreal_1d(CONSTARG float* v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_shortreal_2d(CONSTARG float* v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_shortreal_3d(CONSTARG float* v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
#endif
|
|
|
|
void i_chandle_0d(void* v) {
|
|
if (!v) stop();
|
|
}
|
|
void i_chandle_1d(sv_chandle_array_ptr_t v) {
|
|
if (!v[0]) stop();
|
|
if (!v[1]) stop();
|
|
}
|
|
void i_chandle_2d(sv_chandle_array_ptr_t v) {
|
|
if (!v[2 * 0 + 1]) stop();
|
|
if (!v[2 * 1 + 1]) stop();
|
|
if (!v[2 * 2 + 1]) stop();
|
|
}
|
|
void i_chandle_3d(sv_chandle_array_ptr_t v) {
|
|
if (!v[(0 * 3 + 0) * 2 + 0]) stop();
|
|
if (!v[(1 * 3 + 0) * 2 + 0]) stop();
|
|
if (!v[(2 * 3 + 0) * 2 + 0]) stop();
|
|
if (!v[(3 * 3 + 0) * 2 + 0]) stop();
|
|
}
|
|
|
|
void i_string_0d(CONSTARG char* v) {
|
|
if (!check_0d(v)) stop();
|
|
}
|
|
void i_string_1d(CONSTARG char** v) {
|
|
if (!check_1d(v)) stop();
|
|
}
|
|
void i_string_2d(CONSTARG char** v) {
|
|
if (!check_2d(v)) stop();
|
|
}
|
|
void i_string_3d(CONSTARG char** v) {
|
|
if (!check_3d(v)) stop();
|
|
}
|
|
|
|
void i_bit1_0d(CONSTARG svBit v) {
|
|
if (!compare<svScalar>(v, sv_0)) stop();
|
|
}
|
|
void i_bit1_1d(CONSTARG svBit* v) {
|
|
if (!compare<svScalar>(v[0], sv_1)) stop();
|
|
if (!compare<svScalar>(v[1], sv_0)) stop();
|
|
}
|
|
void i_bit1_2d(CONSTARG svBit* v) {
|
|
if (!compare<svScalar>(v[0 * 2 + 1], sv_1)) stop();
|
|
if (!compare<svScalar>(v[1 * 2 + 1], sv_0)) stop();
|
|
if (!compare<svScalar>(v[2 * 2 + 1], sv_1)) stop();
|
|
}
|
|
void i_bit1_3d(CONSTARG svBit* v) {
|
|
if (!compare<svScalar>(v[(0 * 3 + 0) * 2 + 0], sv_0)) stop();
|
|
if (!compare<svScalar>(v[(1 * 3 + 0) * 2 + 0], sv_1)) stop();
|
|
if (!compare<svScalar>(v[(2 * 3 + 0) * 2 + 0], sv_0)) stop();
|
|
if (!compare<svScalar>(v[(3 * 3 + 0) * 2 + 0], sv_1)) stop();
|
|
}
|
|
|
|
void i_bit7_0d(CONSTARG svBitVecVal* v) {
|
|
if (!check_0d(v, 7)) stop();
|
|
}
|
|
void i_bit7_1d(CONSTARG svBitVecVal* v) {
|
|
if (!check_1d(v, 7)) stop();
|
|
}
|
|
void i_bit7_2d(CONSTARG svBitVecVal* v) {
|
|
if (!check_2d(v, 7)) stop();
|
|
}
|
|
void i_bit7_3d(CONSTARG svBitVecVal* v) {
|
|
if (!check_3d(v, 7)) stop();
|
|
}
|
|
|
|
void i_bit121_0d(CONSTARG svBitVecVal* v) {
|
|
if (!check_0d(v, 121)) stop();
|
|
}
|
|
void i_bit121_1d(CONSTARG svBitVecVal* v) {
|
|
if (!check_1d(v, 121)) stop();
|
|
}
|
|
void i_bit121_2d(CONSTARG svBitVecVal* v) {
|
|
if (!check_2d(v, 121)) stop();
|
|
}
|
|
void i_bit121_3d(CONSTARG svBitVecVal* v) {
|
|
if (!check_3d(v, 121)) stop();
|
|
}
|
|
|
|
void i_logic1_0d(CONSTARG svLogic v) {
|
|
if (!compare<svScalar>(v, sv_0)) stop();
|
|
}
|
|
void i_logic1_1d(CONSTARG svLogic* v) {
|
|
if (!compare<svScalar>(v[0], sv_1)) stop();
|
|
if (!compare<svScalar>(v[1], sv_0)) stop();
|
|
}
|
|
void i_logic1_2d(CONSTARG svLogic* v) {
|
|
if (!compare<svScalar>(v[0 * 2 + 1], sv_1)) stop();
|
|
if (!compare<svScalar>(v[1 * 2 + 1], sv_0)) stop();
|
|
if (!compare<svScalar>(v[2 * 2 + 1], sv_1)) stop();
|
|
}
|
|
void i_logic1_3d(CONSTARG svLogic* v) {
|
|
if (!compare<svScalar>(v[(0 * 3 + 0) * 2 + 0], sv_0)) stop();
|
|
if (!compare<svScalar>(v[(1 * 3 + 0) * 2 + 0], sv_1)) stop();
|
|
if (!compare<svScalar>(v[(2 * 3 + 0) * 2 + 0], sv_0)) stop();
|
|
if (!compare<svScalar>(v[(3 * 3 + 0) * 2 + 0], sv_1)) stop();
|
|
}
|
|
|
|
void i_logic7_0d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_0d(v, 7)) stop();
|
|
}
|
|
void i_logic7_1d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_1d(v, 7)) stop();
|
|
}
|
|
void i_logic7_2d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_2d(v, 7)) stop();
|
|
}
|
|
void i_logic7_3d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_3d(v, 7)) stop();
|
|
}
|
|
|
|
void i_logic121_0d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_0d(v, 121)) stop();
|
|
}
|
|
void i_logic121_1d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_1d(v, 121)) stop();
|
|
}
|
|
void i_logic121_2d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_2d(v, 121)) stop();
|
|
}
|
|
void i_logic121_3d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_3d(v, 121)) stop();
|
|
}
|
|
|
|
void i_pack_struct_0d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_0d(v, 7)) stop();
|
|
}
|
|
void i_pack_struct_1d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_1d(v, 7)) stop();
|
|
}
|
|
void i_pack_struct_2d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_2d(v, 7)) stop();
|
|
}
|
|
void i_pack_struct_3d(CONSTARG svLogicVecVal* v) {
|
|
if (!check_3d(v, 7)) stop();
|
|
}
|
|
|
|
#ifndef NO_UNPACK_STRUCT
|
|
void i_unpack_struct_0d(CONSTARG unpack_struct_t* v) {
|
|
if (!compare(v->val, 42, 121)) stop();
|
|
}
|
|
void i_unpack_struct_1d(CONSTARG unpack_struct_t* v) {
|
|
if (!compare(v[0].val, 43, 121)) stop();
|
|
if (!compare(v[1].val, 44, 121)) stop();
|
|
}
|
|
void i_unpack_struct_2d(CONSTARG unpack_struct_t* v) {
|
|
if (!compare(v[0 * 2 + 1].val, 45, 121)) stop();
|
|
if (!compare(v[1 * 2 + 1].val, 46, 121)) stop();
|
|
if (!compare(v[2 * 2 + 1].val, 47, 121)) stop();
|
|
}
|
|
void i_unpack_struct_3d(CONSTARG unpack_struct_t* v) {
|
|
if (!compare(v[(0 * 3 + 0) * 2 + 0].val, 48, 121)) stop();
|
|
if (!compare(v[(1 * 3 + 0) * 2 + 0].val, 49, 121)) stop();
|
|
if (!compare(v[(2 * 3 + 0) * 2 + 0].val, 50, 121)) stop();
|
|
if (!compare(v[(3 * 3 + 0) * 2 + 0].val, 51, 121)) stop();
|
|
}
|
|
#endif
|
|
|
|
void check_exports() {
|
|
{
|
|
char byte_array[4][3][2];
|
|
set_values(byte_array);
|
|
e_byte_0d(byte_array[3][2][1]);
|
|
e_byte_1d(&byte_array[2][1][0]);
|
|
e_byte_2d(&byte_array[1][0][0]);
|
|
e_byte_3d(&byte_array[0][0][0]);
|
|
}
|
|
{
|
|
unsigned char byte_unsigned_array[4][3][2];
|
|
set_values(byte_unsigned_array);
|
|
e_byte_unsigned_0d(byte_unsigned_array[3][2][1]);
|
|
e_byte_unsigned_1d(&byte_unsigned_array[2][1][0]);
|
|
e_byte_unsigned_2d(&byte_unsigned_array[1][0][0]);
|
|
e_byte_unsigned_3d(&byte_unsigned_array[0][0][0]);
|
|
}
|
|
{
|
|
short shortint_array[4][3][2];
|
|
set_values(shortint_array);
|
|
e_shortint_0d(shortint_array[3][2][1]);
|
|
e_shortint_1d(&shortint_array[2][1][0]);
|
|
e_shortint_2d(&shortint_array[1][0][0]);
|
|
e_shortint_3d(&shortint_array[0][0][0]);
|
|
}
|
|
{
|
|
unsigned short shortint_unsigned_array[4][3][2];
|
|
set_values(shortint_unsigned_array);
|
|
e_shortint_unsigned_0d(shortint_unsigned_array[3][2][1]);
|
|
e_shortint_unsigned_1d(&shortint_unsigned_array[2][1][0]);
|
|
e_shortint_unsigned_2d(&shortint_unsigned_array[1][0][0]);
|
|
e_shortint_unsigned_3d(&shortint_unsigned_array[0][0][0]);
|
|
}
|
|
{
|
|
int int_array[4][3][2];
|
|
set_values(int_array);
|
|
e_int_0d(int_array[3][2][1]);
|
|
e_int_1d(&int_array[2][1][0]);
|
|
e_int_2d(&int_array[1][0][0]);
|
|
e_int_3d(&int_array[0][0][0]);
|
|
}
|
|
{
|
|
unsigned int int_unsigned_array[4][3][2];
|
|
set_values(int_unsigned_array);
|
|
e_int_unsigned_0d(int_unsigned_array[3][2][1]);
|
|
e_int_unsigned_1d(&int_unsigned_array[2][1][0]);
|
|
e_int_unsigned_2d(&int_unsigned_array[1][0][0]);
|
|
e_int_unsigned_3d(&int_unsigned_array[0][0][0]);
|
|
}
|
|
{
|
|
sv_longint_t longint_array[4][3][2];
|
|
set_values(longint_array);
|
|
e_longint_0d(longint_array[3][2][1]);
|
|
e_longint_1d(&longint_array[2][1][0]);
|
|
e_longint_2d(&longint_array[1][0][0]);
|
|
e_longint_3d(&longint_array[0][0][0]);
|
|
}
|
|
{
|
|
sv_longint_unsigned_t longint_unsigned_array[4][3][2];
|
|
set_values(longint_unsigned_array);
|
|
e_longint_unsigned_0d(longint_unsigned_array[3][2][1]);
|
|
e_longint_unsigned_1d(&longint_unsigned_array[2][1][0]);
|
|
e_longint_unsigned_2d(&longint_unsigned_array[1][0][0]);
|
|
e_longint_unsigned_3d(&longint_unsigned_array[0][0][0]);
|
|
}
|
|
#ifndef NO_TIME
|
|
{
|
|
svLogicVecVal time_array[4][3][2][2];
|
|
set_values(time_array, 64);
|
|
e_time_0d(time_array[3][2][1]);
|
|
e_time_1d(time_array[2][1][0]);
|
|
e_time_2d(&time_array[1][0][0][0]);
|
|
e_time_3d(time_array[0][0][0]);
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_INTEGER
|
|
{
|
|
svLogicVecVal integer_array[4][3][2][1];
|
|
set_values(integer_array, 32);
|
|
e_integer_0d(integer_array[3][2][1]);
|
|
e_integer_1d(integer_array[2][1][0]);
|
|
e_integer_2d(&integer_array[1][0][0][0]);
|
|
e_integer_3d(integer_array[0][0][0]);
|
|
}
|
|
#endif
|
|
|
|
{
|
|
double real_array[4][3][2];
|
|
set_values(real_array);
|
|
e_real_0d(real_array[3][2][1]);
|
|
e_real_1d(&real_array[2][1][0]);
|
|
e_real_2d(&real_array[1][0][0]);
|
|
e_real_3d(&real_array[0][0][0]);
|
|
}
|
|
#ifndef NO_SHORTREAL
|
|
{
|
|
float shortreal_array[4][3][2];
|
|
set_values(shortreal_array);
|
|
e_shortreal_0d(shortreal_array[3][2][1]);
|
|
e_shortreal_1d(&shortreal_array[2][1][0]);
|
|
e_shortreal_2d(&shortreal_array[1][0][0]);
|
|
e_shortreal_3d(&shortreal_array[0][0][0]);
|
|
}
|
|
#endif
|
|
|
|
{
|
|
void* chandle_array[4][3][2];
|
|
for (int i = 0; i < 4; ++i)
|
|
for (int j = 0; j < 3; ++j)
|
|
for (int k = 0; k < 2; ++k) chandle_array[i][j][k] = NULL;
|
|
chandle_array[3][2][1] = get_non_null();
|
|
chandle_array[2][1][0] = get_non_null();
|
|
chandle_array[2][1][1] = get_non_null();
|
|
|
|
chandle_array[1][0][1] = get_non_null();
|
|
chandle_array[1][1][1] = get_non_null();
|
|
chandle_array[1][2][1] = get_non_null();
|
|
|
|
chandle_array[0][0][0] = get_non_null();
|
|
chandle_array[1][0][0] = get_non_null();
|
|
chandle_array[2][0][0] = get_non_null();
|
|
chandle_array[3][0][0] = get_non_null();
|
|
|
|
e_chandle_0d(chandle_array[3][2][1]);
|
|
e_chandle_1d(add_const(&chandle_array[2][1][0]));
|
|
e_chandle_2d(add_const(&chandle_array[1][0][0]));
|
|
e_chandle_3d(add_const(&chandle_array[0][0][0]));
|
|
}
|
|
|
|
{
|
|
std::vector<char> buf;
|
|
buf.resize(4 * 3 * 2 * 16, '\0');
|
|
buf[((3 * 3 + 2) * 2 + 1) * 16 + 0] = '4';
|
|
buf[((3 * 3 + 2) * 2 + 1) * 16 + 1] = '2';
|
|
buf[((2 * 3 + 1) * 2 + 0) * 16 + 0] = '4';
|
|
buf[((2 * 3 + 1) * 2 + 0) * 16 + 1] = '3';
|
|
buf[((2 * 3 + 1) * 2 + 1) * 16 + 0] = '4';
|
|
buf[((2 * 3 + 1) * 2 + 1) * 16 + 1] = '4';
|
|
buf[((1 * 3 + 0) * 2 + 1) * 16 + 0] = '4';
|
|
buf[((1 * 3 + 0) * 2 + 1) * 16 + 1] = '5';
|
|
buf[((1 * 3 + 1) * 2 + 1) * 16 + 0] = '4';
|
|
buf[((1 * 3 + 1) * 2 + 1) * 16 + 1] = '6';
|
|
buf[((1 * 3 + 2) * 2 + 1) * 16 + 0] = '4';
|
|
buf[((1 * 3 + 2) * 2 + 1) * 16 + 1] = '7';
|
|
buf[((0 * 3 + 0) * 2 + 0) * 16 + 0] = '4';
|
|
buf[((0 * 3 + 0) * 2 + 0) * 16 + 1] = '8';
|
|
buf[((1 * 3 + 0) * 2 + 0) * 16 + 0] = '4';
|
|
buf[((1 * 3 + 0) * 2 + 0) * 16 + 1] = '9';
|
|
buf[((2 * 3 + 0) * 2 + 0) * 16 + 0] = '5';
|
|
buf[((2 * 3 + 0) * 2 + 0) * 16 + 1] = '0';
|
|
buf[((3 * 3 + 0) * 2 + 0) * 16 + 0] = '5';
|
|
buf[((3 * 3 + 0) * 2 + 0) * 16 + 1] = '1';
|
|
const char* string_array[4][3][2];
|
|
for (int i = 0; i < 4; ++i)
|
|
for (int j = 0; j < 3; ++j)
|
|
for (int k = 0; k < 2; ++k)
|
|
string_array[i][j][k] = buf.data() + ((i * 3 + j) * 2 + k) * 16;
|
|
e_string_0d(string_array[3][2][1]);
|
|
e_string_1d(&string_array[2][1][0]);
|
|
e_string_2d(&string_array[1][0][0]);
|
|
e_string_3d(&string_array[0][0][0]);
|
|
}
|
|
|
|
{
|
|
svBitVecVal bit7_array[4][3][2][1];
|
|
set_values(bit7_array, 7);
|
|
e_bit7_0d(bit7_array[3][2][1]);
|
|
e_bit7_1d(bit7_array[2][1][0]);
|
|
e_bit7_2d(bit7_array[1][0][0]);
|
|
e_bit7_3d(bit7_array[0][0][0]);
|
|
}
|
|
|
|
{
|
|
svBitVecVal bit121_array[4][3][2][4];
|
|
set_values(bit121_array, 121);
|
|
e_bit121_0d(bit121_array[3][2][1]);
|
|
e_bit121_1d(bit121_array[2][1][0]);
|
|
e_bit121_2d(bit121_array[1][0][0]);
|
|
e_bit121_3d(bit121_array[0][0][0]);
|
|
}
|
|
|
|
{
|
|
svLogicVecVal logic7_array[4][3][2][1];
|
|
set_values(logic7_array, 7);
|
|
e_logic7_0d(logic7_array[3][2][1]);
|
|
e_logic7_1d(logic7_array[2][1][0]);
|
|
e_logic7_2d(logic7_array[1][0][0]);
|
|
e_logic7_3d(logic7_array[0][0][0]);
|
|
}
|
|
|
|
{
|
|
svLogicVecVal logic121_array[4][3][2][4];
|
|
set_values(logic121_array, 121);
|
|
e_logic121_0d(logic121_array[3][2][1]);
|
|
e_logic121_1d(logic121_array[2][1][0]);
|
|
e_logic121_2d(logic121_array[1][0][0]);
|
|
e_logic121_3d(logic121_array[0][0][0]);
|
|
}
|
|
|
|
{
|
|
svLogicVecVal pack_struct_array[4][3][2][1];
|
|
set_values(pack_struct_array, 7);
|
|
e_pack_struct_0d(pack_struct_array[3][2][1]);
|
|
e_pack_struct_1d(pack_struct_array[2][1][0]);
|
|
e_pack_struct_2d(pack_struct_array[1][0][0]);
|
|
e_pack_struct_3d(pack_struct_array[0][0][0]);
|
|
}
|
|
|
|
#ifndef NO_UNPACK_STRUCT
|
|
{
|
|
unpack_struct_t unpack_struct_array[4][3][2];
|
|
set_uint(unpack_struct_array[3][2][1].val, 42, 121);
|
|
|
|
set_uint(unpack_struct_array[2][1][0].val, 43, 121);
|
|
set_uint(unpack_struct_array[2][1][1].val, 44, 121);
|
|
|
|
set_uint(unpack_struct_array[1][0][1].val, 45, 121);
|
|
set_uint(unpack_struct_array[1][1][1].val, 46, 121);
|
|
set_uint(unpack_struct_array[1][2][1].val, 47, 121);
|
|
|
|
set_uint(unpack_struct_array[0][0][0].val, 48, 121);
|
|
set_uint(unpack_struct_array[1][0][0].val, 49, 121);
|
|
set_uint(unpack_struct_array[2][0][0].val, 50, 121);
|
|
set_uint(unpack_struct_array[3][0][0].val, 51, 121);
|
|
e_unpack_struct_0d(&unpack_struct_array[3][2][1]);
|
|
e_unpack_struct_1d(&unpack_struct_array[2][1][0]);
|
|
e_unpack_struct_2d(&unpack_struct_array[1][0][0]);
|
|
e_unpack_struct_3d(&unpack_struct_array[0][0][0]);
|
|
}
|
|
#endif
|
|
}
|