Esempio n. 1
0
void Render_Widget::resolve_color_buffer(Buffer& buffer)
{
	if (!buffer.color_is_resolved)
	{
		buffer.color_is_resolved = true;

		q::video::gles::Interface interf;

        interf.iglBindBuffer(q::video::gles::iGL_PIXEL_PACK_BUFFER, buffer.color_pbo);
        auto* ptr = static_cast<uint8_t*>(interf.iglMapBuffer(q::video::gles::iGL_PIXEL_PACK_BUFFER, q::video::gles::iGL_READ_ONLY));
        QASSERT(ptr);

        size_t data_size = buffer.size.x * buffer.size.y * sizeof(uint32_t);
        QASSERT(data_size > 0);
        buffer.color_data.resize(data_size);

        //flip vertically
        size_t row_size = buffer.size.x * sizeof(uint32_t);
        for (size_t i = 0; i < buffer.size.y; i++)
        {
            memcpy(buffer.color_data.data() + (buffer.size.y - 1 - i) * row_size, ptr + i * row_size, row_size);
        }

        interf.iglUnmapBuffer(q::video::gles::iGL_PIXEL_PACK_BUFFER);
        interf.iglBindBuffer(q::video::gles::iGL_PIXEL_PACK_BUFFER, 0);
	}
}
Esempio n. 2
0
bool read_registers_uint16_le(uint8_t addr, uint8_t reg, uint16_t* data, uint8_t size)
{
	QASSERT(s_is_initialized);
	QASSERT(s_is_locked);
	QASSERT(data && size > 0);
	if (!data || size == 0)
	{
		return 0;
	}
	uint8_t* data_ptr8 = reinterpret_cast<uint8_t*>(data) + 1;
	//the data_ptr8 will advance like this
	//1, 0, 3, 2, 5, 4, 7, 6, 9, 8

	if (!_start()) goto error;
	if (!_send_address(SLA_W(addr))) goto error;
	if (!_send_byte(reg)) goto error;
	if (!_start()) goto error;
	if (!_send_address(SLA_R(addr))) goto error;

    {
        uint8_t i = size - 1;
        while (i > 0)
        {
            if (!_receive_byte_ack()) goto error;
            *data_ptr8 = TWDR;
            data_ptr8 -= 1;

            if (!_receive_byte_ack()) goto error;
            *data_ptr8 = TWDR;
            data_ptr8 += 3;

            --i;
        }
    }

	//last bytes
	{
		if (!_receive_byte_ack()) goto error;
		*data_ptr8 = TWDR;
		data_ptr8 -= 1;

		if (!_receive_byte()) goto error;
		*data_ptr8 = TWDR;
		//data_ptr8 += 3;
	}

	if (!_stop()) goto error;
	return true;
error:
	s_lockup_count++;
	return false;
}
Esempio n. 3
0
void set_high_speed(bool active) 
{
	QASSERT(s_is_initialized);
	QASSERT(s_is_locked);

    if (active) 
	{
        TWBR = ((CPU_FREQ / 400000) - 16) / 2;
    } 
	else 
	{
        TWBR = ((CPU_FREQ / 100000) - 16) / 2;
    }
}
Esempio n. 4
0
bool read_registers(uint8_t addr, uint8_t reg, uint8_t* data, uint8_t size)
{
	QASSERT(s_is_initialized);
	QASSERT(s_is_locked);
    QASSERT(size > 0);
    if (size == 0)
	{
		return 0;
	}
    if (!_start()) goto error;
    if (!_send_address(SLA_W(addr))) goto error;
    if (!_send_byte(reg)) goto error;
    if (!_start()) goto error;
    if (!_send_address(SLA_R(addr))) goto error;
    if (data)
    {
    	uint8_t i = size - 1;
    	while (i > 0)
    	{
            if (!_receive_byte_ack()) goto error;
            *data++ = TWDR;
            --i;
    	}
        //last item
        {
            if (!_receive_byte()) goto error;
            *data = TWDR;
        }
    }
    else
    {
    	uint8_t i = size - 1;
    	while (i > 0)
    	{
            if (!_receive_byte_ack()) goto error;
            s_i2c_null_sink = TWDR;
            --i;
    	}
        //last item
        {
            if (!_receive_byte()) goto error;
            s_i2c_null_sink = TWDR;
        }
    }
    if (!_stop()) goto error;
    return true;
error:
    s_lockup_count++;
    return false;
}
Esempio n. 5
0
void AIOP_PWM_Out::set_enabled_for_all(bool enabled)
{
	QASSERT(m_is_initialized);

	if (enabled)
	{
		TCCR3A |= (1<<COM3A1); 
		TCCR4A |= (1<<COM4A1); 
		TCCR3A |= (1<<COM3B1); 
		TCCR3A |= (1<<COM3C1); 
		TCCR4A |= (1<<COM4B1); 
		TCCR4A |= (1<<COM4C1); 
		TCCR1A |= (1<<COM1A1); 
		TCCR1A |= (1<<COM1B1); 
	}
	else
	{
		TCCR3A &= ~(1<<COM3A1);
		TCCR4A &= ~(1<<COM4A1);
		TCCR3A &= ~(1<<COM3B1);
		TCCR3A &= ~(1<<COM3C1);
		TCCR4A &= ~(1<<COM4B1);
		TCCR4A &= ~(1<<COM4C1);
		TCCR1A &= ~(1<<COM1A1);
		TCCR1A &= ~(1<<COM1B1);
	}
}
Esempio n. 6
0
void AIOP_PWM_Out::set_frequency(uint8_t ch, uint16_t hz)
{
	QASSERT(m_is_initialized);

	uint16_t icr = timer_period(hz);
	switch(ch)
	{
		case 0:
		case 1:
		case 2:
			ICR3 = icr;
		break;

		case 6:
		case 7:
			ICR1 = icr;
		break;

		case 3:
		case 4:
		case 5:
			ICR4 = icr;
		break;
	}
}
Esempio n. 7
0
void AIOP_PWM_Out::set_enabled(uint8_t ch, bool enabled)
{
	QASSERT(m_is_initialized);

	if (enabled)
	{
		switch (ch)
		{
			case 0: TCCR3A |= (1<<COM3B1); break;
			case 1: TCCR3A |= (1<<COM3C1); break;
			case 2: TCCR3A |= (1<<COM3A1); break;
			case 3: TCCR4A |= (1<<COM4A1); break;
			case 4: TCCR4A |= (1<<COM4B1); break;
			case 5: TCCR4A |= (1<<COM4C1); break;
			case 6: TCCR1A |= (1<<COM1A1); break;
			case 7: TCCR1A |= (1<<COM1B1); break;
		}
	}
	else
	{
		switch (ch)
		{
			case 0: TCCR3A &= ~(1<<COM3B1); break;
			case 1: TCCR3A &= ~(1<<COM3C1); break;
			case 2: TCCR3A &= ~(1<<COM3A1); break;
			case 3: TCCR4A &= ~(1<<COM4A1); break;
			case 4: TCCR4A &= ~(1<<COM4B1); break;
			case 5: TCCR4A &= ~(1<<COM4C1); break;
			case 6: TCCR1A &= ~(1<<COM1A1); break;
			case 7: TCCR1A &= ~(1<<COM1B1); break;
		}
	}
}
Esempio n. 8
0
//--------------------------------------------------------------------------
void linux_debmod_t::tdb_enable_event(td_event_e event, internal_bpt *bp)
{
  td_notify_t notify;
  td_err_e err = td_ta_event_addr(ta, event, &notify);
  DIE_IF_FAILED("td_ta_event_addr", err);
  bool ok = add_internal_bp(*bp, size_t(notify.u.bptaddr));
  debdeb("%a: added BP for thread event %s\n", bp->bpt_addr, event == TD_CREATE ? "TD_CREATE" : "TD_DEATH");
  QASSERT(ok);
}
Esempio n. 9
0
bool write(uint8_t addr, const uint8_t* data, uint8_t size)
{
	QASSERT(s_is_initialized);
	QASSERT(s_is_locked);
	QASSERT(data && size > 0);

    if (!_start()) goto error;
    if (!_send_address(SLA_W(addr))) goto error;
    for (int8_t i = size; i > 0; i--)
    {
	    if (!_send_byte(*data++)) goto error;
    }
    if (!_stop()) goto error;
    return true;
error:
    s_lockup_count++;
    return false;
}
Esempio n. 10
0
void AIOP_PWM_Out::set_frequency_for_all(uint16_t hz)
{
	QASSERT(m_is_initialized);

	for (uint8_t i = 0; i < MAX_CHANNEL_COUNT; i++)
	{
		set_frequency(i, hz);
	}
}
Esempio n. 11
0
bool read(uint8_t addr, uint8_t* data, uint8_t size)
{
	QASSERT(s_is_initialized);
	QASSERT(s_is_locked);
    QASSERT(size > 0);
    if (size == 0)
	{
		return 0;
	}
    if (!_start()) goto error;
    if (!_send_address(SLA_R(addr))) goto error;
    if (data)
    {
        for (int8_t i = size - 1; i > 0; i--) //write size - 1 butes
        {
            if (!_receive_byte_ack()) goto error;
            *data++ = TWDR;
        }
        //last item
        {
            if (!_receive_byte()) goto error;
            *data = TWDR;
        }
    }
    else
    {
        for (int8_t i = size - 1; i > 0; i--) //write size - 1 butes
        {
            if (!_receive_byte_ack()) goto error;
            s_i2c_null_sink = TWDR;
        }
        //last item
        {
            if (!_receive_byte()) goto error;
            s_i2c_null_sink = TWDR;
        }
    }

    if (!_stop()) goto error;
    return true;
error:
    s_lockup_count++;
    return false;
}
Esempio n. 12
0
//-------------------------------------------------------------------------
// Converts IDC arguments to Python argument list or just one tuple
// If 'decref' is NULL then 'pargs' will contain one element which is the tuple
bool pyw_convert_idc_args(
  const idc_value_t args[],
  int nargs,
  ref_vec_t &pargs,
  bool as_tupple,
  char *errbuf,
  size_t errbufsize)
{
  PYW_GIL_CHECK_LOCKED_SCOPE();

  ref_t py_tuple;

  pargs.qclear();

  if ( as_tupple )
  {
    py_tuple = newref_t(PyTuple_New(nargs));
    if ( py_tuple == NULL )
    {
      if ( errbuf != 0 && errbufsize > 0 )
        qstrncpy(errbuf, "Failed to create a new tuple to store arguments!", errbufsize);
      return false;
    }
  }

  for ( int i=0; i<nargs; i++ )
  {
    ref_t py_obj;
    int cvt = idcvar_to_pyvar(args[i], &py_obj);
    if ( cvt < CIP_OK )
    {
      if ( errbuf != 0 && errbufsize > 0 )
        qsnprintf(errbuf, errbufsize, "arg#%d has wrong type %d", i, args[i].vtype);
      return false;
    }

    if ( as_tupple )
    {
      // PyTuple_SetItem() steals the reference.
      py_obj.incref();
      QASSERT(30412, PyTuple_SetItem(py_tuple.o, i, py_obj.o) == 0);
    }
    else
    {
      pargs.push_back(py_obj);
    }
  }

  // Add the tuple to the list of args only now. Doing so earlier will
  // cause the py_tuple.o->ob_refcnt to be 2 and not 1, and that will
  // cause 'PyTuple_SetItem()' to fail.
  if ( as_tupple )
    pargs.push_back(py_tuple);

  return true;
}
Esempio n. 13
0
//--------------------------------------------------------------------------
// returns true-lowcnd was false, resumed the application
// nb: recursive calls to this function are not handled in any special way!
bool debmod_t::handle_lowcnd(lowcnd_t *lc, debug_event_t *event, int elc_flags)
{
  if ( (debugger_flags & DBG_FLAG_CAN_CONT_BPT) == 0 )
  {
    // difficult case: we have to reset pc, remove the bpt, single step, and resume the app
    QASSERT(616, !handling_lowcnds.has(lc->ea));
    handling_lowcnds.push_back(lc->ea);

    int code;
    if ( (elc_flags & ELC_KEEP_EIP) == 0 )
    {
      regval_t rv;
      rv._set_int(lc->ea);
      code = dbg_write_register(event->tid, pc_idx, &rv);
      if ( code <= 0 )
      {
        handling_lowcnds.del(lc->ea);
        return false;
      }
    }

    code = dbg_freeze_threads_except(event->tid);
    if ( code > 0 )
    {
      int bptlen = lc->type == BPT_SOFT ? lc->orgbytes.size() : lc->size;
      code = dbg_del_bpt(lc->type, lc->ea, lc->orgbytes.begin(), bptlen);
      if ( code > 0 )
      {
        code = dbg_perform_single_step(event, lc->cmd);
        if ( code <= 0 )
          dmsg("%a: failed to single step\n", event->ea); // may happen

        if ( dbg_add_bpt(lc->type, lc->ea, bptlen) <= 0 )
        {
          // if this fails, it may be because the breakpoint is invalid
          // at this time so we should notify IDA it isn't available
          // any more
          code = 0;
          dwarning("%a: could not restore deleted bpt\n", lc->ea); // odd
        }
      }
      if ( dbg_thaw_threads_except(event->tid) <= 0 )
      {
        dwarning("%d: could not resume suspended threads\n", event->tid); // odd
        code = 0;
      }
    }
    handling_lowcnds.del(lc->ea);
    if ( code <= 0 || event->eid != STEP )
      return false; // did not resume
  }
  if ( (elc_flags & ELC_KEEP_SUSP) != 0 )
    return true;
  return dbg_continue_after_event(event) > 0;
}
Esempio n. 14
0
File: vm.hpp Progetto: nealey/vera
 void unlock(vm_pagenum_t pagenum)
 {
   VM_page *found = searchhash(pagenum);
   QASSERT(found != NULL);
   if ( found->locked > 0 )
   {
     found->locked--;
     if ( !found->locked )
       locks++;
   }
 }
