RAM geheugen uitpluizen

[nicoverduin Profiel PrivéberichtWebsite]

Dit zal wel meer voor de specialisten zijn maar het gaat ff om het volgende. Er is al vaker aangegeven dat String() nogal tot fragmentatie voor de Heap() (vrije RAM geheugen) leidt. Dus tijd omdat eens te controleren of er al wat verbeterd is. Nou dat is zeker niet het geval. Wat wel beter lijkt te werken is dat de free() functie [tegenhanger van malloc() of new()] aansluitende blokken die vrij zijn gegeven weer tot een nieuw vrij blok geheugen. Of dit altijd al zo was, weet ik niet, maar dat werkt goed. Helaas is er weinig te vinden over zogenaamde 'heap-walking' dus een manier om een overzicht te krijgen van de gefragmenteerde stukken RAM geheugen.
Moet het kunnen? Ja want anders zou het onmogelijk zijn voor een sketch om een malloc() of new() uit te voeren. Er is een library MemoryFree die aangeeft hoeveel vrije ruimte er nog over is, maar dat is een schijnzekerheid omdat je wel ziet hoeveel er vrij is maar niet hoe het gefragmenteerd is.
De vraag is zijn er al eens anderen hiermee bezig geweest? Of ben ik de pineut

Ik heb al een een eenvoudige dump testprogramma om het geheugen verder uit te printen naar de Serial (zoals de vroegere debug onder msdos.
cpp code

#include "Arduino.h"
//#include "MemoryFree.h"
//The setup function is called once at startup of the sketch

String test = "";
String test1 = "";
String test2 = "";
//struct __freelist {
//	size_t sz;
//	struct __freelist *nx;
//};

/* The head of the free list structure */
//extern struct __freelist *__flp;
uint8_t *tempPtr;
uint8_t *tempPtr2;

void setup() {

	Serial.begin(9600);
	printHeapList();
}

// The loop function is called in an endless loop
void loop() {
}

/**
 * print heap list
 */
void printHeapList() {
	char buffer[100];
	Serial.println();
	for (uint8_t i = 'a'; i <= 'z'; i++) {
		test = test +  (char)i;
	}
	test1 = "Dit is een test regel";
	//
	// and print all again
	//
	Serial.println();
	Serial.println();
	sprintf(buffer, "Heap start				: %04X Heap end 		: %04X\n", (uint16_t)__malloc_heap_start, (uint16_t)__malloc_heap_end);
	Serial.print(buffer);
	sprintf(buffer, "Heap start address  	: %04X Heap end address : %04X\n", (uint16_t)&__malloc_heap_start, (uint16_t)&__malloc_heap_end);
	Serial.print(buffer);
	sprintf(buffer, "test address  			: %04X \n", (uint16_t)test.c_str());
	Serial.print(buffer);
	test1 = "Dit is een test regel";
	sprintf(buffer, "test1 address  			: %04X \n", (uint16_t)test1.c_str());
	Serial.print(buffer);
	test2 = "Dit is een regel";
	test2 = test2 + "en laten we er nog een regel bij doen";
	sprintf(buffer, "test2 address  			: %04X \n", (uint16_t)test2.c_str());
	Serial.print(buffer);
	test2 = test2 + "En doe eens gek en doe er nog eentje bij";
	sprintf(buffer, "test2 address  			: %04X \n", (uint16_t)test2.c_str());
	Serial.print(buffer);
	//
	// print memory dump
	//
	uint8_t *ptr = (uint8_t *)0x100;
	while ((uint16_t)ptr < 0x500) {
		sprintf(buffer, "\n%04X ", (uint16_t)ptr);
		Serial.print(buffer);
		for (uint8_t i = 0; i < 16; i++) {
			sprintf(buffer, "%02X ", *ptr);
			Serial.print(buffer);
			ptr++;
		}
		//
		// print character representation of dump values
		//
		ptr = ptr - 16;
		for (uint8_t i = 0; i < 16; i++) {
			if (*ptr <= 0x0D) {
				Serial.print(".");
			} else {
				Serial.print((char)*ptr);
			}
			ptr++;
		}
	}
}

En daar wat testjes mee gedaan. Dit genereert al aardig wat fragmenten in het RAM geheugen.
cpp code

Heap start				: 0314 Heap end 		: 0000
Heap start address  	: 0102 Heap end address : 0100
test address  			: 0362 
test1 address  			: 034A 
test2 address  			: 03B7 
test2 address  			: 044F 

0100 00 00 14 03 80 00 44 69 74 20 69 73 20 65 65 6E ...€.Dit is een
0110 20 74 65 73 74 20 72 65 67 65 6C 00 48 65 61 70  test regel.Heap
0120 20 73 74 61 72 74 09 09 09 09 3A 20 25 30 34 58  start....: %04X
0130 20 48 65 61 70 20 65 6E 64 20 09 09 3A 20 25 30  Heap end ..: %0
0140 34 58 0A 00 48 65 61 70 20 73 74 61 72 74 20 61 4X..Heap start a
0150 64 64 72 65 73 73 20 20 09 3A 20 25 30 34 58 20 ddress  .: %04X 
0160 48 65 61 70 20 65 6E 64 20 61 64 64 72 65 73 73 Heap end address
0170 20 3A 20 25 30 34 58 0A 00 74 65 73 74 20 61 64  : %04X..test ad
0180 64 72 65 73 73 20 20 09 09 09 3A 20 25 30 34 58 dress  ...: %04X
0190 20 0A 00 74 65 73 74 31 20 61 64 64 72 65 73 73  ..test1 address
01A0 20 20 09 09 09 3A 20 25 30 34 58 20 0A 00 44 69   ...: %04X ..Di
01B0 74 20 69 73 20 65 65 6E 20 72 65 67 65 6C 00 65 t is een regel.e
01C0 6E 20 6C 61 74 65 6E 20 77 65 20 65 72 20 6E 6F n laten we er no
01D0 67 20 65 65 6E 20 72 65 67 65 6C 20 62 69 6A 20 g een regel bij 
01E0 64 6F 65 6E 00 74 65 73 74 32 20 61 64 64 72 65 doen.test2 addre
01F0 73 73 20 20 09 09 09 3A 20 25 30 34 58 20 0A 00 ss  ...: %04X ..
0200 45 6E 20 64 6F 65 20 65 65 6E 73 20 67 65 6B 20 En doe eens gek 
0210 65 6E 20 64 6F 65 20 65 72 20 6E 6F 67 20 65 65 en doe er nog ee
0220 6E 74 6A 65 20 62 69 6A 00 0A 25 30 34 58 20 00 ntje bij..%04X .
0230 25 30 32 58 20 00 2E 00 00 00 00 00 82 02 EE 03 %02X .......‚.î.
0240 04 02 1D 02 0F 02 60 02 0D 0A 00 6E 61 6E 00 69 ....`....nan.i
0250 6E 66 00 6F 76 66 00 00 4F 04 5D 00 5D 00 4A 03 nf.ovf..O.].].J.
0260 15 00 15 00 62 03 1A 00 1A 00 3C 02 00 00 E8 03 ..b...<...è.
0270 00 00 00 00 00 00 C5 00 C4 00 C0 00 C1 00 C2 00 ......Å.Ä.À.Á.Â.
0280 C6 00 01 00 00 29 2D 00 00 00 00 00 00 00 00 00 Æ.............
0290 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
02A0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
02B0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
02C0 00 00 00 00 00 00 00 20 30 30 20 30 30 20 32 30 ....... 00 00 20
02D0 20 33 30 20 33 30 20 32 30 20 32 30 20 33 32 20  20 32 30 20 32 
02E0 33 30 20 32 30 20 33 33 20 33 32 20 32 30 20 32 33 32 20 32 30 2
02F0 30 20 33 32 20 33 33 20 33 32 20 32 30 20 33 32 0 20 33 32 0 20 
0300 33 33 20 33 32 20 30 46 C6 09 00 00 98 09 00 00        2ç...°...
0310 AD 04 14 03 32 00 7D 03 02 00 20 03 2A 00 00 00 ­..2.}... .*...
0320 74 20 69 73 20 65 65 6E 20 72 65 67 65 6C 00 17 t is een regel.
0330 00 00 00 6B 6C 11 00 00 00 74 20 69 73 20 65 65 ...kl...t is ee
0340 6E 20 72 65 67 65 6C 00 16 00 44 69 74 20 69 73 n regel..Dit is
0350 20 65 65 6E 20 74 65 73 74 20 72 65 67 65 6C 00  een test regel.
0360 1B 00 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E .abcdefghijklmn
0370 6F 70 71 72 73 74 75 76 77 78 79 7A 00 CE 00 00 opqrstuvwxyz.Î..
0380 00 74 20 69 73 20 65 65 6E 20 72 65 67 65 6C 65 .t is een regele
0390 6E 20 6C 61 74 65 6E 20 77 65 20 65 72 20 6E 6F n laten we er no
03A0 67 20 65 65 6E 20 72 65 67 65 6C 20 62 69 6A 20 g een regel bij 
03B0 64 6F 65 6E 00 36 00 00 00 74 20 69 73 20 65 65 doen.6...t is ee
03C0 6E 20 72 65 67 65 6C 65 6E 20 6C 61 74 65 6E 20 n regelen laten 
03D0 77 65 20 65 72 20 6E 6F 67 20 65 65 6E 20 72 65 we er nog een re
03E0 67 65 6C 20 62 69 6A 20 64 6F 65 6E 00 5E 00 00 gel bij doen.^..
03F0 00 74 20 69 73 20 65 65 6E 20 72 65 67 65 6C 65 .t is een regele
0400 6E 20 6C 61 74 65 6E 20 77 65 20 65 72 20 6E 6F n laten we er no
0410 67 20 65 65 6E 20 72 65 67 65 6C 20 62 69 6A 20 g een regel bij 
0420 64 6F 65 6E 45 6E 20 64 6F 65 20 65 65 6E 73 20 doenEn doe eens 
0430 67 65 6B 20 65 6E 20 64 6F 65 20 65 72 20 6E 6F gek en doe er no
0440 67 20 65 65 6E 74 6A 65 20 62 69 6A 00 5E 00 44 g eentje bij.^.D
0450 69 74 20 69 73 20 65 65 6E 20 72 65 67 65 6C 65 it is een regele
0460 6E 20 6C 61 74 65 6E 20 77 65 20 65 72 20 6E 6F n laten we er no
0470 67 20 65 65 6E 20 72 65 67 65 6C 20 62 69 6A 20 g een regel bij 
0480 64 6F 65 6E 45 6E 20 64 6F 65 20 65 65 6E 73 20 doenEn doe eens 
0490 67 65 6B 20 65 6E 20 64 6F 65 20 65 72 20 6E 6F gek en doe er no
04A0 67 20 65 65 6E 74 6A 65 20 62 69 6A 00 F2 DD CF g eentje bij.òÝÏ
04B0 FA 46 3F AD 6D AC 7E CF 26 EF 33 FC F7 D5 FC F3 úF?­m¬~Ï&ï3ü÷Õüó
04C0 F3 DF 2B EB 8F 25 7D F7 61 EA E7 E1 A7 B6 7E A7 óß+ë�%}÷aêç᧶~§
04D0 A6 DD FE EB EB FF 7C BE 76 FB EF CB 6B 2D 77 B0 ¦Ýþëëÿ|¾vûïËk-w°
04E0 F6 FF 53 9E EB F6 DD E7 BB 65 EE 63 6F 4D 72 43 öÿSžëöÝç»eîcoMrC
04F0 77 DE A3 EF F4 B6 57 43 39 3A 2B 5A FB 51 7D BD wÞ£ïô¶WC9:+ZûQ}½

Op adres 0x102 staat de eerste vrije lokatie. De avr-gcc documentatie verteld wel iets over de malloc en free maar inhoudelijk nog weinig. Dus daar zal ik wel verder in moeten spitten.
Kijken of ik een mooie 'heap-walker' class kan maken. Kan behulpzaam zijn bij debuggen als de sketch zomaar stopt.

Maar vertel... Ben ik Remy in deze?

[Koepel Profiel Privébericht]

Antwoord : https://www.youtube.com/watch?v=o2aW6KVVeFc
Toch is er wel goede documentatie : http://www.nongnu.org/avr-libc/user-manual/malloc.html
Ik zocht op Github, maar kon het niet vinden.

Zou het op dezelfde manier werken als de gewone gcc compiler heap van libc ? Maar ook daar een goed voorbeeld van kon ik niet vinden.

[nicoverduin Profiel PrivéberichtWebsite]

Die documentatie had ik al gelezen. Maar ergens in die library gaat hij ook de heap doorlopen. En dat stukje code ergens..... in libc zoek ik
Ik had ook al op Github zo ongeveer elke link die er was. Mogelijk maar eens kijken op het internationale forum. Zitten ook nog wel een paar experts die wel van een uitdaging houden

[nicoverduin Profiel PrivéberichtWebsite]

Inmiddels wel een stuk verder. De volgende code geeft o.a. een keurige lijst van alle vrije stukken geheugen die tussen de in gebruik zijnde variabelen zitten. Interessant om te weten is dat:
a) Elke malloc() die uitgevoerd wordt kost 2 bytes meer. Deze staan VOOR het adres die je terug krijgt van malloc() en geeft de lengte aan in bytes
b) String() zijn de grootste vervuilers van de heap. Elke keer dat je een letter plakt aan een string wordt het oude stukje vrijgegeven en een nieuwe malloc() uitgevoerd. Dit leidt tot grote fragmentatie van de Heap.
c) Een string in een functie gebruiken wordt automatisch helemaal opgeruimd als de functie klaar is.
d) Als je geheugen in een functie echter alloceert en daarna beëindig je de functie zonder dit stukje weer vrij te geven (via de free() functie) ben je dat stukje kwijt uit de heap. Op enig moment ben je dan het RAM geheugen kwijt totdat er een reset begint.

Ik zit nog te denken om een defrag functie te bouwen om alle lege stukken uit de heap te halen door alle variabelen naar voren te schuiven. De pointers naar die stukken zijn variabelen die ofwel in de stack staan ofwel in het global variabelen gedeelte (dat is dus het RAM van adres 0x100 tot pointer naar __malloc_heap_start - 4bytes). Theoretisch zou ik kunnen scannen op pointers die verwijzen naar de variabelen in de heap of stack. Want die moet je allemaal aanpassen. Maar dan kan je wel de heap opschonen en maximaal gebruik kunnen maken van het beperkte RAM geheugen.

cpp code

#include "Arduino.h"
#include "MemoryFree.h"
//The setup function is called once at startup of the sketch

uint8_t * p1;
uint8_t * p2;
uint8_t * p3;
uint8_t * p4;
uint8_t * p5;
uint8_t * p6;
uint8_t * p7;

struct __freelist {
	size_t sz;
	struct __freelist *nx;
};

void setup() {

	Serial.begin(9600);

	char buffer[70];

	sprintf(buffer, "FreeMemory = %d", freeMemory());
	Serial.println(buffer);

	p1 = (uint8_t *)malloc(10 * sizeof(uint8_t));
	p2 = (uint8_t *)malloc(15 * sizeof(uint8_t));
	p3 = (uint8_t *)malloc(20 * sizeof(uint8_t));
	p4 = (uint8_t *)malloc(25 * sizeof(uint8_t));
	p5 = (uint8_t *)malloc(30 * sizeof(uint8_t));
	p6 = (uint8_t *)malloc(35 * sizeof(uint8_t));
	p7 = (uint8_t *)malloc(40 * sizeof(uint8_t));
	for (uint8_t i = 0; i < 10; i++) {
		p1[i] = 1;
	}
	for (uint8_t i = 0; i < 15; i++) {
		p2[i] = 2;
	}
	for (uint8_t i = 0; i < 20; i++) {
		p3[i] = 3;
	}
	for (uint8_t i = 0; i < 25; i++) {
		p4[i] = 4;
	}
	for (uint8_t i = 0; i < 30; i++) {
		p5[i] = 5;
	}
	for (uint8_t i = 0; i < 35; i++) {
		p6[i] = 6;
	}
	for (uint8_t i = 0; i < 40; i++) {
		p7[i] = 7;
	}

	free(p2);
	free(p4);
	free(p6);

	printHeapList();

}

// The loop function is called in an endless loop
void loop() {
}

/**
 * print heap list
 */
void printHeapList() {
	char buffer[100];
	//
	// show generic info
	//
	sprintf(buffer, "heap_start =  %04X\n", (uint16_t)__malloc_heap_start);
	Serial.print(buffer);
	uint16_t *freeRamPtr = (uint16_t *)(__malloc_heap_start - 4);
	sprintf(buffer, "unused RAM =  %04X\n", (uint16_t)freeRamPtr[0]);
	Serial.print(buffer);

//	printDump((uint8_t *)((uint16_t)__malloc_heap_start & 0xFFF0), (uint8_t *)*freeRamPtr);
	//
	// Get first location
	//
	uint16_t *freePtr 	= (uint16_t*)__malloc_heap_start - 2;
	if (freePtr[1] != 0) {
		//
		// walk the free segments until the next ptr = 0
		//
		do  {
			//
			// point to next location
			//
			freePtr 			= (uint16_t *)freePtr[1];
			//
			// get size of each free segment
			//
			uint16_t freeSize 	= freePtr[0];
			//
			// display output
			//
			sprintf(buffer, "location : %04X has %d bytes free\n", (uint16_t)freePtr, freeSize + 2);
			Serial.print(buffer);
		} while (freePtr[1] != 0);
	}
}
void printDump (uint8_t *beginAddress, uint8_t *endAddress) {
	char buffer[70];
	//
	// print memory dump
	//
	uint8_t *ptr = beginAddress;
	//
	// we will always finish the line
	//
	while ((uint16_t)ptr < (uint16_t)endAddress) {
		sprintf(buffer, "\n%04X ", (uint16_t)ptr);
		Serial.print(buffer);
		for (uint8_t i = 0; i < 16; i++) {
			sprintf(buffer, "%02X ", *ptr);
			Serial.print(buffer);
			ptr++;
		}
		//
		// print character representation of dump values
		//
		ptr = ptr - 16;							// jump back to the start of this line

		for (uint8_t i = 0; i < 16; i++) {
			if (*ptr == 0x0D || *ptr == 0x0A) {
				Serial.print(".");
			} else {
				Serial.print((char)*ptr);
			}
			ptr++;
		}
	}
	Serial.println();
}

void createString(){
	char buffer[70];
	uint8_t *ptr;
	ptr = (uint8_t *)malloc (20* sizeof(uint8_t));
	Serial.print("ptr points to = ");
	Serial.println((uint16_t)ptr, HEX);
	sprintf(buffer, "FreeMemory = %d", freeMemory());
	Serial.println(buffer);
	printHeapList();
}

Verder is het best interessant om een assembly listing van dit programma (of welk programma dan ook) om eens te kijken wat er aan variabelen allemaal zijn om daarmee te kijken wat het systeem bijhoudt. En met pointers kan je overal bij.
cpp code

TestString.elf:     file format elf32-avr

SYMBOL TABLE:
00800100 l    d  .data	00000000 .data
00000000 l    d  .text	00000000 .text
008001a0 l    d  .bss	00000000 .bss
00000804 l     F .text	00000086 _GLOBAL__sub_I___vector_18
0080024b l     O .bss	00000001 timer0_fract
00000b7e l       .text	00000000 __udivmodsi4_ep
00000b64 l       .text	00000000 __udivmodsi4_loop
0000139a l       .text	00000000 __stop_program
00000096 l       .text	00000000 .do_clear_bss_start
00000094 l       .text	00000000 .do_clear_bss_loop
000000ba  w      .text	00000000 __vector_22
00800250 g     O .bss	00000004 timer0_overflow_count
00000a02 g     F .text	0000002c _ZN5Print7printlnEji
000000ba  w      .text	00000000 __vector_1
00000442 g     F .text	00000024 _Z12freeListSizev
0000090a g     F .text	00000008 _ZN5Print7printlnEv
00000ba0 g       .text	00000008 .hidden __tablejump__
00001362 g       .text	00000036 .hidden __epilogue_restores__
0080024c g     O .bss	00000004 timer0_millis
000004cc g     F .text	0000001c _ZN14HardwareSerial4peekEv
00000936 g     F .text	000000b2 _ZN5Print11printNumberEmh
0000088a g     F .text	00000050 _ZN5Print5writeEPKhj
00000068 g       .text	00000000 __trampolines_start
008001aa g     O .bss	00000002 p2
008001a0 g     O .bss	00000002 p7
0000139c g       .text	00000000 _etext
000004b6 g     F .text	00000016 _ZN14HardwareSerial9availableEv
000000ba  w      .text	00000000 __vector_24
000000be g     F .text	00000002 loop
0000052c g     F .text	00000042 _ZN14HardwareSerial17_tx_udr_empty_irqEv
000000ba  w      .text	00000000 __vector_12
00000a2e  w    F .text	00000002 initVariant
0000126e g     F .text	000000bc __ultoa_invert
000005b2 g     F .text	000000ca _ZN14HardwareSerial5writeEh
000000ba g       .text	00000000 __bad_interrupt
000000ba  w      .text	00000000 __vector_6
00000ba8 g     F .text	00000130 malloc
00800102 g     O .data	00000002 __malloc_heap_start
00000068 g       .text	00000000 __trampolines_end
000000ba  w      .text	00000000 __vector_3
000008da  w    F .text	0000002c _ZN5Print5writeEPKc
000000ba  w      .text	00000000 __vector_23
008001a4 g     O .bss	00000002 p5
000001c8 g     F .text	0000008e _Z12createStringv
0000006a g       .text	00000000 __dtors_end
00800258 g       .bss	00000000 __bss_end
000000ba  w      .text	00000000 __vector_25
00800254 g     O .bss	00000002 __brkval
000011f4 g     F .text	00000016 strnlen
000000ba  w      .text	00000000 __vector_11
0000006a  w      .text	00000000 __init
008001ac g     O .bss	00000002 p1
00000510  w    F .text	0000001c _Z14serialEventRunv
0000056e g     F .text	00000044 _ZN14HardwareSerial5flushEv
000000ba  w      .text	00000000 __vector_13
000000ba  w      .text	00000000 __vector_17
000007a4 g     F .text	0000004c __vector_19
00000912 g     F .text	00000024 _ZN5Print7printlnEPKc
000000ba  w      .text	00000000 __vector_7
008001ae g     O .bss	0000009d Serial
00800181  w    O .data	00000010 _ZTV14HardwareSerial
008001a2 g     O .bss	00000002 p6
0000008c g       .text	00000010 .hidden __do_clear_bss
000011de g     F .text	00000016 strnlen_P
00000466 g     F .text	00000050 freeMemory
000007f0 g     F .text	00000014 _Z17Serial0_availablev
0000067c g     F .text	000000c4 _ZN14HardwareSerial5beginEmh
00800100 g     O .data	00000002 __malloc_heap_end
00000000 g       .text	00000000 __vectors
008001a0 g       .data	00000000 __data_end
00000000  w      .text	00000000 __vector_default
000000ba  w      .text	00000000 __vector_5
00000b9c g       .text	00000004 .hidden __tablejump2__
00000ae2 g     F .text	00000076 init
00000068 g       .text	00000000 __ctors_start
00000076 g       .text	00000016 .hidden __do_copy_data
008001a0 g       .bss	00000000 __bss_start
00000a30 g     F .text	0000001e main
000000ba  w      .text	00000000 __vector_4
00000906 g     F .text	00000004 _ZN5Print5printEPKc
000000ba  w      .text	00000000 __vector_9
000000ba  w      .text	00000000 __vector_2
00000df6 g     F .text	00000044 sprintf
000000ba  w      .text	00000000 __vector_21
000000ba  w      .text	00000000 __vector_15
000009e8 g     F .text	0000001a _ZN5Print5printEmi
0000120a g     F .text	00000064 fputc
00000256 g     F .text	000001ec setup
0000006a g       .text	00000000 __dtors_start
0000006a g       .text	00000000 __ctors_end
008001a8 g     O .bss	00000002 p3
008001a0 g       .data	00000000 _edata
000000ba  w      .text	00000000 __vector_8
00001398  w      .text	00000000 .hidden exit
000004e8 g     F .text	00000028 _ZN14HardwareSerial4readEv
00800256 g     O .bss	00000002 __flp
00000b58 g       .text	00000044 .hidden __udivmodsi4
000000c0 g     F .text	00000108 _Z13printHeapListv
00001398 g       .text	00000000 .hidden _exit
000000ba  w      .text	00000000 __vector_14
000000ba  w      .text	00000000 __vector_10
00000a4e g     F .text	00000094 __vector_16
00800100 g       .data	00000000 __data_start
008001a6 g     O .bss	00000002 p4
00000740 g     F .text	00000064 __vector_18
00800104 g     O .data	00000002 __malloc_margin
000000ba  w      .text	00000000 __vector_20
0000132a g       .text	00000038 .hidden __prologue_saves__
00000e3a g     F .text	000003a4 vfprintf
00000cd8 g     F .text	0000011e free
0000009c g       .text	00000016 .hidden __do_global_ctors


Contents of section .data:
 800100 00005802 80006865 61705f73 74617274  ..X...heap_start
 800110 203d2020 25303458 0a00756e 75736564   =  %04X..unused
 800120 2052414d 203d2020 25303458 0a006c6f   RAM =  %04X..lo
 800130 63617469 6f6e203a 20253034 58206861  cation : %04X ha
 800140 73202564 20627974 65732066 7265650a  s %d bytes free.
 800150 000a2530 34582000 25303258 20002e00  ..%04X .%02X ...
 800160 70747220 706f696e 74732074 6f203d20  ptr points to = 
 800170 00467265 654d656d 6f727920 3d202564  .FreeMemory = %d
 800180 00000000 00d90245 045b0274 026602b7  .......E.[.t.f..
 800190 020d0a00 6e616e00 696e6600 6f766600  ....nan.inf.ovf.