christoph/fail
1
Fork 0
Code Releases Activity

T32: Evalute memory map, RangeListener, MemAccess

Browse Source
This commit is contained in:
Martin Hoffmann
2013-02-17 21:41:30 +01:00
parent e66ae5e691
commit 447411da9a
5 changed files with 217 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
debuggers/t32/include/T32Connector.hpp
View File

@ -1,20 +1,84 @@
#ifndef __T32CONNECTOR_HPP__
#define __T32CONNECTOR_HPP__
#include <util/Logger.hpp>
#include <utility>
#include <vector>
#include "sal/SALInst.hpp"
namespace fail {
class T32Connector {
char* m_hostname;
unsigned m_port;
unsigned m_packetlength;
/**
* \class T32Connector
*
* \brief Connector to the remote T32 device.
*/
class T32Connector {
public:
T32Connector() : m_hostname("localhost"), m_port("20010"), m_packetlength("1024"), m_log("T32", false), m_connection_established(false) { };
T32Connector(const char* hostname, const char* port, const char* packlen) : m_hostname(hostname), m_port(port),
m_packetlength(packlen), m_log("T32", false), m_connection_established(false) { };
public:
T32Connector() { };
T32Connector(char* hostname, unsigned port, unsigned packlen);
~T32Connector();
~T32Connector();
};
// Setters/getters
void setHostname(const char* host) { m_hostname = host; };
const char* getHostname(const char* host) const { return m_hostname; };
void setPort(const char* port) { m_port = port; };
const char* getPort(const char* port) const { return m_port; };
void setPacketlength(const char* packetlength) { m_packetlength = packetlength; };
const char* getPacketlength(const char* packetlength) const { return m_packetlength; };
void setScript(const char* script) { m_script = script; };
const char* getScript(const char* script) const { return m_script; };
/**
* @brief Connect and initialize T32 device
*/
bool startup(void);
bool isRunning(void) const { return getState() == RUNNING; } ;
bool isHalted(void) const { return getState() == HALTED; } ;
bool isStopped(void) const { return getState() == STOPPED; } ;
bool isDown(void) const { return getState() == DOWN; };
bool isBigEndian(void) const { return !m_littleendian; };
bool isLittleEndian(void) const { return m_littleendian; };
private:
const char* m_hostname; //!< The hostname of the T32 device
const char* m_port; //!< The port to connect as configure in config.t32. Here we use strings, as required by the API
const char* m_packetlength; //!< The packetlength of a command packet?
const char* m_script; //!< The user defined startup script to bring up the device
mutable fail::Logger m_log; //!< Logging (mutable for calls of the err method)
std::string m_cpustring;
typedef std::vector< std::pair< address_t, address_t > > memory_map_t;
memory_map_t m_data_memory_map;
memory_map_t m_program_memory_map;
bool m_littleendian; //!< Big endian: 0, little endian != 0
bool m_connection_established;
/* ---- Private methods ---- */
/**
* @brief Internal error handling
*/
bool err(int) const;
bool scriptRunning(void) const;
enum ICE_state_t { DOWN = 0, HALTED = 1, STOPPED = 2, RUNNING = 3, };
int getState(void) const;
enum MemoryDiscoverCommand_t { DISCOVER_PROGRAM_RAM = 2, DISCOVER_DATA_RAM = 1, DISCOVER_END = 0, };
void discoverMemory(int discovertype, memory_map_t & map);
};
} // end-of-namespace fail
#endif // __T32CONNECTOR_HPP__

76
debuggers/t32/src/T32Connector.cc
View File