Esempio n. 15
0
//--------------------------------------------------------------------------
void linux_debmod_t::new_thread(thrinfo_t *info)
{
  int tid = info->ti_lid;
  threads_t::iterator p = threads.find(tid);
  if ( p == threads.end() ) // not found
  {
#ifdef LDEB
    msg("thread %d is new\n", tid);
    ::display_thrinfo(*info);
#endif

    td_err_e err;

    td_thr_events_t events;
    td_event_emptyset(&events);
    td_event_addset(&events, TD_CREATE);
    td_event_addset(&events, TD_DEATH);
    td_event_addset(&events, TD_CATCHSIG);
    err = td_thr_set_event(info->th_p, &events);
    DIE_IF_FAILED("td_thr_set_event", err);

    err = td_thr_event_enable(info->th_p, 1);
    COMPLAIN_IF_FAILED("td_thr_event_enable", err);
    if ( err != TD_OK )
    {
#ifdef LDEB
      msg("%d: thread dead already? not adding to list.\n", tid);
#endif
      return;
    }

    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGSTOP);
    td_thr_setsigpending(info->th_p, 1, &set);

    debug_event_t ev;
    ev.eid     = THREAD_START;
    ev.pid     = process_handle;
    ev.tid     = tid;
    ev.ea      = (ea_t)info->ti_startfunc;
    ev.handled = true;
    add_thread(tid);
    // attach to the thread and make is ready for debugging
    qptrace(PTRACE_ATTACH, tid, 0, 0);
    int status;
    int tid2 = waitpid(tid, &status, __WCLONE); // (must succeed) consume SIGSTOP
    QASSERT(tid2 != -1 && WIFSTOPPED(status) && WSTOPSIG(status) == SIGSTOP);
    get_thread(tid)->waiting_sigstop = false;
    enqueue_event(ev, IN_FRONT);
  }
  get_thread(tid)->thr = info->th_p;
}
Esempio n. 16
0
File: vm.hpp Progetto: nealey/vera
 bool lock(vm_pagenum_t pagenum)
 {
   if ( locks > 0 )
   {
     VM_page *found = searchhash(pagenum);
     QASSERT(found != NULL);
     if ( !found->locked )
       locks--;
     found->locked++;
     return true;
   }
   return false;
 }
