void traceStack(unsigned pc, unsigned sp, unsigned ra)
{
// lx4180_regfile_t *regFile = pExceptionContext;
unsigned* begin;
unsigned opcode;
/* search upward for the begin of this subroutine */
begin = (unsigned*)pc;
printk("EPC: %08x\n", begin);
#if 0
while ( isValidAddress((unsigned)begin) )
{
/* instruction "addiu sp,XX" begins a subroutine */
if ( (*begin & (OP_MASK | RS_MASK | RT_MASK)) == ADDIU_SP_SP_INSTR )
{
/* check if previous instruction is "jr ra" */
if ( *(begin - 1) == JR_RA_INSTR )
begin++;
break;
}
/* instruction "jr ra" ends a subroutine */
else if ( *begin == JR_RA_INSTR )
{
begin += 2;
break;
}
begin--;
}
if ( !isValidAddress((unsigned)begin) ) {
printk("Invalid addr %08x. Can't print stack\n", begin);
return;
}
printk("Subroutine: %08x\n", begin);
#endif
trace(ra, sp);
#if 0
opcode = *(unsigned*)pc;
if ( ((opcode & OP_MASK) == JAL_INSTR) ||
((opcode & OP_MASK) == J_INSTR) ||
((opcode & (OP_MASK | SUBCODE_MASK)) == JR_INSTR) ||
((opcode & (OP_MASK | SUBCODE_MASK)) == JALR_INSTR) ||
((opcode & OP_MASK) == BEQ_INSTR) ||
((opcode & OP_MASK) == BNE_INSTR) ||
((opcode & (OP_MASK | RT_MASK)) == BLEZ_INSTR) ||
((opcode & (OP_MASK | RT_MASK)) == BGTZ_INSTR) ||
((opcode & (OP_MASK | RT_MASK)) == BLTZ_INSTR) ||
((opcode & (OP_MASK | RT_MASK)) == BLTZAL_INSTR) ||
((opcode & (OP_MASK | RT_MASK)) == BGEZ_INSTR) ||
((opcode & (OP_MASK | RT_MASK)) == BGEZAL_INSTR) )
pc += 8;
else
pc+=4;
#endif
}
void UOscFunctionLibrary::SendOsc(FName Address, const TArray<FOscDataElemStruct> & Data, int32 TargetIndex)
{
if(!isValidAddress(Address))
{
return;
}
static_assert(sizeof(uint8) == sizeof(char), "Cannot cast uint8 to char");
osc::OutboundPacketStream output((char *)GlobalBuffer.GetData(), GlobalBuffer.Max());
check(reinterpret_cast<const void *>(GlobalBuffer.GetData()) == reinterpret_cast<const void *>(output.Data()));
appendMessage(output, Address, Data);
if(output.State() == osc::OUT_OF_BUFFER_MEMORY_ERROR)
{
GlobalBuffer.Reserve(GlobalBuffer.Max() * 2); // not enough memory: double the size
SendOsc(Address, Data, TargetIndex); // try again
return;
}
if(output.State() == osc::SUCCESS)
{
GetMutableDefault<UOscSettings>()->Send(GlobalBuffer.GetData(), output.Size(), TargetIndex);
}
else
{
UE_LOG(LogOSC, Error, TEXT("OSC Send Message Error: %s"), osc::errorString(output.State()));
}
}
void R3000DebugInterface::write32(u32 address, u32 value)
{
if (!isValidAddress(address))
return;
iopMemWrite32(address,value);
}
void R5900DebugInterface::write8(u32 address, u8 value)
{
if (!isValidAddress(address))
return;
memWrite8(address,value);
}
u32 R5900DebugInterface::read32(u32 address)
{
if (!isValidAddress(address) || address % 4)
return -1;
return memRead32(address);
}
u32 R5900DebugInterface::read8(u32 address)
{
if (!isValidAddress(address))
return -1;
return memRead8(address);
}
char* DebugInterface::stringFromPointer(u32 p)
{
const int BUFFER_LEN = 25;
static char buf[BUFFER_LEN] = { 0 };
if (!isValidAddress(p))
return NULL;
try {
for (u32 i = 0; i < BUFFER_LEN; i++) {
char c = read8(p + i);
buf[i] = c;
if (c == 0) {
return i > 0 ? buf : NULL;
}
else if (c < 0x20 || c >= 0x7f) {
// non printable character
return NULL;
}
}
}
catch (Exception::Ps2Generic&) {
return NULL;
}
buf[BUFFER_LEN - 1] = 0;
buf[BUFFER_LEN - 2] = '~';
return buf;
}
u64 R5900DebugInterface::read64(u32 address)
{
if (!isValidAddress(address) || address % 8)
return -1;
u64 result;
memRead64(address,result);
return result;
}
u128 R5900DebugInterface::read128(u32 address)
{
if (!isValidAddress(address))
return u128::From32(-1);
u128 result;
memRead128(address,result);
return result;
}
u128 R5900DebugInterface::read128(u32 address)
{
__aligned16 u128 result;
if (!isValidAddress(address) || address % 16)
{
result.hi = result.lo = -1;
return result;
}
memRead128(address,result);
return result;
}
u32 R3000DebugInterface::read32(u32 address)
{
if (!isValidAddress(address))
return -1;
return iopMemRead32(address);
}
static void trace(const unsigned ra, const unsigned sp)
{
unsigned* begin;
unsigned* jr_ra;
unsigned* lw_ra;
unsigned parent_ra;
unsigned parent_sp;
if (!isValidAddress(ra) || !isValidAddress(sp))
return;
/* search upward for the begin of this subroutine */
begin = (unsigned*)ra;
while ( isValidAddress((unsigned)begin) )
{
/* instruction "addiu sp,XX" begins a subroutine */
if ( (*begin & (OP_MASK | RS_MASK | RT_MASK)) == ADDIU_SP_SP_INSTR )
break;
/* instruction "jr ra" ends a subroutine */
else if ( *begin == JR_RA_INSTR )
{
begin += 2;
break;
}
begin--;
}
if ( !isValidAddress((unsigned)begin) )
return;
printk("Called by subroutine: %08x\n", begin);
/* search downward for instruction "jr ra", which ends this subroutine */
jr_ra = (unsigned*)ra;
while ( isValidAddress((unsigned)jr_ra) )
{
if ( *jr_ra == JR_RA_INSTR )
break;
jr_ra++;
}
if ( !isValidAddress((unsigned)jr_ra) )
return;
/* look at previous or next instruction to find offset of stack deallocation
and compute stack pointer of parent subroutine */
if ( isValidAddress((unsigned)(jr_ra - 1)) &&
((*(jr_ra - 1) & (OP_MASK | RS_MASK | RT_MASK)) == ADDIU_SP_SP_INSTR) )
parent_sp = sp + (*(jr_ra - 1) & BROFFSET_MASK);
else if ( isValidAddress((unsigned)(jr_ra + 1)) &&
((*(jr_ra + 1) & (OP_MASK | RS_MASK | RT_MASK)) == ADDIU_SP_SP_INSTR) )
parent_sp = sp + (*(jr_ra + 1) & BROFFSET_MASK);
else
return;
if ( !isValidAddress(parent_sp) || (parent_sp == sp) )
return;
/* search for instruction "lw ra,XX(XX)" between ra and end of this subroutine */
lw_ra = (unsigned*)ra;
while ( lw_ra < jr_ra )
{
if ( (*lw_ra & (OP_MASK | RS_MASK | RT_MASK)) == LW_RA_SP_INSTR )
{
if ( isValidAddress(sp + (*lw_ra & BROFFSET_MASK)) )
parent_ra = *(unsigned*)(sp + (*lw_ra & BROFFSET_MASK));
else
return;
break;
}
lw_ra++;
}
if ( !isValidAddress(parent_ra) || (parent_ra == ra) )
return;
trace(parent_ra, parent_sp);
}
/**
* Main entry point.
* @param argc
* The number of arguments.
* @param argv
* The array containing all arguments.
*/
int
main(int argc, char *argv[])
{
struct Address addr;
char const *err = NULL;
int minArg;
if (argc < 3 || argc > 5) {
return usage(argv[0]);
}
if (strcmp(argv[1], "isip") == 0) {
if (argc == 3) {
parseAddressWithoutMask(argv[2], &addr);
return isValidAddress(&addr) ? 0 : 1;
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "isipv4") == 0) {
if (argc == 3) {
parseAddressWithoutMask(argv[2], &addr);
return addr.type == AF_INET ? 0 : 1;
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "isipv6") == 0) {
if (argc == 3) {
parseAddressWithoutMask(argv[2], &addr);
return addr.type == AF_INET6 ? 0 : 1;
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "netmask") == 0) {
if (argc == 3) {
if (parseAddressWithMask(argv[2], &addr)) {
convertCIDRToNetmask(&addr);
}
return makeResult(&addr, argv[2], FALSE);
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "netmaskbits") == 0) {
if (argc == 3) {
if (parseAddressWithoutMask(argv[2], &addr)) {
convertNetmaskToCIDR(&addr);
}
else {
parseAddressWithMask(argv[2], &addr);
}
if (isValidAddress(&addr)) {
printf("%u\n", addr.netmaskbits);
return 0;
}
else {
return makeResult(&addr, argv[2], FALSE);
}
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "combine") == 0) {
minArg = 4;
}
else {
minArg = 3;
}
if (argc < minArg || argc > minArg + 1) {
return usage(argv[0]);
}
else if (argc == minArg) {
parseAddressWithMask(argv[2], &addr);
err = argv[2];
}
else {
if (parseAddressWithoutMask(argv[2], &addr)) {
struct Address mask;
if (parseAddressWithoutMask(argv[3], &mask)
&& convertNetmaskToCIDR(&mask)) {
if (addr.type == mask.type) {
addr.netmaskbits = mask.netmaskbits;
}
else {
fprintf(stderr, "address and netmask must belong to the same address family\n");
return -ERR_INVALID_NETMASK + 1;
}
}
else {
err = argv[3];
addr.type = mask.type == ERR_INVALID_ADDRESS
? ERR_INVALID_NETMASK : mask.type;
}
}
else if (parseAddressWithMask(argv[2], &addr)) {
return usage(argv[0]);
}
else {
err = argv[2];
}
}
if (strcmp(argv[1], "canonicalize") == 0) {
return makeResult(&addr, err, TRUE);
}
if (strcmp(argv[1], "network") == 0) {
if (isValidAddress(&addr)) {
convertCIDRToNetwork(&addr);
err = argv[2];
}
return makeResult(&addr, err, FALSE);
}
if (strcmp(argv[1], "host") == 0) {
if (isValidAddress(&addr)) {
convertCIDRToHost(&addr);
err = argv[2];
}
return makeResult(&addr, err, FALSE);
}
if (strcmp(argv[1], "broadcast") == 0) {
if (addr.type == AF_INET6) {
printf("ff02::1\n");
return 0;
}
else {
if (isValidAddress(&addr)) {
convertCIDRToBroadcast(&addr);
err = argv[2];
}
return makeResult(&addr, err, FALSE);
}
}
if (strcmp(argv[1], "dnsrev") == 0) {
if (isValidAddress(&addr) &&
convertCIDRToNetwork(&addr)) {
char *str = buildReverseDNSName(&addr);
if (str) {
printf("%s\n", str);
free(str);
return 0;
}
else {
fprintf(stderr, "conversion to DNS name failed\n");
return -ERR_DNS_CONVERSION_FAILED + 1;
}
}
else {
return makeResult(&addr, err, FALSE);
}
}
if (strcmp(argv[1], "combine") == 0) {
struct Address addr2;
if (isValidAddress(&addr)) {
if (parseAddressWithoutMask(argv[argc - 1], &addr2)) {
if (addr.type == addr2.type) {
combineAddresses(&addr, &addr2);
return makeResult(&addr, argv[2], TRUE);
}
else {
fprintf(stderr, "addresses to be combined must belong to the same address family\n");
return -ERR_INVALID_ADDRESS + 1;
}
}
else {
return makeResult(&addr2, argv[argc - 1], FALSE);
}
}
else {
return makeResult(&addr, err, FALSE);
}
}
// from old source:
if (! strcmp (argv[1], "dnsnet")) {
if (isValidAddress(&addr)) {
return (dnsnet (argc, argv));
}
}
return usage(argv[0]);
}