demande de quelques détails sur l'exécution de code dans une TI - Page 1

Hello les gens,

je démarre un projet qui sera intéressant si il marche ()

Pour le moment je dois résoudre un pb technique:
Mon code aura besoin d'assez de RAM pour les données, donc je voudrais économiser au max l'espace de code. je voudrais que le max de code soit archivé.

mais comme le bidule sera modulaire, je vais écrire des modules de code séparés, comme des plugins.
je voudrais que leur code soit archivé; mais:

-si j'archive une variable OTH contenant le code je pourrai plus modifier de variable locale si la var est archivée;
-si je passe par des DLLs, on peut en charger une seule à la fois et apparemment elle sont chargées en ram (po cool)

reste les libs kernel

STOP PAS DE TROLL je m'en fous.

je voudrais savoir si les libs standards qui existent depuis doors sont désarchivées avant d'être exécutées, et si elles utilisent automatiquement un segment BSS (qui est en ram, lui? ) pour stocker leurs variables.

merci

l'exécution de code en archive est un peu délicate sur certains HW, donc oui le kernel désarchive avant d'exécuter... Pour ce qui est des BSS, c'est comme le segment de données : dans les deux cas ça finit en RAM, la seule différence c'est que les BSS économisent un peu d'archive puisqu'ils ne sont pas initialisés ^^

pour exécuter vraiment du code en archive, pour l'instant la seule solution "clé en mains" reste les flashapps (ou aussi patcher pedrom si tu fais du GPL)

ah
et ça marche sur quel hw?

je fais du gpl, pedrom sait faire ça aussi?

pedRom est sous GPL, me semble bien

je parle d'exécution de variables archivées

squalyl^2 :
je parle d'exécution de variables archivées

PedroM désactive normalement toutes les protections, mais à vérifier.

J'avais fait une doc qui expliquait toutes les techniques de contournement de la protection d'exécution, s'agit de la retrouver...

Voilà voilà : http://membres.lycos.fr/extended/FlashROM_exec_protection.txt (utiliser Opera ou FireFox pour éviter la vérif du referer par Lycos).
Il manque la Titanium qui existait pas à l'époque, mais la je suis crevé et pas envie de réfléchir, même 2 secondes

le ghost space de l'archive sur 92+ hw2 je connaissais pas

les méthodes pour 89 et V200 ne sont pas vraiment utilisables en pratique
(par expérience)

et les libs kernel à exécuter en archive, c'est la galère

bon changé de design ce sera du code statique
(ce sera le plus compact finalement)

merci pour les infos

Tu peux pas charger juste ce dont tu as besoin quand tu en as besoin ?

tiens ben je viens de tester le modèle de truc que j'utiliserai

#include <stdio.h>

int function(int a, int b) {
 return a+b;
}

typedef struct machin {
  struct machin *next;
  int (*fptr)(int,int);
} machin;

int called(struct machin *bidule) {
  int a;
  a=bidule->fptr(2,4);
  printf("2+4=%d\n",a);
}

int main(void) {
  struct machin truc= {
    .next=NULL,
    .fptr=&function
  };
  called(&truc);
}

avec des trucs comme ça je m'en sortirai, et tout sera lié en statique:

et HeapAllocHigh() ça va m'aider aussi

