void DoArrayLoad(short id, short ptr)
/*
* id is ST index, ptr is DT index
*/
{
short areg, type, ld;
#ifdef X86_64
short k;
k = (ptr-1)<<2;
#endif
type = FLAG2TYPE(STflag[id-1]);
FixDeref(ptr);
switch(type)
{
case T_INT:
/*
* Special case for integer arrays, which are still 32-bits on x86-64
*/
#ifdef X86_64
areg = GetReg(T_SHORT);
InsNewInst(NULL, NULL, NULL, LDS, -areg, ptr, 0);
if (!IS_UNSIGNED(STflag[id-1]))
{
/*
* FIXME: should use CVTSI (movslq) instruction to upgrade
*/
k = STiconstlookup(31);
InsNewInst(NULL, NULL, NULL, SHL, -areg, -areg, k);
InsNewInst(NULL, NULL, NULL, SAR, -areg, -areg, k);
LocalStore(id, areg);
GetReg(-1);
return;
}
#endif
ld = LD;
break;
case T_FLOAT:
ld = FLD;
break;
case T_DOUBLE:
ld = FLDD;
break;
#if 1
case T_VFLOAT:
ld = VFLD;
break;
case T_VDOUBLE:
ld = VDLD;
break;
#endif
default:
fko_error(__LINE__, "Unknown type %d\n", type);
}
areg = GetReg(type);
InsNewInst(NULL, NULL, NULL, ld, -areg, ptr, 0);
LocalStore(id, areg);
GetReg(-1);
}
static ucl_bool basic_ptr_check(void)
{
ucl_bool r = 1;
ucl_bool sanity;
r &= __ucl_assert(sizeof(char *) >= sizeof(int));
r &= __ucl_assert(sizeof(ucl_byte *) >= sizeof(char *));
r &= __ucl_assert(sizeof(ucl_voidp) == sizeof(ucl_byte *));
r &= __ucl_assert(sizeof(ucl_voidp) == sizeof(ucl_voidpp));
r &= __ucl_assert(sizeof(ucl_voidp) == sizeof(ucl_bytepp));
r &= __ucl_assert(sizeof(ucl_voidp) >= sizeof(ucl_uint));
r &= __ucl_assert(sizeof(ucl_ptr_t) == sizeof(ucl_voidp));
r &= __ucl_assert(sizeof(ucl_ptr_t) >= sizeof(ucl_uint));
r &= __ucl_assert(sizeof(ucl_ptrdiff_t) >= 4);
r &= __ucl_assert(sizeof(ucl_ptrdiff_t) >= sizeof(ptrdiff_t));
#if defined(SIZEOF_CHAR_P)
r &= __ucl_assert(SIZEOF_CHAR_P == sizeof(char *));
#endif
#if defined(SIZEOF_PTRDIFF_T)
r &= __ucl_assert(SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t));
#endif
/* assert the signedness of our integral types */
sanity = IS_UNSIGNED(unsigned short) && IS_UNSIGNED(unsigned) &&
IS_UNSIGNED(unsigned long) &&
IS_SIGNED(short) && IS_SIGNED(int) && IS_SIGNED(long);
if (sanity)
{
r &= __ucl_assert(IS_UNSIGNED(ucl_ptr_t));
r &= __ucl_assert(IS_UNSIGNED(ucl_moff_t));
r &= __ucl_assert(IS_SIGNED(ucl_ptrdiff_t));
r &= __ucl_assert(IS_SIGNED(ucl_sptr_t));
}
return r;
}
static bool
_hasNativeMulFor (iCode *ic, sym_link *left, sym_link *right)
{
sym_link *test = NULL;
value *val;
if ( ic->op != '*')
{
return FALSE;
}
if ( IS_LITERAL (left))
{
test = left;
val = OP_VALUE (IC_LEFT (ic));
}
else if ( IS_LITERAL (right))
{
test = right;
val = OP_VALUE (IC_RIGHT (ic));
}
/* 8x8 unsigned multiplication code is shorter than
call overhead for the multiplication routine. */
else if ( IS_CHAR (right) && IS_UNSIGNED (right) &&
IS_CHAR (left) && IS_UNSIGNED(left) && !IS_GB)
{
return TRUE;
}
else
{
return FALSE;
}
if ( getSize (test) <= 2)
{
return TRUE;
}
return FALSE;
}
static bool
_hasNativeMulFor (iCode * ic, sym_link * left, sym_link * right)
{
sym_link *test = NULL;
int result_size = IS_SYMOP(IC_RESULT(ic)) ? getSize(OP_SYM_TYPE(IC_RESULT(ic))) : 4;
if (ic->op != '*')
{
return FALSE;
}
if (IS_LITERAL (left))
test = left;
else if (IS_LITERAL (right))
test = right;
/* 8x8 unsigned multiplication code is shorter than
call overhead for the multiplication routine. */
else if (IS_CHAR (right) && IS_UNSIGNED (right) && IS_CHAR (left) && IS_UNSIGNED (left) && !IS_GB)
{
return TRUE;
}
/* Same for any multiplication with 8 bit result. */
else if (result_size == 1 && !IS_GB)
{
return TRUE;
}
else
{
return FALSE;
}
if (getSize (test) <= 2)
{
return TRUE;
}
return FALSE;
}
static ucl_bool basic_integral_check(void)
{
ucl_bool r = 1;
ucl_bool sanity;
/* paranoia */
r &= __ucl_assert(CHAR_BIT == 8);
r &= __ucl_assert(sizeof(char) == 1);
r &= __ucl_assert(sizeof(short) >= 2);
r &= __ucl_assert(sizeof(long) >= 4);
r &= __ucl_assert(sizeof(int) >= sizeof(short));
r &= __ucl_assert(sizeof(long) >= sizeof(int));
r &= __ucl_assert(sizeof(ucl_uint32) >= 4);
r &= __ucl_assert(sizeof(ucl_uint32) >= sizeof(unsigned));
#if defined(__UCL_STRICT_16BIT)
r &= __ucl_assert(sizeof(ucl_uint) == 2);
#else
r &= __ucl_assert(sizeof(ucl_uint) >= 4);
r &= __ucl_assert(sizeof(ucl_uint) >= sizeof(unsigned));
#endif
#if defined(SIZEOF_UNSIGNED)
r &= __ucl_assert(SIZEOF_UNSIGNED == sizeof(unsigned));
#endif
#if defined(SIZEOF_UNSIGNED_LONG)
r &= __ucl_assert(SIZEOF_UNSIGNED_LONG == sizeof(unsigned long));
#endif
#if defined(SIZEOF_UNSIGNED_SHORT)
r &= __ucl_assert(SIZEOF_UNSIGNED_SHORT == sizeof(unsigned short));
#endif
#if !defined(__UCL_IN_MINIUCL)
#if defined(SIZEOF_SIZE_T)
r &= __ucl_assert(SIZEOF_SIZE_T == sizeof(size_t));
#endif
#endif
/* assert the signedness of our integral types */
sanity = IS_UNSIGNED(unsigned short) && IS_UNSIGNED(unsigned) &&
IS_UNSIGNED(unsigned long) &&
IS_SIGNED(short) && IS_SIGNED(int) && IS_SIGNED(long);
if (sanity)
{
r &= __ucl_assert(IS_UNSIGNED(ucl_uint32));
r &= __ucl_assert(IS_UNSIGNED(ucl_uint));
r &= __ucl_assert(IS_SIGNED(ucl_int32));
r &= __ucl_assert(IS_SIGNED(ucl_int));
r &= __ucl_assert(INT_MAX == UCL_STYPE_MAX(sizeof(int)));
r &= __ucl_assert(UINT_MAX == UCL_UTYPE_MAX(sizeof(unsigned)));
r &= __ucl_assert(LONG_MAX == UCL_STYPE_MAX(sizeof(long)));
r &= __ucl_assert(ULONG_MAX == UCL_UTYPE_MAX(sizeof(unsigned long)));
r &= __ucl_assert(SHRT_MAX == UCL_STYPE_MAX(sizeof(short)));
r &= __ucl_assert(USHRT_MAX == UCL_UTYPE_MAX(sizeof(unsigned short)));
r &= __ucl_assert(UCL_UINT32_MAX == UCL_UTYPE_MAX(sizeof(ucl_uint32)));
r &= __ucl_assert(UCL_UINT_MAX == UCL_UTYPE_MAX(sizeof(ucl_uint)));
#if !defined(__UCL_IN_MINIUCL)
r &= __ucl_assert(SIZE_T_MAX == UCL_UTYPE_MAX(sizeof(size_t)));
#endif
}
#if 0
/* for some reason this fails on a Cray ??? */
r &= __ucl_assert(UCL_BYTE(257) == 1);
r &= __ucl_assert(UCL_USHORT(65537L) == 1);
#endif
return r;
}
int mysql_dumper_dump(struct mysql_login_info *mysql_login_info, const char *outputdir, const char *dbname, const char *tablename, const char *query, size_t query_len, struct mysql_dumper_type *types) {
MYSQL mysql;
MYSQL_STMT *stmt = NULL;
mysql_init(&mysql);
my_bool b_flag = 1;
if (0 != mysql_options(&mysql, MYSQL_OPT_RECONNECT, (const char *)&b_flag))
return report_error(&mysql);
if (NULL == mysql_real_connect(&mysql, mysql_login_info->host, mysql_login_info->user, mysql_login_info->pass, mysql_login_info->db, mysql_login_info->port, NULL, CLIENT_COMPRESS))
return report_error(&mysql);
b_flag = 0;
if (0 != mysql_options(&mysql, MYSQL_REPORT_DATA_TRUNCATION, (const char *)&b_flag))
return report_error(&mysql);
stmt = mysql_stmt_init(&mysql);
if (!stmt)
return report_error(&mysql);
if (0 != mysql_stmt_prepare(stmt, query, query_len))
return report_stmt_error(&mysql, stmt);
MYSQL_RES *rs = mysql_stmt_result_metadata(stmt);
if (!rs)
return report_stmt_error(&mysql, stmt);
unsigned int n = mysql_num_fields(rs);
MYSQL_FIELD *fields = mysql_fetch_fields(rs);
int field_types[n];
MYSQL_BIND bind[n];
my_bool is_null[n];
unsigned long length[n];
my_bool error[n];
memset(bind, 0, sizeof(MYSQL_BIND) * n);
int null_terminate_str[n];
memset(null_terminate_str, 0, sizeof(int) * n);
struct file_writer ffields[n];
struct file_writer vfields[2][n];
struct vmbuf buf = VMBUF_INITIALIZER;
vmbuf_init(&buf, 4096);
vmbuf_sprintf(&buf, "%s/%s/%s/schema.txt", outputdir, dbname, tablename);
mkdir_for_file_recursive(vmbuf_data(&buf));
int fdschema = creat(vmbuf_data(&buf), 0644);
struct vmfile ds_txt = VMFILE_INITIALIZER;
vmbuf_reset(&buf);
vmbuf_sprintf(&buf, "%s/%s/%s/ds.txt", outputdir, dbname, tablename);
if (0 > vmfile_init(&ds_txt, vmbuf_data(&buf), 4096))
return LOGGER_ERROR("failed to create: %s", vmbuf_data(&buf)), vmbuf_free(&buf), -1;
vmfile_sprintf(&ds_txt, "DS_LOADER_BEGIN()\n");
vmfile_sprintf(&ds_txt, "/*\n * DB: %s\n */\n", dbname);
vmfile_sprintf(&ds_txt, "#undef DB_NAME\n#define DB_NAME %s\n", dbname);
ssize_t len = 80 - strlen(tablename);
if (len < 0) len = 4;
char header[len];
memset(header, '=', len);
vmfile_sprintf(&ds_txt, "/* %.*s[ %s ]%.*s */\n", (int)len / 2, header, tablename, (int)(len - (len / 2)), header);
vmfile_sprintf(&ds_txt, "# undef TABLE_NAME\n# define TABLE_NAME %s\n", tablename);
/*
* initialize output files
*/
unsigned int i;
for (i = 0; i < n; ++i) {
file_writer_make(&ffields[i]);
file_writer_make(&vfields[0][i]);
file_writer_make(&vfields[1][i]);
}
struct hashtable ht_types = HASHTABLE_INITIALIZER;
hashtable_init(&ht_types, 32);
if (NULL != types) {
struct mysql_dumper_type *t = types;
for (; t->name; ++t) {
/* storing ptr here which points to static str */
hashtable_insert(&ht_types, t->name, strlen(t->name), t, sizeof(struct mysql_dumper_type));
}
}
/*
* parse meta data and construct bind array
*/
int err = 0;
for (i = 0; i < n; ++i) {
field_types[i] = fields[i].type;
bind[i].is_unsigned = IS_UNSIGNED(fields[i].flags);
int64_t ds_type = -1;
const char *ds_type_str = "VAR";
/*
* handle overrides
*/
while (NULL != types) {
uint32_t ofs = hashtable_lookup(&ht_types, fields[i].name, strlen(fields[i].name));
if (!ofs) break;
struct mysql_dumper_type *type = (struct mysql_dumper_type *)hashtable_get_val(&ht_types, ofs);
null_terminate_str[i] = MYSQL_DUMPER_CSTR & type->flags;
if (type->mysql_type)
field_types[i] = type->mysql_type;
bind[i].is_unsigned = (type->flags & MYSQL_DUMPER_UNSIGNED) > 0 ? 1 : 0;
break;
}
vmbuf_reset(&buf);
vmbuf_sprintf(&buf, "%s/%s/%s/%s", outputdir, dbname, tablename, fields[i].name);
mkdir_for_file_recursive(vmbuf_data(&buf));
if (is_var_length_field(field_types[i])) {
size_t ofs = vmbuf_wlocpos(&buf);
vmbuf_sprintf(&buf, ".ofs");
if (0 > (err = file_writer_init(&vfields[0][i], vmbuf_data(&buf))))
break;
vmbuf_wlocset(&buf, ofs);
vmbuf_sprintf(&buf, ".dat");
if (0 > (err = file_writer_init(&vfields[1][i], vmbuf_data(&buf))))
break;
} else {
ds_type = get_ds_type(field_types[i], bind[i].is_unsigned);
const char *s = get_ds_type_str(ds_type);
if (*s) ds_type_str = s;
if (0 > (err = file_writer_init(&ffields[i], vmbuf_data(&buf))) ||
0 > (err = file_writer_write(&ffields[i], &ds_type, sizeof(ds_type))))
break;;
}
len = ribs_mysql_get_storage_size(field_types[i], fields[i].length);
if (fdschema > 0)
dprintf(fdschema, "%03d name = %s, size=%zu, length=%lu, type=%s (%s), is_prikey=%d, ds_type=%s\n", i, fields[i].name, len, fields[i].length, ribs_mysql_get_type_name(field_types[i]), bind[i].is_unsigned ? "unsigned" : "signed", IS_PRI_KEY(fields[i].flags), ds_type_str);
if (is_var_length_field(field_types[i])) {
vmfile_sprintf(&ds_txt, " DS_VAR_FIELD_LOADER(%s)\n", fields[i].name);
} else {
vmfile_sprintf(&ds_txt, " DS_FIELD_LOADER(%s, %s)\n", ds_type_str, fields[i].name);
}
bind[i].buffer_type = field_types[i];
bind[i].buffer_length = len;
bind[i].buffer = malloc(len);
bind[i].is_null = &is_null[i];
bind[i].length = &length[i];
bind[i].error = &error[i];
}
hashtable_free(&ht_types);
mysql_free_result(rs);
close(fdschema);
//vmfile_sprintf(&ds_txt, "/*\n * TABLE END: %s\n */\n", tablename);
vmfile_sprintf(&ds_txt, "DS_LOADER_END()\n");
vmfile_close(&ds_txt);
/*
* execute & bind
*/
if (0 != err ||
0 != mysql_stmt_execute(stmt) ||
0 != mysql_stmt_bind_result(stmt, bind)) {
err = -1;
report_stmt_error(&mysql, stmt);
goto dumper_close_writer;
}
char zeros[4096];
memset(zeros, 0, sizeof(zeros));
int mysql_err = 0;
size_t count = 0, num_rows_errors = 0;
/*
* write all rows to output files
*/
while (0 == (mysql_err = mysql_stmt_fetch(stmt))) {
int b = 0;
for (i = 0; i < n && !b; ++i)
b = b || error[i];
if (b) {
++num_rows_errors;
continue;
}
for (i = 0; i < n; ++i) {
if (is_var_length_field(field_types[i])) {
size_t ofs = file_writer_wlocpos(&vfields[1][i]);
if (0 > (err = file_writer_write(&vfields[0][i], &ofs, sizeof(ofs))) ||
0 > (err = file_writer_write(&vfields[1][i], is_null[i] ? NULL : bind[i].buffer, is_null[i] ? 0 : length[i])))
goto dumper_error;
if (null_terminate_str[i]) {
const char c = '\0';
if (0 > (err = file_writer_write(&vfields[1][i], &c, sizeof(c))))
goto dumper_error;
}
} else {
if (0 > (err = file_writer_write(&ffields[i], is_null[i] ? zeros : bind[i].buffer, bind[i].buffer_length)))
goto dumper_error;
}
}
++count;
}
/* no dumper errors */
goto dumper_ok;
dumper_error:
LOGGER_ERROR("failed to write data, aborting");
dumper_ok:
/* we are done with mysql, close it */
mysql_stmt_close(stmt);
mysql_close(&mysql);
LOGGER_INFO("%s: %zu records, %zu skipped", tablename, count, num_rows_errors);
/* check for mysql errors */
if (mysql_err != MYSQL_NO_DATA) {
LOGGER_ERROR("mysql_stmt_fetch returned an error (code=%d)\n", mysql_err);
err = -1;
}
dumper_close_writer:
/*
* finalize & free memory
*/
for (i = 0; i < n; ++i) {
if (is_var_length_field(field_types[i])) {
size_t ofs = file_writer_wlocpos(&vfields[1][i]);
if (0 > (err = file_writer_write(&vfields[0][i], &ofs, sizeof(ofs))))
LOGGER_ERROR("failed to write offset");
file_writer_close(&vfields[0][i]);
file_writer_close(&vfields[1][i]);
} else {
file_writer_close(&ffields[i]);
}
free(bind[i].buffer);
}
vmbuf_free(&buf);
return err;
}
