void G1BlockOffsetSharedArray::set_offset_array(size_t index, HeapWord* high, HeapWord* low) {
check_index(index, "index out of range");
assert(high >= low, "addresses out of order");
size_t offset = pointer_delta(high, low);
check_offset(offset, "offset too large");
set_offset_array(index, (u_char)offset);
}
int HMC5883::check_calibration()
{
bool offset_valid = (check_offset() == OK);
bool scale_valid = (check_scale() == OK);
if (_calibrated != (offset_valid && scale_valid)) {
warnx("mag cal status changed %s%s", (scale_valid) ? "" : "scale invalid ",
(offset_valid) ? "" : "offset invalid");
_calibrated = (offset_valid && scale_valid);
// XXX Change advertisement
/* notify about state change */
struct subsystem_info_s info = {
true,
true,
_calibrated,
SUBSYSTEM_TYPE_MAG};
static orb_advert_t pub = -1;
if (pub > 0) {
orb_publish(ORB_ID(subsystem_info), pub, &info);
} else {
pub = orb_advertise(ORB_ID(subsystem_info), &info);
}
}
/* return 0 if calibrated, 1 else */
return (!_calibrated);
}
u16 bcm3450_read_word(u8 offset)
{
struct i2c_msg msg[2];
u8 off, buf[4];
struct i2c_client *client = &pclient_data->client;
BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__);
if(check_offset(offset, WORD_ALIGN))
return -1;
/* BCM3450 requires the offset to be the register number */
off = offset/4;
msg[0].addr = msg[1].addr = client->addr;
msg[0].flags = msg[1].flags = client->flags & I2C_M_TEN;
msg[0].len = 1;
msg[0].buf = (char *)&off;
msg[1].flags |= I2C_M_RD;
msg[1].len = 4;
msg[1].buf = buf;
if(i2c_transfer(client->adapter, msg, 2) == 2)
{
return swab16(*((u16 *)&buf[offset % 4]));
}
return -1;
}
int bcm3450_write_word(u8 offset, u16 val)
{
u8 off;
int tmp_val;
BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__);
if(check_offset(offset, WORD_ALIGN))
return -1;
/* Make the offset WORD aligned */
off = offset & 0xFC;
/* Read */
tmp_val = bcm3450_read_reg(off);
if (tmp_val < 0)
{
return -1;
}
/* Modify */
tmp_val = (tmp_val & (~(0xFFFF << ((offset % 4) * 8))))
| (val << ((offset % 4) * 8));
/* Write */
return bcm3450_write_reg(off, tmp_val);
}
int bcm3450_read_reg(u8 offset)
{
struct i2c_msg msg[2];
int val;
struct i2c_client *client = &pclient_data->client;
BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__);
if(check_offset(offset, DWORD_ALIGN)) {
return -EINVAL;
}
/* BCM3450 requires the offset to be the register number */
offset = offset/4;
msg[0].addr = msg[1].addr = client->addr;
msg[0].flags = msg[1].flags = client->flags & I2C_M_TEN;
msg[0].len = 1;
msg[0].buf = (char *)&offset;
msg[1].flags |= I2C_M_RD;
msg[1].len = 4;
msg[1].buf = (char *)&val;
/* On I2C bus, we receive LS byte first. So swap bytes as necessary */
if(i2c_transfer(client->adapter, msg, 2) == 2)
return swab32(val);
return -1;
}
int HMC5883::check_calibration()
{
bool offset_valid = (check_offset() == OK);
bool scale_valid = (check_scale() == OK);
if (_calibrated != (offset_valid && scale_valid)) {
_calibrated = (offset_valid && scale_valid);
}
/* return 0 if calibrated, 1 else */
return (!_calibrated);
}
int LIS3MDL::check_calibration()
{
bool offset_valid = (check_offset() == OK);
bool scale_valid = (check_scale() == OK);
if (_calibrated != (offset_valid && scale_valid)) {
warnx("mag cal status changed %s%s", (scale_valid) ? "" : "scale invalid ",
(offset_valid) ? "" : "offset invalid");
_calibrated = (offset_valid && scale_valid);
}
/* return 0 if calibrated, 1 else */
return !_calibrated;
}
int IST8310::check_calibration()
{
bool offset_valid = (check_offset() == OK);
bool scale_valid = (check_scale() == OK);
if (_calibrated != (offset_valid && scale_valid)) {
if (!scale_valid || !offset_valid) {
PX4_WARN("mag cal status changed %s%s", (scale_valid) ? "" : "scale invalid ",
(offset_valid) ? "" : "offset invalid");
}
_calibrated = (offset_valid && scale_valid);
}
/* return 0 if calibrated, 1 else */
return (!_calibrated);
}
ssize_t bcm3450_write(char *buf, size_t count)
{
struct i2c_client *client = &pclient_data->client;
BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__);
if(check_offset(buf[0], DWORD_ALIGN))
return -1;
if(count > MAX_TRANSACTION_SIZE)
{
BCM_LOG_NOTICE(BCM_LOG_ID_I2C, "count > %d is not yet supported \n",
MAX_TRANSACTION_SIZE);
return -1;
}
/* BCM3450 requires the offset to be the register number */
buf[0] = buf[0]/4;
return i2c_master_send(client, buf, count);
}
ssize_t bcm3450_read(char *buf, size_t count)
{
struct i2c_msg msg[2];
struct i2c_client *client = &pclient_data->client;
BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__);
if(check_offset(buf[0], DWORD_ALIGN))
return -1;
/* BCM3450 requires the offset to be the register number */
buf[0] = buf[0]/4;
if(count > MAX_TRANSACTION_SIZE)
{
BCM_LOG_NOTICE(BCM_LOG_ID_I2C, "count > %d is not yet supported \n",
MAX_TRANSACTION_SIZE);
return -1;
}
/* First write the offset */
msg[0].addr = msg[1].addr = client->addr;
msg[0].flags = msg[1].flags = client->flags & I2C_M_TEN;
msg[0].len = 1;
msg[0].buf = buf;
/* Now read the data */
msg[1].flags |= I2C_M_RD;
msg[1].len = count;
msg[1].buf = buf;
/* On I2C bus, we receive LS byte first. So swap bytes as necessary */
if(i2c_transfer(client->adapter, msg, 2) == 2)
{
return count;
}
return -1;
}
int bcm3450_write_reg(u8 offset, int val)
{
char buf[5];
struct i2c_client *client = &pclient_data->client;
BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__);
if(check_offset(offset, DWORD_ALIGN)) {
return -EINVAL;
}
/* BCM3450 requires the offset to be the register number */
buf[0] = offset/4;
/* On the I2C bus, LS Byte should go first */
val = swab32(val);
memcpy(&buf[1], (char*)&val, 4);
if (i2c_master_send(client, buf, 5) == 5)
{
return 0;
}
return -1;
}
int main(void)
{
static const int size[] = { 1, 13, 403, 999, 30000 };
char buffer[40000];
char *original;
int c, i;
ssize_t n;
off_t off;
reopen("vcf.c", "test/hfile1.tmp");
while ((c = hgetc(fin)) != EOF) {
if (hputc(c, fout) == EOF) fail("hputc");
}
if (herrno(fin)) { errno = herrno(fin); fail("hgetc"); }
reopen("test/hfile1.tmp", "test/hfile2.tmp");
if (hpeek(fin, buffer, 50) < 0) fail("hpeek");
while ((n = hread(fin, buffer, 17)) > 0) {
if (hwrite(fout, buffer, n) != n) fail("hwrite");
}
if (n < 0) fail("hread");
reopen("test/hfile2.tmp", "test/hfile3.tmp");
while ((n = hread(fin, buffer, sizeof buffer)) > 0) {
if (hwrite(fout, buffer, n) != n) fail("hwrite");
if (hpeek(fin, buffer, 700) < 0) fail("hpeek");
}
if (n < 0) fail("hread");
reopen("test/hfile3.tmp", "test/hfile4.tmp");
i = 0;
off = 0;
while ((n = hread(fin, buffer, size[i++ % 5])) > 0) {
off += n;
buffer[n] = '\0';
check_offset(fin, off, "pre-peek");
if (hputs(buffer, fout) == EOF) fail("hputs");
if ((n = hpeek(fin, buffer, size[(i+3) % 5])) < 0) fail("hpeek");
check_offset(fin, off, "post-peek");
}
if (n < 0) fail("hread");
reopen("test/hfile4.tmp", "test/hfile5.tmp");
n = hread(fin, buffer, 200);
if (n < 0) fail("hread");
else if (n != 200) fail("hread only got %d", (int)n);
if (hwrite(fout, buffer, 1000) != 1000) fail("hwrite");
check_offset(fin, 200, "input/first200");
check_offset(fout, 1000, "output/first200");
if (hseek(fin, 800, SEEK_CUR) < 0) fail("hseek/cur");
check_offset(fin, 1000, "input/seek");
for (off = 1000; (n = hread(fin, buffer, sizeof buffer)) > 0; off += n)
if (hwrite(fout, buffer, n) != n) fail("hwrite");
if (n < 0) fail("hread");
check_offset(fin, off, "input/eof");
check_offset(fout, off, "output/eof");
if (hseek(fin, 200, SEEK_SET) < 0) fail("hseek/set");
if (hseek(fout, 200, SEEK_SET) < 0) fail("hseek(output)");
check_offset(fin, 200, "input/backto200");
check_offset(fout, 200, "output/backto200");
n = hread(fin, buffer, 800);
if (n < 0) fail("hread");
else if (n != 800) fail("hread only got %d", (int)n);
if (hwrite(fout, buffer, 800) != 800) fail("hwrite");
check_offset(fin, 1000, "input/wrote800");
check_offset(fout, 1000, "output/wrote800");
if (hflush(fout) == EOF) fail("hflush");
original = slurp("vcf.c");
for (i = 1; i <= 5; i++) {
char *text;
sprintf(buffer, "test/hfile%d.tmp", i);
text = slurp(buffer);
if (strcmp(original, text) != 0) {
fprintf(stderr, "%s differs from vcf.c\n", buffer);
return EXIT_FAILURE;
}
free(text);
}
free(original);
if (hclose(fin) != 0) fail("hclose(input)");
if (hclose(fout) != 0) fail("hclose(output)");
fout = hopen("test/hfile_chars.tmp", "w");
if (fout == NULL) fail("hopen(\"test/hfile_chars.tmp\")");
for (i = 0; i < 256; i++)
if (hputc(i, fout) != i) fail("chars: hputc (%d)", i);
if (hclose(fout) != 0) fail("hclose(test/hfile_chars.tmp)");
fin = hopen("test/hfile_chars.tmp", "r");
if (fin == NULL) fail("hopen(\"test/hfile_chars.tmp\") for reading");
for (i = 0; i < 256; i++)
if ((c = hgetc(fin)) != i)
fail("chars: hgetc (%d = 0x%x) returned %d = 0x%x", i, i, c, c);
if ((c = hgetc(fin)) != EOF) fail("chars: hgetc (EOF) returned %d", c);
if (hclose(fin) != 0) fail("hclose(test/hfile_chars.tmp) for reading");
fin = hopen("data:hello, world!\n", "r");
if (fin == NULL) fail("hopen(\"data:...\")");
n = hread(fin, buffer, 300);
if (n < 0) fail("hread");
buffer[n] = '\0';
if (strcmp(buffer, "hello, world!\n") != 0) fail("hread result");
if (hclose(fin) != 0) fail("hclose(\"data:...\")");
return EXIT_SUCCESS;
}
static void
execute_instr_at_pc(void) {
Instr *instr;
int i1, i2;
float r1, r2;
char *s1, *s2;
int l;
char *s;
const char *builtin_func;
int slot;
int offset;
char buf[1024];
if (print_instrs)
printf("instr %d, pc %d: ", cur_instr, pc);
instr = &instrs[pc];
switch (instr->opcode) {
case OP_PUSH_STACK_FRAME:
if (print_instrs)
printf("push_stack_frame %d\n", instr->int_const);
top_slot++;
if (stack_check_overflow())
break;
stack[top_slot].store_valid = TRUE;
stack[top_slot].store_type = TYPE_FRAME_SIZE;
stack[top_slot].int_val = cur_frame_size;
cur_frame_size = instr->int_const;
top_slot += instr->int_const;
if (stack_check_overflow())
break;
break;
case OP_POP_STACK_FRAME:
if (print_instrs)
printf("pop_stack_frame %d\n", instr->int_const);
if (instr->int_const != cur_frame_size) {
fprintf(stderr, "pop_stack_frame %d doesn't match "
"previous push_stack_frame %d\n",
instr->int_const, cur_frame_size);
found_error = TRUE;
break;
}
for (slot = 0; slot < instr->int_const; slot++)
stack_slot(slot).store_valid = FALSE;
top_slot -= instr->int_const;
cur_frame_size = stack[top_slot].int_val;
stack[top_slot].store_valid = FALSE;
top_slot--;
break;
case OP_LOAD:
if (print_instrs)
printf("load r%d, %d\n", instr->rd, instr->int_const);
check_slot(instr->int_const, TRUE, TRUE);
regs[instr->rd] = stack_slot(instr->int_const);
break;
case OP_STORE:
if (print_instrs)
printf("store %d, r%d\n", instr->int_const, instr->rs1);
check_reg(instr->rs1);
check_slot(instr->int_const, FALSE, TRUE);
stack_slot(instr->int_const) = regs[instr->rs1];
break;
case OP_LOAD_ADDRESS:
if (print_instrs)
printf("load_address r%d, %d\n", instr->rd, instr->int_const);
check_slot(instr->int_const, FALSE, TRUE);
set_reg_addr(instr->rd, top_slot - instr->int_const);
break;
case OP_LOAD_INDIRECT:
if (print_instrs)
printf("load_indirect r%d, r%d\n", instr->rd, instr->rs1);
offset = addr_reg(instr->rs1);
check_offset(offset, TRUE, TRUE); /* Must be valid */
regs[instr->rd] = stack[offset];
break;
case OP_STORE_INDIRECT:
if (print_instrs)
printf("store_indirect r%d, r%d\n", instr->rd, instr->rs1);
check_reg(instr->rs1);
offset = addr_reg(instr->rd);
check_offset(offset, FALSE, TRUE); /* Need not be valid */
stack[offset] = regs[instr->rs1];
break;
case OP_INT_CONST:
if (print_instrs)
printf("int_const r%d, %d\n", instr->rd, instr->int_const);
set_reg_int(instr->rd, instr->int_const);
break;
case OP_REAL_CONST:
if (print_instrs)
printf("real_const r%d, %f\n", instr->rd, instr->real_const);
set_reg_real(instr->rd, instr->real_const);
break;
case OP_STRING_CONST:
if (print_instrs)
printf("string_const r%d, %s\n", instr->rd, instr->string_const);
set_reg_string(instr->rd, make_string_const(instr->string_const));
break;
case OP_ADD_INT:
if (print_instrs)
printf("add_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 + i2);
break;
case OP_ADD_REAL:
if (print_instrs)
printf("add_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_real(instr->rd, r1 + r2);
break;
case OP_ADD_OFFSET:
if (print_instrs)
printf("add_offset r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
offset = addr_reg(instr->rs1);
i2 = int_reg(instr->rs2);
offset += i2;
check_offset(offset, FALSE, TRUE);
set_reg_addr(instr->rd, offset);
break;
case OP_SUB_INT:
if (print_instrs)
printf("sub_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 - i2);
break;
case OP_SUB_REAL:
if (print_instrs)
printf("sub_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_real(instr->rd, r1 - r2);
break;
case OP_SUB_OFFSET:
if (print_instrs)
printf("sub_offset r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
offset = addr_reg(instr->rs1);
i2 = int_reg(instr->rs2);
offset -= i2;
check_offset(offset, FALSE, TRUE);
set_reg_addr(instr->rd, offset);
break;
case OP_MUL_INT:
if (print_instrs)
printf("mul_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 * i2);
break;
case OP_MUL_REAL:
if (print_instrs)
printf("mul_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_real(instr->rd, r1 * r2);
break;
case OP_DIV_INT:
if (print_instrs)
printf("div_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 / i2);
break;
case OP_DIV_REAL:
if (print_instrs)
printf("div_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_real(instr->rd, r1 / r2);
break;
case OP_CMP_EQ_INT:
if (print_instrs)
printf("cmp_eq_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 == i2);
break;
case OP_CMP_NE_INT:
if (print_instrs)
printf("cmp_ne_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 != i2);
break;
case OP_CMP_GT_INT:
if (print_instrs)
printf("cmp_gt_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 > i2);
break;
case OP_CMP_GE_INT:
if (print_instrs)
printf("cmp_ge_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 >= i2);
break;
case OP_CMP_LT_INT:
if (print_instrs)
printf("cmp_lt_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 < i2);
break;
case OP_CMP_LE_INT:
if (print_instrs)
printf("cmp_le_int r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 <= i2);
break;
case OP_CMP_EQ_REAL:
if (print_instrs)
printf("cmp_eq_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_int(instr->rd, r1 == r2);
break;
case OP_CMP_NE_REAL:
if (print_instrs)
printf("cmp_ne_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_int(instr->rd, r1 != r2);
break;
case OP_CMP_GT_REAL:
if (print_instrs)
printf("cmp_gt_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_int(instr->rd, r1 > r2);
break;
case OP_CMP_GE_REAL:
if (print_instrs)
printf("cmp_ge_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_int(instr->rd, r1 >= r2);
break;
case OP_CMP_LT_REAL:
if (print_instrs)
printf("cmp_lt_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_int(instr->rd, r1 < r2);
break;
case OP_CMP_LE_REAL:
if (print_instrs)
printf("cmp_le_real r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
r1 = real_reg(instr->rs1);
r2 = real_reg(instr->rs2);
set_reg_int(instr->rd, r1 <= r2);
break;
case OP_CMP_EQ_STRING:
if (print_instrs)
printf("cmp_eq_string r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
s1 = string_reg(instr->rs1);
s2 = string_reg(instr->rs2);
set_reg_int(instr->rd, strcmp(s1, s2) == 0);
break;
case OP_CMP_NE_STRING:
if (print_instrs)
printf("cmp_ne_string r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
s1 = string_reg(instr->rs1);
s2 = string_reg(instr->rs2);
set_reg_int(instr->rd, strcmp(s1, s2) != 0);
break;
case OP_CMP_GT_STRING:
if (print_instrs)
printf("cmp_gt_string r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
s1 = string_reg(instr->rs1);
s2 = string_reg(instr->rs2);
set_reg_int(instr->rd, strcmp(s1, s2) > 0);
break;
case OP_CMP_GE_STRING:
if (print_instrs)
printf("cmp_ge_string r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
s1 = string_reg(instr->rs1);
s2 = string_reg(instr->rs2);
set_reg_int(instr->rd, strcmp(s1, s2) >= 0);
break;
case OP_CMP_LT_STRING:
if (print_instrs)
printf("cmp_lt_string r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
s1 = string_reg(instr->rs1);
s2 = string_reg(instr->rs2);
set_reg_int(instr->rd, strcmp(s1, s2) < 0);
break;
case OP_CMP_LE_STRING:
if (print_instrs)
printf("cmp_le_string r%d, r%d, r%d\n",
instr->rd, instr->rs1, instr->rs2);
s1 = string_reg(instr->rs1);
s2 = string_reg(instr->rs2);
set_reg_int(instr->rd, strcmp(s1, s2) <= 0);
break;
case OP_AND:
if (print_instrs)
printf("and r%d, r%d, r%d\n", instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 && i2);
break;
case OP_OR:
if (print_instrs)
printf("or r%d, r%d, r%d\n", instr->rd, instr->rs1, instr->rs2);
i1 = int_reg(instr->rs1);
i2 = int_reg(instr->rs2);
set_reg_int(instr->rd, i1 || i2);
break;
case OP_NOT:
if (print_instrs)
printf("not r%d, r%d\n", instr->rd, instr->rs1);
i1 = int_reg(instr->rs1);
set_reg_int(instr->rd, !i1);
break;
case OP_BRANCH_UNCOND:
if (print_instrs)
printf("branch_uncond %s\n", instr->string_const);
next_pc = lookup_label(instr->string_const);
break;
case OP_BRANCH_ON_TRUE:
if (print_instrs)
printf("branch_on_true r%d, %s\n",
instr->rs1, instr->string_const);
i1 = int_reg(instr->rs1);
if (i1)
next_pc = lookup_label(instr->string_const);
break;
case OP_BRANCH_ON_FALSE:
if (print_instrs)
printf("branch_on_false r%d, %s\n",
instr->rs1, instr->string_const);
i1 = int_reg(instr->rs1);
if (! i1)
next_pc = lookup_label(instr->string_const);
break;
case OP_RETURN:
if (print_instrs)
printf("return\n");
check_slot(0, TRUE, FALSE);
if (stack_slot(0).store_type != TYPE_RETURN_ADDR) {
print_dynamic_context();
fprintf(stderr, "top of stack doesn't hold a return address\n");
found_error = TRUE;
}
next_pc = stack_slot(0).int_val;
top_slot--;
break;
case OP_CALL:
if (print_instrs)
printf("call %s\n", instr->string_const);
top_slot++;
if (stack_check_overflow())
break;
stack[top_slot].store_valid = TRUE;
stack[top_slot].store_type = TYPE_RETURN_ADDR;
stack[top_slot].int_val = next_pc;
next_pc = lookup_label(instr->string_const);
break;
case OP_CALL_BUILTIN:
if (instr->func >= FUNCOP_LAST)
report_error_and_exit("bad function in call");
builtin_func = func_names[instr->func];
if (print_instrs)
printf("call_builtin %s\n", builtin_func);
switch (instr->func) {
case FUNCOP_READ_INT:
init_all_regs();
if (scanf("%d", &i1) != 1)
report_error_and_exit("cannot read integer");
set_reg_int(0, i1);
break;
case FUNCOP_READ_REAL:
init_all_regs();
if (scanf("%f", &r1) != 1)
report_error_and_exit("cannot read real");
set_reg_real(0, r1);
break;
case FUNCOP_READ_BOOL:
init_all_regs();
if (scanf("%s", buf) != 1)
report_error_and_exit("cannot read bool");
if (streq(buf, "true"))
set_reg_int(0, 1);
else if (streq(buf, "false"))
set_reg_int(0, 0);
else
report_error_and_exit("read invalid bool");
break;
case FUNCOP_READ_STRING:
init_all_regs();
if (scanf("%s", buf) != 1)
report_error_and_exit("cannot read string");
set_reg_string(0, strdup(buf));
break;
case FUNCOP_PRINT_INT:
printf("%d", int_reg(0));
init_all_regs();
break;
case FUNCOP_PRINT_REAL:
printf("%f", real_reg(0));
init_all_regs();
break;
case FUNCOP_PRINT_BOOL:
printf("%s", int_reg(0) ? "true" : "false");
init_all_regs();
break;
case FUNCOP_PRINT_STRING:
printf("%s", string_reg(0));
init_all_regs();
break;
case FUNCOP_STRING_CONCAT:
s1 = string_reg(0);
s2 = string_reg(1);
l = (int) strlen(s1) + (int) strlen(s2) + 1;
s = checked_malloc(l);
s = strcpy(s, s1);
s = strcat(s, s2);
init_all_regs();
set_reg_string(0, s);
break;
case FUNCOP_STRING_LENGTH:
s1 = string_reg(0);
init_all_regs();
set_reg_int(0, (int) strlen(s1));
break;
case FUNCOP_SUBSTRING:
s1 = string_reg(0);
i1 = int_reg(1);
i2 = int_reg(2);
l = (int) strlen(s1) + 1;
s = checked_malloc(l);
if (i1 > l)
report_error_and_exit("substring: invalid start");
strcpy(s, s1 + i1);
l = l - i1;
if (i2 < l)
s[i2] = '\0';
init_all_regs();
set_reg_string(0, s);
break;
case FUNCOP_SQRT:
r1 = real_reg(0);
init_all_regs();
set_reg_real(0, (float) sqrt(r1));
break;
case FUNCOP_TRUNC:
r1 = real_reg(0);
init_all_regs();
set_reg_int(instr->rd, oztrunc(r1));
break;
case FUNCOP_ROUND:
r1 = real_reg(0);
init_all_regs();
set_reg_int(instr->rd, ozround(r1));
break;
case FUNCOP_LAST:
report_error_and_exit("call: invalid function");
}
break;
case OP_INT_TO_REAL:
if (print_instrs)
printf("int_to_real r%d, r%d\n", instr->rd, instr->rs1);
i1 = int_reg(instr->rs1);
set_reg_real(instr->rd, (float) i1);
break;
case OP_MOVE:
if (print_instrs)
printf("move r%d, r%d\n", instr->rd, instr->rs1);
set_reg_any(instr->rd, instr->rs1);
break;
case OP_DEBUG_REG:
if (print_instrs)
printf("debug_reg r%d\n", instr->rs1);
check_reg(instr->rs1);
if (quiet)
break;
switch (regs[instr->rs1].store_type) {
case TYPE_INT:
printf("register %d: %d\n", instr->rs1, int_reg(instr->rs1));
break;
case TYPE_REAL:
printf("register %d: %f\n", instr->rs1, real_reg(instr->rs1));
break;
case TYPE_ADDRESS:
printf("register %d: @%d\n", instr->rs1,
regs[instr->rs1].int_val);
break;
case TYPE_STRING:
printf("register %d: %s\n",
instr->rs1, string_reg(instr->rs1));
break;
default:
report_error_and_exit("invalid register type");
break;
}
break;
case OP_DEBUG_SLOT:
if (print_instrs)
printf("debug_slot %d\n", instr->int_const);
check_slot(instr->int_const, TRUE, TRUE);
if (quiet)
break;
switch (stack_slot(instr->int_const).store_type) {
case TYPE_INT:
printf("slot %d: %d\n",
instr->int_const, int_slot(instr->int_const));
break;
case TYPE_REAL:
printf("slot %d: %f\n",
instr->int_const, real_slot(instr->int_const));
break;
case TYPE_ADDRESS:
printf("slot %d: @%d\n",
instr->int_const, stack_slot(instr->int_const).int_val);
break;
case TYPE_STRING:
printf("slot %d: %s\n",
instr->int_const, string_slot(instr->int_const));
break;
case TYPE_FRAME_SIZE:
report_error_and_exit("frame size slot");
break;
case TYPE_RETURN_ADDR:
report_error_and_exit("return address slot");
break;
default:
report_error_and_exit("invalid slot type");
break;
}
break;
case OP_DEBUG_STACK:
if (print_instrs)
printf("debug_stack\n");
if (quiet)
break;
printf("\n");
printf("cur_frame_size = %d\n", cur_frame_size);
for (offset = 0; offset <= top_slot; offset++) {
if (! stack[offset].store_valid) {
printf("offset %d is invalid\n", offset);
continue;
}
switch (stack[offset].store_type) {
case TYPE_INT:
printf("offset %d: %d\n", offset, stack[offset].int_val);
break;
case TYPE_REAL:
printf("offset %d: %f\n", offset, stack[offset].real_val);
break;
case TYPE_ADDRESS:
printf("offset %d: @%d\n", offset, stack[offset].int_val);
break;
case TYPE_STRING:
printf("offset %d: %s\n", offset, stack[offset].string_val);
break;
case TYPE_FRAME_SIZE:
printf("offset %d: frame size %d\n",
offset, stack[offset].int_val);
break;
case TYPE_RETURN_ADDR:
printf("offset %d: return address %d\n",
offset, stack[offset].int_val);
break;
default:
report_error_and_exit("invalid slot type");
break;
}
}
printf("\n");
break;
case OP_HALT:
if (print_instrs)
printf("halt\n");
halted = TRUE;
break;
default:
report_internal_error_and_exit("unknown opcode");
break;
}
}
void G1BlockOffsetSharedArray::check_offset_array(size_t index, HeapWord* high, HeapWord* low) const {
check_index(index, "index out of range");
assert(high >= low, "addresses out of order");
check_offset(pointer_delta(high, low), "offset too large");
assert(_offset_array[index] == pointer_delta(high, low), "Wrong offset");
}
evac study(Conjunct *C, Sequence<Variable_ID> &evac_from, Sequence<Variable_ID> &evac_to, int n_from, int n_to, int max_arity)
{
assert(max_arity > 0);
assert(max_arity <= C->relation()->n_inp());
assert(max_arity <= C->relation()->n_out());
assert((&evac_from == &input_vars && &evac_to == &output_vars) ||
(&evac_from == &output_vars && &evac_to == &input_vars));
evac ret = evac_nasty;
if (C->query_guaranteed_leading_0s() >= max_arity)
ret = evac_trivial;
else
{
Conjunct *c = C->copy_conj_same_relation();
assert(c->relation() == C->relation());
if (evac_debug >= 3)
{
fprintf(DebugFile, "About to study %s evacuation for conjunct\n",
&evac_from == &input_vars ? "In-->Out" : "Out-->In");
use_ugly_names++;
C->prefix_print(DebugFile);
use_ugly_names--;
}
bool sat = simplify_conj(c, true, 4, black);
assert(sat); // else c is deleted
int v, col;
// Substitute out all possible symbolic constants
assert(c->problem->nSUBs == 0);
for (v = 1; v <= c->relation()->global_decls()->length(); v++)
if ((col = c->find_column((*c->relation()->global_decls())[v]))>0)
try_to_sub(c->problem, col);
if (check_offset(c, evac_from, evac_to, n_from, n_to, max_arity))
ret = evac_offset;
else if (check_subseq(c, evac_from, evac_to, n_from, n_to, max_arity))
ret = evac_subseq;
else if (check_offset_subseq(c, evac_from, evac_to, n_from, n_to, max_arity))
ret = evac_offset_subseq;
else if (check_affine(c, evac_from, evac_to, n_from, n_to, max_arity))
ret = evac_affine;
delete c;
}
if (evac_debug >= 2)
{
if ((evac_debug == 2 && ret != evac_trivial && ret != evac_nasty))
{
fprintf(DebugFile, "Studied %s evacuation for conjunct\n",
&evac_from == &input_vars ? "In-->Out" : "Out-->In");
use_ugly_names++;
C->prefix_print(DebugFile);
use_ugly_names--;
}
fprintf(DebugFile, "Saw evacuation type %s\n", evac_names[ret]);
}
return ret;
}
