Mirrors/avrdude
1
0
Fork 0
mirror of https://github.com/avrdudes/avrdude.git synced 2026-09-24 10:06:25 +03:00
Code Issues Packages Projects Releases Wiki Activity

Move remaining static variables into context structure

Browse Source
This commit is contained in:
Stefan Rueger
2024-07-18 01:28:06 +01:00
parent 781c87d034
commit 72c70cb98b
6 changed files with 181 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/disasm.c
View File

@@ -293,13 +293,9 @@ void Disassemble(const char *Bitstream, int Read, int addr) {
}
void Display_Opcodes() {
unsigned int i;
printf("%d opcodes registered:\n", cx->dis_n_ops);
for(i = 0; i < cx->dis_n_ops; i++) {
// This invokes UB as a function pointer is converted to void * - beware
for(int i = 0; i < cx->dis_n_ops; i++)
printf("%3d: '%-80s' -> %p\n", i, cx->dis_op[i].Opcode_String, (void *) cx->dis_op[i].Callback);
}
}
int Get_Specifity(const char *Opcode) {

6
src/disasm_callbacks_assembly.c
View File

@@ -340,10 +340,9 @@ CALLBACK(call_Callback) {
if(!cx->dis_opts.Process_Labels) {
snprintf(cx->dis_code, 255, "%-7s 0x%02x", avr_opcodes[mnemo].opcode, Pos);
} else {
char *LabelName;
char *LabelComment = NULL;
const char *LabelName = Get_Label_Name(Pos, &LabelComment);
LabelName = Get_Label_Name(Pos, &LabelComment);
snprintf(cx->dis_code, 255, "%-7s %s", avr_opcodes[mnemo].opcode, LabelName);
if(LabelComment != NULL)
snprintf(cx->dis_comment, 255, "%s", LabelComment);
@@ -639,10 +638,9 @@ CALLBACK(rcall_Callback) {
}
snprintf(cx->dis_comment, 255, "0x%02x", Target);
} else {
char *LabelName;
char *LabelComment = NULL;
const char *LabelName = Get_Label_Name(Target, &LabelComment);
LabelName = Get_Label_Name(Target, &LabelComment);
snprintf(cx->dis_code, 255, "%-7s %s", avr_opcodes[mnemo].opcode, LabelName);
if(LabelComment != NULL)
snprintf(cx->dis_comment, 255, "%s", LabelComment);

83
src/disasm_jumpcall.c
View File

@@ -36,16 +36,13 @@
#include "disasm_tagfile.h"
#include "disasm_jumpcall.h"
static int JumpCall_Count;
static struct JumpCall *JumpCalls;
void Display_JumpCalls() {
int i;
printf("%d jumps/calls found:\n", JumpCall_Count);
for(i = 0; i < JumpCall_Count; i++) {
printf("%3d: 0x%-4x -> 0x%-4x %s (%d)\n", i, (unsigned int) JumpCalls[i].From, (unsigned int) JumpCalls[i].To,
avr_opcodes[JumpCalls[i].Type].opcode, JumpCalls[i].FunctionCall);
printf("%d jumps/calls found:\n", cx->dis_JumpCallN);
for(i = 0; i < cx->dis_JumpCallN; i++) {
printf("%3d: 0x%-4x -> 0x%-4x %s (%d)\n", i, (unsigned int) cx->dis_JumpCalls[i].From, (unsigned int) cx->dis_JumpCalls[i].To,
avr_opcodes[cx->dis_JumpCalls[i].Type].opcode, cx->dis_JumpCalls[i].FunctionCall);
}
}
@@ -63,21 +60,21 @@ int FixTargetAddress(int Address) {
void Register_JumpCall(int From, int To, int Type, unsigned char FunctionCall) {
if((cx->dis_opts.Process_Labels == 1) && (cx->dis_opts.Pass == 1)) {
JumpCall_Count++;
JumpCalls = mmt_realloc(JumpCalls, sizeof(struct JumpCall) * (JumpCall_Count));
JumpCalls[JumpCall_Count - 1].From = From;
JumpCalls[JumpCall_Count - 1].To = To;
JumpCalls[JumpCall_Count - 1].Type = Type;
JumpCalls[JumpCall_Count - 1].LabelNumber = 0;
JumpCalls[JumpCall_Count - 1].FunctionCall = FunctionCall;
cx->dis_JumpCallN++;
cx->dis_JumpCalls = mmt_realloc(cx->dis_JumpCalls, sizeof(Disasm_JumpCall) * (cx->dis_JumpCallN));
cx->dis_JumpCalls[cx->dis_JumpCallN - 1].From = From;
cx->dis_JumpCalls[cx->dis_JumpCallN - 1].To = To;
cx->dis_JumpCalls[cx->dis_JumpCallN - 1].Type = Type;
cx->dis_JumpCalls[cx->dis_JumpCallN - 1].LabelNumber = 0;
cx->dis_JumpCalls[cx->dis_JumpCallN - 1].FunctionCall = FunctionCall;
}
}
int JC_Comparison(const void *Element1, const void *Element2) {
struct JumpCall *JC1, *JC2;
Disasm_JumpCall *JC1, *JC2;
JC1 = (struct JumpCall *) Element1;
JC2 = (struct JumpCall *) Element2;
JC1 = (Disasm_JumpCall *) Element1;
JC2 = (Disasm_JumpCall *) Element2;
if((JC1->To) > (JC2->To))
return 1;
else if((JC1->To) == (JC2->To))
@@ -86,27 +83,27 @@ int JC_Comparison(const void *Element1, const void *Element2) {
}
void Sort_JumpCalls() {
qsort(JumpCalls, JumpCall_Count, sizeof(struct JumpCall), JC_Comparison);
qsort(cx->dis_JumpCalls, cx->dis_JumpCallN, sizeof(Disasm_JumpCall), JC_Comparison);
}
void Correct_Label_Types(void) {
int i, j;
int LastIdx = 0;
int LastDest = JumpCalls[0].To;
char CurType = JumpCalls[0].FunctionCall;
int LastDest = cx->dis_JumpCalls[0].To;
char CurType = cx->dis_JumpCalls[0].FunctionCall;
for(i = 1; i < JumpCall_Count; i++) {
if(JumpCalls[i].To != LastDest) {
for(i = 1; i < cx->dis_JumpCallN; i++) {
if(cx->dis_JumpCalls[i].To != LastDest) {
for(j = LastIdx; j < i; j++)
JumpCalls[j].FunctionCall = CurType;
cx->dis_JumpCalls[j].FunctionCall = CurType;
LastIdx = i;
LastDest = JumpCalls[i].To;
LastDest = cx->dis_JumpCalls[i].To;
CurType = 0;
}
CurType = (CurType || JumpCalls[i].FunctionCall);
CurType = (CurType || cx->dis_JumpCalls[i].FunctionCall);
}
for(j = LastIdx; j < JumpCall_Count; j++)
JumpCalls[j].FunctionCall = CurType;
for(j = LastIdx; j < cx->dis_JumpCallN; j++)
cx->dis_JumpCalls[j].FunctionCall = CurType;
}
void Enumerate_Labels(void) {
@@ -115,29 +112,29 @@ void Enumerate_Labels(void) {
int CurrentFunctionNumber = 0;
int Destination;
if(JumpCall_Count < 2)
if(cx->dis_JumpCallN < 2)
return;
Sort_JumpCalls();
Correct_Label_Types();
Destination = JumpCalls[0].To;
if(JumpCalls[0].FunctionCall)
Destination = cx->dis_JumpCalls[0].To;
if(cx->dis_JumpCalls[0].FunctionCall)
CurrentFunctionNumber++;
else
CurrentLabelNumber++;
for(i = 0; i < JumpCall_Count; i++) {
if(Destination != JumpCalls[i].To) {
if(JumpCalls[i].FunctionCall)
for(i = 0; i < cx->dis_JumpCallN; i++) {
if(Destination != cx->dis_JumpCalls[i].To) {
if(cx->dis_JumpCalls[i].FunctionCall)
CurrentFunctionNumber++;
else
CurrentLabelNumber++;
Destination = JumpCalls[i].To;
Destination = cx->dis_JumpCalls[i].To;
}
if(JumpCalls[i].FunctionCall)
JumpCalls[i].LabelNumber = CurrentFunctionNumber;
if(cx->dis_JumpCalls[i].FunctionCall)
cx->dis_JumpCalls[i].LabelNumber = CurrentFunctionNumber;
else
JumpCalls[i].LabelNumber = CurrentLabelNumber;
cx->dis_JumpCalls[i].LabelNumber = CurrentLabelNumber;
}
}
@@ -151,9 +148,9 @@ const char *Get_Label_Name(int Destination, char **LabelComment) {
return str_ccprintf("%s", Tagfile_GetLabel(TagIndex));
}
for(int i = 0; i < JumpCall_Count; i++)
if(JumpCalls[i].To == Destination)
return str_ccprintf("%s%d", JumpCalls[i].FunctionCall? "Function": "Label", JumpCalls[i].LabelNumber);
for(int i = 0; i < cx->dis_JumpCallN; i++)
if(cx->dis_JumpCalls[i].To == Destination)
return str_ccprintf("%s%d", cx->dis_JumpCalls[i].FunctionCall? "Function": "Label", cx->dis_JumpCalls[i].LabelNumber);
return "UNKNOWN";
}
@@ -163,13 +160,13 @@ void Print_JumpCalls(int Position) {
int i;
int Match = 0;
for(i = 0; i < JumpCall_Count; i++) {
if((JumpCalls[i].To) == Position) {
for(i = 0; i < cx->dis_JumpCallN; i++) {
if((cx->dis_JumpCalls[i].To) == Position) {
if(Match == 0) {
printf("\n");
Match = 1;
}
printf("; Referenced from offset 0x%02x by %s\n", JumpCalls[i].From, avr_opcodes[JumpCalls[i].Type].opcode);
printf("; Referenced from offset 0x%02x by %s\n", cx->dis_JumpCalls[i].From, avr_opcodes[cx->dis_JumpCalls[i].Type].opcode);
}
}
if(Match == 1) {

8
src/disasm_private.h
View File

@@ -36,11 +36,3 @@
#define CALLBACK(name) void name(const char *Bitstream, int Position, AVR_opcode mnemo)
struct JumpCall {
int From;
int To;
int Type;
unsigned int LabelNumber;
unsigned char FunctionCall;
};

234
src/disasm_tagfile.c
View File

@@ -37,54 +37,16 @@
#include "disasm_private.h"
#include "disasm_tagfile.h"
struct CodeLabel {
int Address;
char *Text;
char *Comment;
};
struct PGMLabel {
int Address;
char Type;
unsigned int Count;
char *Comment;
};
struct MemLabel {
int Address;
char Type;
unsigned int Count;
char *Comment;
};
struct IO_Register {
int Address;
char *Name;
unsigned char Used;
};
static int CodeLabelCount = 0;
static struct CodeLabel *CodeLabels;
static int PGMLabelCount = 0;
static struct PGMLabel *PGMLabels = NULL;
static int MemLabelCount = 0;
static struct MemLabel *MemLabels = NULL;
static struct IO_Register *IORegisters = NULL;
static int IORegistersCount = 0;
/*
static void Display_Tagfile() {
int i;
printf("%d code labels:\n", CodeLabelCount);
for(i = 0; i < CodeLabelCount; i++)
printf("%d: 0x%x = %s\n", i, CodeLabels[i].Address, CodeLabels[i].Text);
printf("%d code labels:\n", cx->dis_CodeLabelN);
for(i = 0; i < cx->dis_CodeLabelN; i++)
printf("%d: 0x%x = %s\n", i, cx->dis_CodeLabels[i].Address, cx->dis_CodeLabels[i].Text);
printf("%d PGM labels:\n", PGMLabelCount);
for(i = 0; i < PGMLabelCount; i++)
printf("%d: 0x%x = %d * %d\n", i, PGMLabels[i].Address, PGMLabels[i].Count, PGMLabels[i].Type);
printf("%d PGM labels:\n", cx->dis_PGMLabelN);
for(i = 0; i < cx->dis_PGMLabelN; i++)
printf("%d: 0x%x = %d * %d\n", i, cx->dis_PGMLabels[i].Address, cx->dis_PGMLabels[i].Count, cx->dis_PGMLabels[i].Type);
}
*/
@@ -122,32 +84,32 @@ static int ahtoi(const char *String) {
}
static void Add_LabelTag(int Address, const char *LabelText, const char *LabelComment) {
CodeLabelCount++;
cx->dis_CodeLabelN++;
CodeLabels = (struct CodeLabel *) mmt_realloc(CodeLabels, sizeof(struct CodeLabel) * CodeLabelCount);
CodeLabels[CodeLabelCount - 1].Address = Address;
CodeLabels[CodeLabelCount - 1].Text = LabelText? mmt_strdup(LabelText): NULL;
CodeLabels[CodeLabelCount - 1].Comment = LabelComment? mmt_strdup(LabelComment): NULL;
cx->dis_CodeLabels = (Disasm_CodeLabel *) mmt_realloc(cx->dis_CodeLabels, sizeof(Disasm_CodeLabel) * cx->dis_CodeLabelN);
cx->dis_CodeLabels[cx->dis_CodeLabelN - 1].Address = Address;
cx->dis_CodeLabels[cx->dis_CodeLabelN - 1].Text = LabelText? mmt_strdup(LabelText): NULL;
cx->dis_CodeLabels[cx->dis_CodeLabelN - 1].Comment = LabelComment? mmt_strdup(LabelComment): NULL;
}
static void Add_PGM_Tag(int Address, char Type, unsigned int Count, const char *Comment) {
PGMLabelCount++;
cx->dis_PGMLabelN++;
PGMLabels = (struct PGMLabel *) mmt_realloc(PGMLabels, sizeof(struct PGMLabel) * PGMLabelCount);
PGMLabels[PGMLabelCount - 1].Address = Address;
PGMLabels[PGMLabelCount - 1].Type = Type;
PGMLabels[PGMLabelCount - 1].Count = Count;
PGMLabels[PGMLabelCount - 1].Comment = Comment? mmt_strdup(Comment): NULL;
cx->dis_PGMLabels = (Disasm_PGMLabel *) mmt_realloc(cx->dis_PGMLabels, sizeof(Disasm_PGMLabel) * cx->dis_PGMLabelN);
cx->dis_PGMLabels[cx->dis_PGMLabelN - 1].Address = Address;
cx->dis_PGMLabels[cx->dis_PGMLabelN - 1].Type = Type;
cx->dis_PGMLabels[cx->dis_PGMLabelN - 1].Count = Count;
cx->dis_PGMLabels[cx->dis_PGMLabelN - 1].Comment = Comment? mmt_strdup(Comment): NULL;
}
static void Add_Mem_Tag(int Address, char Type, unsigned int Count, const char *Comment) {
MemLabelCount++;
cx->dis_MemLabelN++;
MemLabels = (struct MemLabel *) mmt_realloc(MemLabels, sizeof(struct MemLabel) * MemLabelCount);
MemLabels[MemLabelCount - 1].Address = Address;
MemLabels[MemLabelCount - 1].Type = Type;
MemLabels[MemLabelCount - 1].Count = Count;
MemLabels[MemLabelCount - 1].Comment = Comment? mmt_strdup(Comment): NULL;
cx->dis_MemLabels = (Disasm_MemLabel *) mmt_realloc(cx->dis_MemLabels, sizeof(Disasm_MemLabel) * cx->dis_MemLabelN);
cx->dis_MemLabels[cx->dis_MemLabelN - 1].Address = Address;
cx->dis_MemLabels[cx->dis_MemLabelN - 1].Type = Type;
cx->dis_MemLabels[cx->dis_MemLabelN - 1].Count = Count;
cx->dis_MemLabels[cx->dis_MemLabelN - 1].Comment = Comment? mmt_strdup(Comment): NULL;
}
static void Tagfile_Readline(char *Line, int LineNo) {
@@ -237,10 +199,10 @@ static void Tagfile_Readline(char *Line, int LineNo) {
}
static int CodeLabelSort(const void *A, const void *B) {
const struct CodeLabel *X, *Y;
const Disasm_CodeLabel *X, *Y;
X = (const struct CodeLabel *) A;
Y = (const struct CodeLabel *) B;
X = (const Disasm_CodeLabel *) A;
Y = (const Disasm_CodeLabel *) B;
if(X->Address == Y->Address)
return 0;
if(X->Address < Y->Address)
@@ -249,10 +211,10 @@ static int CodeLabelSort(const void *A, const void *B) {
}
static int PGMLabelSort(const void *A, const void *B) {
const struct PGMLabel *X, *Y;
const Disasm_PGMLabel *X, *Y;
X = (const struct PGMLabel *) A;
Y = (const struct PGMLabel *) B;
X = (const Disasm_PGMLabel *) A;
Y = (const Disasm_PGMLabel *) B;
if(X->Address == Y->Address)
return 0;
if(X->Address < Y->Address)
@@ -261,10 +223,10 @@ static int PGMLabelSort(const void *A, const void *B) {
}
static int MemLabelSort(const void *A, const void *B) {
const struct MemLabel *X, *Y;
const Disasm_MemLabel *X, *Y;
X = (const struct MemLabel *) A;
Y = (const struct MemLabel *) B;
X = (const Disasm_MemLabel *) A;
Y = (const Disasm_MemLabel *) B;
if(X->Address == Y->Address)
return 0;
if(X->Address < Y->Address)
@@ -273,9 +235,9 @@ static int MemLabelSort(const void *A, const void *B) {
}
static void Tagfile_SortLabels() {
qsort(CodeLabels, CodeLabelCount, sizeof(struct CodeLabel), CodeLabelSort);
qsort(PGMLabels, PGMLabelCount, sizeof(struct PGMLabel), PGMLabelSort);
qsort(MemLabels, MemLabelCount, sizeof(struct MemLabel), MemLabelSort);
qsort(cx->dis_CodeLabels, cx->dis_CodeLabelN, sizeof(Disasm_CodeLabel), CodeLabelSort);
qsort(cx->dis_PGMLabels, cx->dis_PGMLabelN, sizeof(Disasm_PGMLabel), PGMLabelSort);
qsort(cx->dis_MemLabels, cx->dis_MemLabelN, sizeof(Disasm_MemLabel), MemLabelSort);
}
int Read_Tagfile(const char *Filename) {
@@ -303,51 +265,51 @@ int Read_Tagfile(const char *Filename) {
}
int Tagfile_FindLabelAddress(int Address) {
struct CodeLabel Goal;
struct CodeLabel *Result;
Disasm_CodeLabel Goal;
Disasm_CodeLabel *Result;
Goal.Address = Address;
Result = bsearch(&Goal, CodeLabels, CodeLabelCount, sizeof(struct CodeLabel), CodeLabelSort);
Result = bsearch(&Goal, cx->dis_CodeLabels, cx->dis_CodeLabelN, sizeof(Disasm_CodeLabel), CodeLabelSort);
if(Result == NULL)
return -1;
return Result - CodeLabels;
return Result - cx->dis_CodeLabels;
}
char *Tagfile_GetLabel(int TagIndex) {
return CodeLabels[TagIndex].Text;
return cx->dis_CodeLabels[TagIndex].Text;
}
char *Tagfile_GetLabelComment(int TagIndex) {
return CodeLabels[TagIndex].Comment;
return cx->dis_CodeLabels[TagIndex].Comment;
}
int Tagfile_FindPGMAddress(int Address) {
struct PGMLabel Goal;
struct PGMLabel *Result;
Disasm_PGMLabel Goal;
Disasm_PGMLabel *Result;
Goal.Address = Address;
Result = bsearch(&Goal, PGMLabels, PGMLabelCount, sizeof(struct PGMLabel), PGMLabelSort);
Result = bsearch(&Goal, cx->dis_PGMLabels, cx->dis_PGMLabelN, sizeof(Disasm_PGMLabel), PGMLabelSort);
if(Result == NULL)
return -1;
return Result - PGMLabels;
return Result - cx->dis_PGMLabels;
}
const char *Tagfile_Resolve_Mem_Address(int Address) {
for(int i = 0; i < MemLabelCount && MemLabels[i].Address <= Address; i++) {
int Start = MemLabels[i].Address;
int Size = MemLabels[i].Type == TYPE_WORD? 2: 1;
int End = MemLabels[i].Address + MemLabels[i].Count * Size - 1;
for(int i = 0; i < cx->dis_MemLabelN && cx->dis_MemLabels[i].Address <= Address; i++) {
int Start = cx->dis_MemLabels[i].Address;
int Size = cx->dis_MemLabels[i].Type == TYPE_WORD? 2: 1;
int End = cx->dis_MemLabels[i].Address + cx->dis_MemLabels[i].Count * Size - 1;
if(Address >= Start && Address <= End) {
if(MemLabels[i].Count == 1) { // Single variable
if(cx->dis_MemLabels[i].Count == 1) { // Single variable
if(Size == 1)
return str_ccprintf("%s", MemLabels[i].Comment);
return str_ccprintf("_%s8(%s)", Address == Start? "lo": "hi", MemLabels[i].Comment);
return str_ccprintf("%s", cx->dis_MemLabels[i].Comment);
return str_ccprintf("_%s8(%s)", Address == Start? "lo": "hi", cx->dis_MemLabels[i].Comment);
}
// Array
if(Size == 1)
return str_ccprintf("%s[%d]", MemLabels[i].Comment, Address - Start);
return str_ccprintf("_%s8(%s[%d])", (Address-Start)%2? "hi": "lo", MemLabels[i].Comment,
return str_ccprintf("%s[%d]", cx->dis_MemLabels[i].Comment, Address - Start);
return str_ccprintf("_%s8(%s[%d])", (Address-Start)%2? "hi": "lo", cx->dis_MemLabels[i].Comment,
(Address - Start)/2);
}
}
@@ -418,7 +380,7 @@ int Tagfile_Process_Data(const char *Bitstream, int Position) {
if(Index == -1)
return 0;
switch (PGMLabels[Index].Type) {
switch (cx->dis_PGMLabels[Index].Type) {
case TYPE_BYTE:
ProcessingFunction = Tagfile_Process_Byte;
break;
@@ -433,8 +395,8 @@ int Tagfile_Process_Data(const char *Bitstream, int Position) {
break;
}
printf("; Inline PGM data: %d ", PGMLabels[Index].Count);
switch (PGMLabels[Index].Type) {
printf("; Inline PGM data: %d ", cx->dis_PGMLabels[Index].Count);
switch (cx->dis_PGMLabels[Index].Type) {
case TYPE_BYTE:
printf("byte");
break;
@@ -448,18 +410,18 @@ int Tagfile_Process_Data(const char *Bitstream, int Position) {
printf("string");
break;
}
if(PGMLabels[Index].Count != 1)
if(cx->dis_PGMLabels[Index].Count != 1)
printf("s");
printf(" starting at 0x%x", Position);
if(PGMLabels[Index].Comment != NULL) {
printf(" (%s)", PGMLabels[Index].Comment);
if(cx->dis_PGMLabels[Index].Comment != NULL) {
printf(" (%s)", cx->dis_PGMLabels[Index].Comment);
}
printf("\n");
if((PGMLabels[Index].Type == TYPE_ASTRING) || (PGMLabels[Index].Type == TYPE_STRING)) {
if(PGMLabels[Index].Comment != NULL) {
snprintf(Buffer, sizeof(Buffer), "%x_%s", Position, PGMLabels[Index].Comment);
if((cx->dis_PGMLabels[Index].Type == TYPE_ASTRING) || (cx->dis_PGMLabels[Index].Type == TYPE_STRING)) {
if(cx->dis_PGMLabels[Index].Comment != NULL) {
snprintf(Buffer, sizeof(Buffer), "%x_%s", Position, cx->dis_PGMLabels[Index].Comment);
Sanitize_String(Buffer);
} else {
snprintf(Buffer, sizeof(Buffer), "%x", Position);
@@ -467,11 +429,11 @@ int Tagfile_Process_Data(const char *Bitstream, int Position) {
}
BytesAdvanced = 0;
for(i = 0; i < PGMLabels[Index].Count; i++) {
for(i = 0; i < cx->dis_PGMLabels[Index].Count; i++) {
BytesAdvanced += ProcessingFunction(Bitstream, Position + BytesAdvanced, i, Buffer);
}
if(PGMLabels[Index].Type == TYPE_ASTRING) {
if(cx->dis_PGMLabels[Index].Type == TYPE_ASTRING) {
// Autoaligned string
if((BytesAdvanced % 2) != 0) {
// Not yet aligned correctly
@@ -501,72 +463,72 @@ static char *regname(const char *reg, int suf) {
return ret;
}
// Initialise IORegisters and MemLabels from part register file
// Initialise cx->dis_IORegisters and cx->dis_MemLabels from part register file
void initRegisters(const AVRPART *p) {
int nr = 0, nio = 0, offset = 0;
const Register_file *rf = avr_locate_register_file(p, &nr);
if(rf) {
if(IORegisters) {
for(int i = 0; i < IORegistersCount; i++)
mmt_free(IORegisters[i].Name);
mmt_free(IORegisters);
if(cx->dis_IORegisters) {
for(int i = 0; i < cx->dis_IORegisterN; i++)
mmt_free(cx->dis_IORegisters[i].Name);
mmt_free(cx->dis_IORegisters);
}
if(MemLabels) {
for(int i = 0; i < MemLabelCount; i++)
mmt_free(MemLabels[i].Comment);
mmt_free(MemLabels);
if(cx->dis_MemLabels) {
for(int i = 0; i < cx->dis_MemLabelN; i++)
mmt_free(cx->dis_MemLabels[i].Comment);
mmt_free(cx->dis_MemLabels);
}
// Count how many entries are needed
for(int i = 0; i< nr; i++)
if(rf[i].addr < 0x40 && rf[i].size > 0)
nio += rf[i].size;
IORegisters = mmt_malloc(nio*sizeof*IORegisters);
MemLabels = mmt_malloc(nr*sizeof*MemLabels);
cx->dis_IORegisters = mmt_malloc(nio*sizeof*cx->dis_IORegisters);
cx->dis_MemLabels = mmt_malloc(nr*sizeof*cx->dis_MemLabels);
AVRMEM *mem = avr_locate_io(p);
if(mem)
offset = mem->offset;
nio = 0;
for(int i = 0; i< nr; i++) {
MemLabels[i].Address = offset + rf[i].addr;
MemLabels[i].Type = rf[i].size == 2? TYPE_WORD: TYPE_BYTE;
MemLabels[i].Count = rf[i].size > 2? rf[i].size: 1;
MemLabels[i].Comment = regname(rf[i].reg, -1);
cx->dis_MemLabels[i].Address = offset + rf[i].addr;
cx->dis_MemLabels[i].Type = rf[i].size == 2? TYPE_WORD: TYPE_BYTE;
cx->dis_MemLabels[i].Count = rf[i].size > 2? rf[i].size: 1;
cx->dis_MemLabels[i].Comment = regname(rf[i].reg, -1);
if(rf[i].addr < 0x40) {
if(rf[i].size == 1) {
IORegisters[nio].Name = regname(rf[i].reg, -1);
IORegisters[nio].Address = rf[i].addr;
cx->dis_IORegisters[nio].Name = regname(rf[i].reg, -1);
cx->dis_IORegisters[nio].Address = rf[i].addr;
nio++;
} else if(rf[i].size == 2) {
IORegisters[nio].Name = regname(rf[i].reg, 'l');
IORegisters[nio].Address = rf[i].addr;
cx->dis_IORegisters[nio].Name = regname(rf[i].reg, 'l');
cx->dis_IORegisters[nio].Address = rf[i].addr;
nio++;
IORegisters[nio].Name = regname(rf[i].reg, 'h');
IORegisters[nio].Address = rf[i].addr+1;
cx->dis_IORegisters[nio].Name = regname(rf[i].reg, 'h');
cx->dis_IORegisters[nio].Address = rf[i].addr+1;
nio++;
} else if(rf[i].size > 2) {
for(int k = 0; k < rf[i].size; k++) {
IORegisters[nio].Name = regname(rf[i].reg, k);
IORegisters[nio].Address = rf[i].addr + k;
cx->dis_IORegisters[nio].Name = regname(rf[i].reg, k);
cx->dis_IORegisters[nio].Address = rf[i].addr + k;
nio++;
}
}
}
}
IORegistersCount = nio;
MemLabelCount = nr;
qsort(MemLabels, MemLabelCount, sizeof(struct MemLabel), MemLabelSort);
cx->dis_IORegisterN = nio;
cx->dis_MemLabelN = nr;
qsort(cx->dis_MemLabels, cx->dis_MemLabelN, sizeof(Disasm_MemLabel), MemLabelSort);
}
}
const char *Resolve_IO_Register(int Number) {
for(int i = 0; i < IORegistersCount; i++) {
if(IORegisters[i].Address == Number) {
IORegisters[i].Used = 1;
return IORegisters[i].Name;
for(int i = 0; i < cx->dis_IORegisterN; i++) {
if(cx->dis_IORegisters[i].Address == Number) {
cx->dis_IORegisters[i].Used = 1;
return cx->dis_IORegisters[i].Name;
}
}
@@ -574,7 +536,7 @@ const char *Resolve_IO_Register(int Number) {
}
void Emit_Used_IO_Registers() {
for(int i = 0; i < IORegistersCount; i++)
if(IORegisters[i].Used)
printf(".equ %s, 0x%x\n", IORegisters[i].Name, IORegisters[i].Address);
for(int i = 0; i < cx->dis_IORegisterN; i++)
if(cx->dis_IORegisters[i].Used)
printf(".equ %s, 0x%x\n", cx->dis_IORegisters[i].Name, cx->dis_IORegisters[i].Address);
}

40
src/libavrdude.h
View File

@@ -1470,6 +1470,40 @@ typedef struct {
AVR_cycle_index cycle_index;
} Disasm_options;
typedef struct {
int From;
int To;
int Type;
unsigned int LabelNumber;
unsigned char FunctionCall;
} Disasm_JumpCall;
typedef struct {
int Address;
char *Text;
char *Comment;
} Disasm_CodeLabel;
typedef struct {
int Address;
char Type;
unsigned int Count;
char *Comment;
} Disasm_PGMLabel;
typedef struct {
int Address;
char Type;
unsigned int Count;
char *Comment;
} Disasm_MemLabel;
typedef struct {
int Address;
char *Name;
unsigned char Used;
} Disasm_IO_Register;
typedef enum {
OPCODE_add, OPCODE_adc, OPCODE_adiw, OPCODE_sub,
OPCODE_subi, OPCODE_sbc, OPCODE_sbci, OPCODE_sbiw,
@@ -1776,6 +1810,12 @@ typedef struct {
Disasm_opcode dis_op[256]; // Must be 256
int dis_regs[256]; // Must be 256
char dis_code[256], dis_comment[256], dis_after_code[256]; // Must be 256
int dis_JumpCallN, dis_CodeLabelN, dis_PGMLabelN, dis_MemLabelN, dis_IORegisterN;
Disasm_JumpCall *dis_JumpCalls;
Disasm_CodeLabel *dis_CodeLabels;
Disasm_PGMLabel *dis_PGMLabels;
Disasm_MemLabel *dis_MemLabels;
Disasm_IO_Register *dis_IORegisters;
// Static variables from usb_libusb.c
#include "usbdevs.h"