Esempio n. 17
0
void SReqListener::request(const ReqMsg &msg) {
	SMutex::Autolock autoLock(mLock);

	if (mQueue->size() >= mQueue->maxSize()) {
		LOGVBS("%s: wait for queueing, current size: %llu",
			mName.c_str(), mQueue->size());
		QASSERT(mQueue->size() == mQueue->maxSize());

		mQueuePoped.wait(mLock);
	}

	mQueue->push(msg);
	mQueuePushed.signal();
}
void Acceleration_Calibration_Wizard::set_calibration_points(sz::calibration::Acceleration_Points const& data)
{
    rapidjson::Document calibrationj;
    calibrationj.SetObject();
    autojsoncxx::to_document(data, calibrationj);

    q::Path path("Calibration");
    path += m_output.name;

    rapidjson::Document configj = jsonutil::clone_value(m_node->config);
    if (!jsonutil::remove_value(configj, path))
    {
        QASSERT(0);
        return;
    }

    if (!jsonutil::add_value(configj, path, std::move(calibrationj), configj.GetAllocator()))
    {
        QASSERT(0);
        return;
    }

    m_hal.set_node_config(m_node, configj);
}
Esempio n. 19
0
void AIOP_PWM_Out::set_data_for_all(Data const& data)
{
	QASSERT(m_is_initialized);

	int16_t pulse = static_cast<int16_t>(data.value * PULSE_RANGE_F);
	pulse = MIN_PULSE_WIDTH + math::clamp(pulse, int16_t(0), PULSE_RANGE);

	OCR3B = pulse; //2
	OCR3C = pulse; //3
	OCR3A = pulse; //5
	OCR4A = pulse; //6
	OCR4B = pulse; //7
	OCR4C = pulse; //8
	OCR1A = pulse;// d11
	OCR1B = pulse;// d12
}
Esempio n. 20
0
//--------------------------------------------------------------------------
// determine the future bpt size and read the original instruction from memory.
// if necessary, the bpt address may be adjusted.
// return the number of read bytes.
// this function is overloaded in arm debugger subclasses.
int debmod_t::read_bpt_orgbytes(ea_t *p_ea, int *p_len, uchar *buf, int bufsize)
{
  int len = *p_len;
  if ( (debugger_flags & DBG_FLAG_CAN_CONT_BPT) == 0 )
  { // we must save the original bytes before adding the bpt
    QASSERT(30017, bufsize >= len);
    if ( dbg_read_memory(*p_ea, buf, len) <= 0 )
      return -1;
  }
  else
  { // if the debuger can itself continue from bpts,
    // orgbytes will not be used by the kernel. however
    // we must return something because non-empty orgbytes mean
    // that a soft bpt is active. we return zeroes in b->orgbytes.
  }
  return len;
}
Esempio n. 21
0
//--------------------------------------------------------------------------
bool debmod_t::check_input_file_crc32(uint32 orig_crc)
{
  // take this opportunity to check that the derived class initialized
  // register related fields correctly
  QASSERT(30016, sp_idx != -1 && pc_idx != -1 && nregs > 0);

  if ( orig_crc == 0 )
    return true; // the database has no crc

  linput_t *li = open_linput(input_file_path.c_str(), false);
  if ( li == NULL )
    return false;

  uint32 crc = calc_file_crc32(li);
  close_linput(li);
  return crc == orig_crc;
}
Esempio n. 22
0
size_t JSON_Model::Tree_Item::get_row() const
{
    if (!m_parent)
    {
        return 0;
    }
    auto it = std::find_if(m_parent->m_children.begin(), m_parent->m_children.end(), [this](std::unique_ptr<Tree_Item> const& c)
    {
            return c.get() == this;
    });
    if (it != m_parent->m_children.end())
    {
        return std::distance(m_parent->m_children.begin(), it);
    }
    QASSERT(0);
    return 0;
}
Esempio n. 23
0
void AIOP_PWM_Out::set_data(uint8_t ch, Data const& data) 
{
	QASSERT(m_is_initialized);

	int16_t pulse = static_cast<int16_t>(data.value * PULSE_RANGE_F);
	pulse = MIN_PULSE_WIDTH + math::clamp(pulse, int16_t(0), PULSE_RANGE);
	switch(ch)
	{
		case 0: OCR3B = pulse; break; //2
		case 1: OCR3C = pulse; break; //3
		case 2: OCR3A = pulse; break; //5
		case 3: OCR4A = pulse; break; //6
		case 4: OCR4B = pulse; break; //7
		case 5: OCR4C = pulse; break; //8
		case 6: OCR1A = pulse; break;// d11
		case 7: OCR1B = pulse; break;// d12
	}
} 
Esempio n. 24
0
//--------------------------------------------------------------------------
bool debmod_t::evaluate_and_handle_lowcnd(debug_event_t *event, int elc_flags)
{
  bool resume = false;
  if ( event->eid == BREAKPOINT )
  {
    ea_t ea = event->bpt.kea != BADADDR ? event->bpt.kea
            : event->bpt.hea != BADADDR ? event->bpt.hea
            : event->ea;
    QASSERT(617, !handling_lowcnds.has(ea));
    lowcnd_t *lc = get_failed_lowcnd(event->tid, ea);
    if ( lc != NULL )
    { // condition is not satisfied, just make a single step and resume
      debdeb("%a: bptcnd yielded false\n", ea);
      event->handled = true;
      resume = handle_lowcnd(lc, event, elc_flags);
    }
  }
  return resume;
}
//--------------------------------------------------------------------------
cpu_type_t macbase_debmod_t::get_process_cpu(pid_t _pid)
{
  int mib[CTL_MAXNAME];
  size_t mibLen = CTL_MAXNAME;
  int err = sysctlnametomib("sysctl.proc_cputype", mib, &mibLen);
  if ( err == 0 )
  {
    QASSERT(895, mibLen < CTL_MAXNAME);
    mib[mibLen] = _pid;
    mibLen += 1;
    cpu_type_t cpu_type;
    size_t cpuTypeSize = sizeof(cpu_type);
    err = sysctl(mib, mibLen, &cpu_type, &cpuTypeSize, 0, 0);
    if ( err == 0 )
      return cpu_type;
  }
  msg("error from sysctl: %s\n", strerror(errno));
  return 0;
}
Esempio n. 26
0
int eb_get_pos(EditBuffer *b, int *line_ptr, int *col_ptr, int offset)
{
    Page *p, *p_end;
    int line, col, line1, col1;

    QASSERT(offset >= 0);

    line = 0;
    col = 0;
    p = b->page_table;
    p_end = p + b->nb_pages;
    for (;;) {
        if (p >= p_end)
            goto the_end;
        if (offset < p->size)
            break;
        if (!(p->flags & PG_VALID_POS)) {
            p->flags |= PG_VALID_POS;
            get_pos(p->data, p->size, &p->nb_lines, &p->col, 
                    &b->charset_state);
        }
        line += p->nb_lines;
        if (p->nb_lines)
            col = 0;
        col += p->col;
        offset -= p->size;
        p++;
    }
    get_pos(p->data, offset, &line1, &col1, &b->charset_state);
    line += line1;
    if (line1)
        col = 0;
    col += col1;
 the_end:
    *line_ptr = line;
    *col_ptr = col;
    return line;
}
Esempio n. 27
0
/* return the number of lines and column position for a buffer */
static void get_pos(u8 *buf, int size, int *line_ptr, int *col_ptr, 
                    CharsetDecodeState *s)
{
    u8 *p, *p1, *lp;
    int line, len, col, ch;

    QASSERT(size >= 0);

    line = 0;
    p = buf;
    lp = p;
    p1 = p + size;
    for (;;) {
        p = memchr(p, '\n', p1 - p);
        if (!p)
            break;
        p++;
        lp = p;
        line++;
    }
    /* now compute number of chars (XXX: potential problem if out of
       block, but for UTF8 it works) */
    col = 0;
    while (lp < p1) {
        ch = s->table[*lp];
        if (ch == ESCAPE_CHAR) {
            /* XXX: utf8 only is handled */
            len = utf8_length[*lp];
            lp += len;
        } else {
            lp++;
        }
        col++;
    }
    *line_ptr = line;
    *col_ptr = col;
}
Esempio n. 28
0
float Render_Widget::get_depth_at(const math::vec2u32& coords)
{
	if (!m_flags.test(Flag::DEPTH_ACCESS))
	{
		QASSERT(0);
		return 0;
	}

	if (m_buffers_full)
	{
		auto& buffer = m_buffers[m_read_buffer_idx];
        std::lock_guard<std::mutex> lg(buffer.mutex);

        resolve_depth_buffer(buffer);

		auto c = math::min(coords, buffer.size - math::vec2u32(1, 1));

		//convert from top-left origin to openGL bottom-left origin
		c.y = buffer.size.y - c.y - 1;

		return buffer.depth_data[c.y * buffer.size.x + c.x];
	}
	return 0;
}
Esempio n. 29
0
//--------------------------------------------------------------------------
static const regval_t &idaapi arm_getreg(const char *name, const regval_t *regvals)
{
  int idx = ssmod->get_regidx(name, NULL);
  QASSERT(30182, idx >= 0 && idx < ssmod->nregs);
  return regvals[idx];
}
Esempio n. 30
0
//----------------------------------------------------------------------
static void process_operand(op_t &x,int isAlt,int isload)
{
  switch ( x.type )
  {
    case o_reg:
    case o_reglist:
      return;
    case o_imm:
      QASSERT(10090, isload);
      process_immediate_number(x.n);
      if ( op_adds_xrefs(uFlag, x.n) )
        ua_add_off_drefs2(x, dr_O, calc_opimm_flags());
      break;
    case o_phrase:
    case o_displ:
      process_immediate_number(x.n);
      if ( isAlt ) break;
      if ( op_adds_xrefs(uFlag, x.n) )
      {
        ea_t ea = ua_add_off_drefs2(x, isload ? dr_R : dr_W, calc_opdispl_flags());
        if ( ea != BADADDR )
        {
          ua_dodata2(x.offb, ea, x.dtyp);
          if ( !isload )
            doVar(ea);
        }
      }
      // create stack variables if required
      if ( x.type == o_displ
        && may_create_stkvars()
        && !isDefArg(uFlag, x.n) )
      {
        func_t *pfn = get_func(cmd.ea);
        if ( pfn != NULL
          && (issp(x.phrase)
              || isbp(x.phrase) && (pfn->flags & FUNC_FRAME) != 0) )
        {
          if ( ua_stkvar2(x, x.addr, STKVAR_VALID_SIZE) )
            op_stkvar(cmd.ea, x.n);
        }
      }
      break;
    case o_near:
    case o_far:
      {
        cref_t ftype = x.type == o_near ? fl_JN : fl_JF;
        ea_t ea = calc_mem(x);
        if ( InstrIsSet(cmd.itype, CF_CALL) )
        {
          if ( !func_does_return(ea) )
            flow = false;
          ftype = x.type == o_near ? fl_CN : fl_CF;
        }
        ua_add_cref(x.offb, ea, ftype);
      }
      break;
    case o_mem:
      {
        ea_t ea = calc_mem(x);
        ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
        ua_dodata2(x.offb, ea, x.dtyp);
        if ( !isload ) doVar(ea);
      }
      break;
    default:
      INTERR(10091);
  }
}