Je viens de réfléchir qu'en fait, la mémoire sera pas si critique que ça, en revoyant mes objectifs à la baisse ce sera aussi bien ce qui va gêner c'est plutot les 12 MHz du CPU (et le fait que j'ai pas de gray link )

gestion d'une pile ? u--d------p|t-c---p-/-i---p-

MAIS CHUTEUH!
(en même temps ct po trop caché)

j'espère m'en sortir. c'est bien parti. le but principal c'est éducatif pour moi pour voir comment on code ça. non je porterai pas la pile de nunux, elle est trop grosse.
pour le moment je me débats avec le port I/O

ya un truc qui s'apelle tiny_ _ qui semble etre petit et bien marcher

godzil :
gestion d'une pile ?

tu parles de mieux gérer la batterie ?

tout a fait

godzil :
ya un truc qui s'apelle tiny_ _ qui semble etre petit et bien marcher

y'en a d'autres: lwmachin, utruc, etc...
je veux apprendre à coder le truc by mayself
ça me montre
-les réseaux en détail coté théorique et coté linux
-la programmation du kernel linux (d'ailleurs y font chier avec la guéguerre udev/devfs, du coup y'a plus rien qui marche, le plus simple c'est de faire les noeuds à la main on dirait )
-libticables
-le DBUS en détail (y'aura des articles tiwiki à la clé)

si ça marche réellement comme je veux, tant mieux (sinon j'aurais appris plein de trucs)

hem j'y reviens

(j'ai besoin de spécialistes)

je laisse tomber l'exécution en flash.

mais là je démarre un sous-projet: le chargement dynamique.
je parle pas de libs kernel qui sont toutes chargées au démarrage de l'appli.

je parle pas de DLLs nostub à la tigcc qui permettent d'en charger une seule à la fois (ie limite de 64k -> limite de 128kb, ça revient au même)

je parle d'implémenter dlfcn.h

void * dlopen (const char * filename, int flag);
const char * dlerror(void);
void * dlsym (void * handle, char * symbol);
int dlclose (void * handle);

---

pour le moment je me débats avec ce code:

#define LIBSO_MAGIC	0xCCAABBEE

int foo(int,int);
int bar(int);

void* _calls[]={
	(void*)LIBSO_MAGIC,
	&foo,
	&bar,
	0
};

int foo(int a, int b)
{
	return a+b;
}

int bar(int a)
{
	return 2*a;
}

je le compile avec

tigcc -standalone -outputbin --all-relocs -c shobjtest.c -o test

Je m'étais dit c'est cool, comme ma table est le premier truc compilé, elle apparaitra a l'offset 0 si je compile le fichier en binaire. D'autant plus que le fichier asm généré est:

        .file   "shobjtest.c"
#NO_APP
        .text
tigcc_compiled.:
        .globl  _calls
        .text
        .even
_calls:
        .long   -861226002
        .long   foo
        .long   bar
        .long   0
        .text
        .even
        .globl  foo
foo:
        link.w %fp,#0
        move.w 8(%fp),%d0
        add.w 10(%fp),%d0
        unlk %fp
        rts
        .even
        .globl  bar
bar:
        link.w %fp,#0
        move.w 8(%fp),%d0
        add.w %d0,%d0
        unlk %fp
        rts

j'étais confiant, la table est le premier code généré.

mais hexdump -C test me donne:

[squalyl@server test]$ hexdump -C test
00000000  01 50 00 03 43 76 0d 90  00 00 00 ce 00 00 00 0d  |.P..Cv..........|
00000010  00 00 02 04 2e 74 65 78  74 00 00 00 00 00 00 00  |.....text.......|
00000020  00 00 00 00 00 00 00 2e  00 00 00 8c 00 00 00 ba  |................|
00000030  00 00 00 00 00 02 00 00  00 00 00 20 2e 64 61 74  |........... .dat|
00000040  61 00 00 00 00 00 00 2e  00 00 00 2e 00 00 00 00  |a...............|
00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000060  00 00 00 40 2e 62 73 73  00 00 00 00 00 00 00 2e  |...@.bss........|
00000070  00 00 00 2e 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000080  00 00 00 00 00 00 00 00  00 00 00 82 cc aa bb ee  |................|
00000090  00 00 00 10 00 00 00 20  00 00 00 00 4e 56 00 00  |....... ....NV..|
000000a0  30 2e 00 08 d0 6e 00 0a  4e 5e 4e 75 4e 56 00 00  |0....n..N^NuNV..|
000000b0  30 2e 00 08 d0 40 4e 5e  4e 75 00 00 00 04 00 00  |0....@N^Nu......|
000000c0  00 0b 80 11 00 00 00 08  00 00 00 0c 80 11 2e 66  |...............f|
000000d0  69 6c 65 00 00 00 00 00  00 00 ff fe 00 00 67 01  |ile...........g.|
000000e0  73 68 6f 62 6a 74 65 73  74 2e 63 00 00 00 00 00  |shobjtest.c.....|
000000f0  00 00 00 00 00 00 00 00  00 04 00 00 00 00 00 01  |................|
00000100  00 00 06 00 2e 74 65 78  74 00 00 00 00 00 00 00  |.....text.......|
00000110  00 01 00 00 03 01 00 00  00 2e 00 02 00 00 00 00  |................|
00000120  00 00 00 00 00 00 00 00  2e 64 61 74 61 00 00 00  |.........data...|
00000130  00 00 00 2e 00 02 00 00  03 01 00 00 00 00 00 00  |................|
00000140  00 00 00 00 00 00 00 00  00 00 00 00 2e 62 73 73  |.............bss|
00000150  00 00 00 00 00 00 00 2e  00 03 00 00 03 01 00 00  |................|
00000160  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000170  00 00 00 00 00 00 00 14  00 00 00 00 00 01 00 00  |................|
00000180  02 00 5f 63 61 6c 6c 73  00 00 00 00 00 00 00 01  |.._calls........|
00000190  00 00 02 00 66 6f 6f 00  00 00 00 00 00 00 00 10  |....foo.........|
000001a0  00 01 00 00 02 00 62 61  72 00 00 00 00 00 00 00  |......bar.......|
000001b0  00 20 00 01 00 00 02 00  00 00 00 24 74 69 67 63  |. .........$tigc|
000001c0  63 5f 63 6f 6d 70 69 6c  65 64 2e 00 5f 5f 6c 64  |c_compiled..__ld|
000001d0  5f 61 6c 6c 5f 72 65 6c  6f 63 73 00              |_all_relocs.|
000001dc

deux trucs

déja y'a des sections avant, mais je peux dire que c'est pas grave si je cherche l'offset de LIBSO_MAGIC_TAG dans le fichier binaire.

mais je vois que les offsets des fonctions dans ma table sont bien des offsets, ie on voit que foo=0x10 et bar=0x20. bon c'est gérable d'ajouter l'offset du début de ma table.

ce qui me laisse penser à un vieux problème de relocations.

mon but est de faire un malloc() et d'y copier ce code, puis d'utiliser la table _calls pour appeler les fonctions chargées.

mais est ce que le code s'exécutera? ie, est ce que c'est du code -fPIC? est ce qu'il risque de contenir des références absolues, ou est ce que tout dépend de la position de PC?

merci de répondre à mes questions, ça m'aiderait largement et ouvrirait la porte à des projets sympas, dont la suite du mien

Tu veux reimplanter kernel::LibsBegin, LibsCall, LibsEnd quoi ?

heu je voyais un truc qui se passe éventuellement de kernel.

kernel::Libs* ça peut s'appeler pendant le déroulement d'un programme?

Ben oui. cf doc.
Au passage, -fPIC n'est pas vraiment utilisable sur ti.

ben c'est la première fois que je me penche sur la programmation système dans une TI

et puis..

#ifdef USE_KERNEL
#define dlopen Lbsbegin
#define truc machin
#else
#error DTC
#endif

?

Sinon dans le tien si tu préféres. Parce que c'est tres loin d'etre gagné ton affaire.

tu m'étonnes

bon.

j'ai trouvé les sources de la µClibc, spa gagné c'est clûr.

donc
-ma pile sera liée en statique
-après je m'intéresserai de près au dynamique

je dois vraiment trouver de la doc sur les fonctions dont tu m'as parlé, elles sont utilisables pendant l'exécution d'un programme déja chargé? elles sont utilisables en C? (etc)

Cf RamCalls.txt dans le pack SDK de PreOs.

suis je bête.
j'ai posé une question technique
/mo go rtfm

>je dois vraiment trouver de la doc sur les fonctions dont tu m'as parlé, elles sont utilisables pendant l'exécution d'un programme déja chargé? elles sont utilisables en C? (etc)
Oui.
Oui.

cool alors