@ -1,17 +1,79 @@
#include "T32Connector.hpp"
#include <iostream>
namespace fail {
T32Connector::T32Connector(char *hostname, unsigned port, unsigned packlen) : m_hostname(hostname), m_port(port), m_packetlength(packlen) {
}
#include <t32.h>
using namespace fail;
T32Connector::~T32Connector() {
if(m_connection_established){
// Close Connection to T32 on object deletion. Also works, on simulator.terminate -> global object.
std::cout << "[T32] Closing connection." << std::endl;
m_log << "Closing connection." << std::endl;
}
}
bool T32Connector::startup(){
// Setup connection to Lauterbach
m_log << "Remote connection: " << m_hostname << ":" << m_port << " - Packet length: " << m_packetlength << std::endl;
T32_Config("NODE=", m_hostname);
T32_Config("PACKLEN=", m_packetlength);
T32_Config("PORT=", m_port);
m_log << "Init." << std::endl;
if(!err(T32_Init()) ) { return false; }
m_log << "Attach." << std::endl;
if(!err(T32_Attach(T32_DEV_ICD)) ) { return false; }
word tmp, fpu, endian;
char* cpuname[128];
//if(!err(T32_GetCpuInfo( reinterpret_cast<char**>(&m_cpustring), &fpu, &endian, &tmp))) { return false; }
if(!err(T32_GetCpuInfo( reinterpret_cast<char**>(&cpuname), &fpu, &endian, &tmp))) { return false; }
m_littleendian = (endian != 0);
m_cpustring = reinterpret_cast<const char*>(cpuname);
m_log << "Attached to: " << m_cpustring << std::endl;
// discoverMemory(DISCOVER_PROGRAM_RAM, m_program_memory_map);
// discoverMemory(DISCOVER_DATA_RAM, m_data_memory_map);
m_connection_established = true;
// TODO send init script.
return true;
}
void T32Connector::discoverMemory(int access, memory_map_t& map) {
dword pstart = 0, pend;
word paccess;
do {
paccess = access;
err(T32_GetRam(&pstart, &pend, &paccess));
if(paccess != DISCOVER_END){
map.push_back(std::make_pair<address_t, address_t>( pstart, pend ));
}
} while(paccess != DISCOVER_END);
}
bool T32Connector::scriptRunning() const {
int retval = 0;
err(T32_GetPracticeState( &retval ));
return (retval == 1);
}
int T32Connector::getState() const {
int retval = 0;
err(T32_GetState( &retval ));
return retval;
}
/* Default T32 error handler */
bool T32Connector::err(int errornum) const {
if(errornum != 0){
//m_log << "Error: " << errornum << std::endl;
return false;
}
return true;
}
}

40
debuggers/t32/src/main.cc
View File

@ -15,7 +15,7 @@
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include "config/VariantConfig.hpp"
#include "sal/SALInst.hpp"
#include "optionparser.h"
@ -24,14 +24,6 @@
#include "T32Connector.hpp"
using namespace std;
/* Default T32 error handler */
void err(int ernum){
if(err != 0){
cerr << "Error: " << err << endl;
//exit(-1);
}
}
static fail::T32Connector t32;
//!< Program options
@ -62,7 +54,7 @@ int main(int argc, char** argv){
return 1;
}
if ( options[HELP] ) // || argc == 0 || options[RUN].count() == 0) // to enforce -s
if ( options[HELP] ) // || argc == 0 || options[RUN].count() == 0) // to enforce -s
{
int columns = getenv("COLUMNS")? atoi(getenv("COLUMNS")) : 80;
option::printUsage(fwrite, stdout, usage, columns);
@ -70,39 +62,23 @@ int main(int argc, char** argv){
}
if(options[RUN].count()){
cout << "Script: " << options[RUN].first()->arg << endl;
t32.setScript(options[RUN].first()->arg);
}
char hostname[] = "localhost";
if(options[T32HOST].count()){
cout << "T32 Hostname: " << options[T32HOST].first()->arg << endl;
t32.setHostname(options[T32HOST].first()->arg);
}
char port[] = "20010";
if(options[PORT].count()){
cout << "T32 Port: " << options[PORT].first()->arg << endl;
t32.setPort(options[PORT].first()->arg);
}
char packlen[] = "1024";
if(options[PACKLEN].count()){
cout << "T32 Packet Length: " << options[PACKLEN].first()->arg << endl;
t32.setPacketlength(options[PACKLEN].first()->arg);
}
// Setup connection to Lauterbach
cout << "Lauterbach remote connection" << endl;
int error;
cout << "[T32] Connecting to " << hostname << ":" << port << " Packlen: " << packlen << endl;
T32_Config("NODE=", hostname);
T32_Config("PACKLEN=", packlen);
T32_Config("PORT=", port);
cout << "[T32] Init." << endl;
err(T32_Init());
cout << "[T32] Attach." << endl;
err(T32_Attach(T32_DEV_ICD));
// Initialize T32
t32.startup();
// Let the SimulatorController do the dirty work.