question sdk graph 90+e/ portage CAS

[critor]

@parisse Il vous suffit de partager un build et je testerai l'affichage sur la vraie calculatrice.

[parisse]

critor: il y a un build sur ma page https://www-fourier.ujf-grenoble.fr/~parisse/casio/
Adriweb: je ne suis pas convaincu de l'interet de m'embeter avec des outils que je ne maitrise pas, en tout cas pour le moment...

[parisse]

J'ai fini les modifications necessaires pour compiler giac, j'ai une taille de 4.5Mo pour l'ensemble des fichiers objets (avec l'aide en ligne), pratiquement tout est chargeable en ROM (4 Ko de data et bss).

Code: Select all

sh3eb-elf-size -t *.o
   text      data       bss       dec       hex   filename
4466748       809      3080   4470637    44376d   (TOTALS)

Mais mauvaise nouvelle, ca ne linke pas parce qu'il manque la libsupc++. Le linker rale pour des fonctions manquantes C++ comme dynamic_cast, mais aussi pour les initialisations/destructions de variables statiques (__cxa_atexit, __cxa_guard_acquire/release manquants).

Code: Select all

...
moyal.cc:(.text+0x7108): undefined reference to `___cxa_guard_acquire'
moyal.cc:(.text+0x7154): undefined reference to `___cxa_guard_release'
...
misc.cc:(.text+0x11b8): undefined reference to `___dynamic_cast'
...
/home/parisse/opt/sh3eb-elf/lib/gcc/sh3eb-elf/7.3.0/../../../../sh3eb-elf/lib/libustl.a(uexception.o):(.data.rel.ro._ZTIN4ustl23stream_bounds_exceptionE[_ZTIN4ustl23stream_bounds_exceptionE]+0x0): undefined reference to `vtable for __cxxabiv1::__si_class_type_info'
/home/parisse/opt/sh3eb-elf/lib/gcc/sh3eb-elf/7.3.0/../../../../sh3eb-elf/lib/libustl.a(mistream.o):(.data.rel.ro._ZTIN4ustl8ios_baseE[_ZTIN4ustl8ios_baseE]+0x0): undefined reference to `vtable for __cxxabiv1::__class_type_info'
/home/parisse/opt/sh3eb-elf/lib/gcc/sh3eb-elf/7.3.0/../../../../sh3eb-elf/lib/libustl.a(mistream.o):(.data.rel.ro._ZTIN4ustl7istreamE[_ZTIN4ustl7istreamE]+0x0): undefined reference to `vtable for __cxxabiv1::__vmi_class_type_info'
...


Du coup j'ai reessaie de compiler juste la libsupc++ de gcc en configurant gcc avec --disable-hosted-stdcxx, mais quand on lance make all-target-libstdc++-v3 la configuration plante, il manque trop de headers de la librairie standard C. Si on commente les lignes provoquant les erreurs (en remplacant la commande d'erreur par echo), on arrive a configurer, mais apres la compilation de libsupc++ plante (headers manquants).
Si quelqu'un connait un moyen de compiler une libstdc++ ou libsupc++ ou fournir les fonctions manquantes a l'editeur de liens, je suis preneur! Sinon, je suis bloque et mes aventures avec Casio vont s'arreter la (ca fait une semaine de perdue, enfin pas vraiment perdue, j'ai appris quelques petites choses).

[Adriweb]

Tu peux essayer de stubber des choses, au moins pour voir si ca linke...

Code: Select all

extern "C" int __cxa_thread_atexit(void (*func)(), void *obj, void *dso_symbol) {
  (void)func; (void)obj; (void)dso_symbol;
  // en theorie, code qui appelle les destructors...
}

Puis j'imagine que tout ça est monothreadé, donc... d'après https://github.com/bblanchon/ArduinoJso ... -249209167 : -fno-threadsafe-statics.
(ou sinon, stubbe les trucs avec des fonctions vides)

Et ya probablement beaucoup de flags divers et variés qui pourraient arranger les choses, si ce n'est au moins la taille.

[parisse]

Petit progres en compilant giac avec -fnouse-cxa-at-exit et -fno-rtti. Mais je n'arrive pas a compiler la ustl sans exceptions et sans rtti. On peut bien sur rajouter des fonctions qui ne font rien pour linker, mais ca m'etonnerait que ca soit tres fonctionnel si on remplace _GLOBAL_OFFSET_TABLE_ ou `vtable for __cxxabiv1::__class_type_info', et comme il est impossible de debuguer autrement qu'en envoyant sur l'emulateur, ce qui va prendre probablement plusieurs minutes de transfert, ca va etre infaisable.
C'est quand meme rageant, d'un cote il y a la Numworks qui a un bon compilateur mais pas assez de memoire, de l'autre la Casio qui a (probablement) assez de memoire mais pas un compilateur au niveau (en tout cas public).

[parisse]

Bon, compiler libsupc++ n'est peut-etre pas hors de portee, mais ca risque de prendre du temps vu que la configuration automatique n'a pas marche, il manque plein de liens symboliques.
Sinon, p.s. pour Adriweb: je ne crois pas qu'il soit possible d'ameliorer la taille plus qu'avec -fno-exceptions -Os. On peut juste gagner la taille de l'aide en ligne, et probablement descendre juste en-dessous de 4Mo, si on veut descendre plus il faut enlever des fonctionnalites, mais tout est tres interconnecte.

[Adriweb]

Oui en fait, no-rtti et no-exceptions sont les deux que j'avais en tete. Je ne connaissais pas nouse-cxa-at-exit (mais comment sont geres les appels des destructors en sortie, du coup ?).

Pour la uSTL, il y a une branche git "no-exceptions", ca devrait aider je suppose : https://github.com/szastupov/ustl/tree/no-exceptions

[parisse]

En ajoutant les liens qui me paraissaient pertinents au fur et a mesure des erreurs et quelques definitions de type, j'ai fini par reussir a compiler libsupc++, ouf. J'ai mis dans https://www-fourier.ujf-grenoble.fr/~parisse/casio/ une archive du repertoire de build ainsi qu'une archive des fichiers que j'ai modifies dans le repertoire libsupc++ de gcc 7.3. Je garde le flag -fnouse_cxa_atexit et j'ai defini atexit comme une fonction ne faisant rien.
J'ai egalement mis a jour le source de giac avec un Makefile qui compile les fichiers .o et teste s'il y a des symboles non resolus, mais pour l'instant ca ne donne pas un addin, il n'y a pas d'interface. Il va surement me manquer des choses quand je vais reellement linker, pour le moment il me manque une fonction pour savoir si la touche d'interruption AC/ON est pressee.
Avant il faut que je teste sur des petits exemples si les libs fonctionnent (libtommath, libustl) ainsi que la creation de variables statiques C++. Pour l'instant je garde la ustl avec exceptions (je l'avais modifiee pas mal pour pouvoir compiler...), si ca pose probleme il sera temps d'essayer avec celle indiquee par Adriweb.

[parisse]

Ca va prendre un peu plus de temps que prevu, il y a des bugs et des manques dans l'implementation partielle de la libc de libfxcg. Par exemple, 3 erreurs dans strtol (2 variables qui doivent etre signees et sont declarees unsigned, et str_end est renvoye 1 caractere trop loin)...

[parisse]

Des que j'essaie d'ecrire un petit programme avec la ustl, ca plante. Du coup j'essaie beaucoup plus simple, une classe vecteur maison, et la il y a un truc vraiment bizarre, le programme suivant passe, mais si on enleve les {} autour de l'utilisation de std::vector, ca plante. Apparamment, le destructeur en sortie de portee de {} marche, mais pas en sortie de portee de main().

Code: Select all

// -*- compile-command:"sh3eb-elf-g++ -std=c++98 -nostdlib  -ffreestanding -fno-strict-aliasing -I. -Os -mb -m4a-nofpu -mhitachi -fno-strict-aliasing -c testv.cc -o test.o && sh3eb-elf-g++ -nostdlib -Os -mb -m4a-nofpu -mhitachi test.o -Tprizm.ld  -Wl,-static -Wl,-gc-sections -flto -lsupc++ -lc -lgcc -o test.bin && mkg3a -n basic:Test -n internal:TEST -i uns:unselected.bmp -i sel:selected.bmp test.bin /shared/PrizmSDK-0.3/test.g3a" -*-

#include <fxcg/display.h>
#include <fxcg/keyboard.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#define GIAC_VECTOR
#include <vector.h>
//using namespace ustl;

int main(){
  int i=4321;
  {
    std::vector<int> v(3);
    for (int j=0;j<v.size();++j)
      v[j]=j*j;
    i=v[2];
    v.clear();
  }
  //for (int j=0;j<v.size();++j) v[j]=j*j;
  char buf[]="!!Hello abcdefghijklmnopqrstuvwxyz 123456789";
  //sprint_int(buf,123456);
  double d=123456.78;
  char tmp[]="12g";
  char * ptr;
  int j=strtol(tmp,&ptr,10);
  d=ptr-tmp;
  //sprint_double(buf+2,d);
  sprintf(buf+2,"Co %d %.10f %s",i,d,"XXX");
  Bdisp_EnableColor(0);//Use 3-bit mode
  Bdisp_AllClr_VRAM();
  PrintXY(1,1,buf,TEXT_MODE_TRANSPARENT_BACKGROUND,TEXT_COLOR_BLACK);
  int key;
  for(;;)
    GetKey(&key);
}


Pour etre complet, voila le source de vector.h

Code: Select all

#ifndef GIAC_VECTOR_H
#define GIAC_VECTOR_H
// Simple vector implementation for giac
// Incomplete (allocation is handled by new/delete)
// compatible with alias_ref_vecteur and without all VISUALC++ checks
#include <string.h>

namespace std {
  template<typename _Tp> class vector{
    // private members
    _Tp * _begin,*_end,*_endalloc;
    // private allocation methods
    void _realloc(unsigned n){
      if (_endalloc-_begin>=int(n))
   return;
      unsigned old=unsigned(_end-_begin);
      _Tp * _newbegin = new _Tp[n];
      for (_Tp * ptr=_begin;ptr!=_end;++ptr,++_newbegin){
   *_newbegin = *ptr;
      }
      _newbegin -= old;
      if (_begin)
   delete [] _begin;
      _begin=_newbegin;
      _end=_begin+old;
      _endalloc=_begin+n;
    }
    void _alloc(unsigned n){
      _end=_begin = new _Tp[n];
      _endalloc=_begin+n;
    }
    void _alloc_fill(const _Tp * b,const _Tp * e){
      unsigned n=unsigned(e-b);
      _alloc(n);
      for (_Tp * ptr=_begin;ptr!=_endalloc;++ptr,++b){
   *ptr = *b;
      }
      _end = _begin+ n;
    }
  public:
    typedef _Tp value_type;
    typedef _Tp * pointer;
    typedef const _Tp * const_iterator;
    typedef pointer iterator;
    typedef giac_reverse_pointer<_Tp> reverse_iterator;
    typedef giac_reverse_pointer<const _Tp> const_reverse_iterator;
   
  vector():_begin(0),_end(0),_endalloc(0) {}
    ~vector() { if (_begin) delete [] _begin; }
    vector(size_t n_,const _Tp & value=_Tp()){
      unsigned n=unsigned(n_);
      _alloc(n);
      for (;_end!=_endalloc;++_end){
   *_end =value;
      }
    }
    vector(const const_iterator & b,const const_iterator & e){
      _alloc_fill(b,e);
    }
    vector(const vector<_Tp> & w){
      _alloc_fill(w._begin,w._end);
    }
    vector<_Tp> & operator = (const vector<_Tp> & w){
      if (this==&w)
   return *this;
      unsigned n=unsigned(w._end-w._begin);
      _realloc(n);
      _end=_begin;
      for (_Tp * ptr=w._begin;ptr!=w._end;++_end,++ptr){
   *_end = *ptr;
      }
      return *this;
    }
    iterator begin(){ return _begin; }
    iterator end(){ return _end;}
    const_iterator begin() const { return _begin; }
    const_iterator end() const { return _end;}
    reverse_iterator rbegin(){ return _end-1; }
    reverse_iterator rend(){ return _begin-1;}
    const_reverse_iterator rbegin() const { return _end-1; }
    const_reverse_iterator rend() const { return _begin-1;}
    size_t size() const { return _end-_begin; }
    size_t capacity() const { return _endalloc-_begin;}
    _Tp & front() { return *_begin; }
    _Tp & back() { return *(_end-1); }
    _Tp & operator [](size_t i) { return *(_begin+i); }
    const _Tp & front() const { return *_begin; }
    const _Tp & back() const { return *(_end-1); }
    const _Tp & operator [](size_t i) const { return *(_begin+i); }
    void push_back(const _Tp & p){
      if (_endalloc==_end){
   unsigned n = unsigned(_end-_begin);
   _realloc(n?2*n:2);
      }
      *_end=p;
      ++_end;
    }
    _Tp pop_back(){ --_end; return *_end; }
    void clear(){ _end=_begin;}
    bool empty() const { return _end==_begin; }
    void reserve(size_t n){ if (_endalloc-_begin<int(n)) _realloc(int(n)); }
    void resize(size_t n_,const _Tp &value=_Tp()){
      int n=int(n_);
      if (_end-_begin>=n) _end=_begin+n;
      else {
   _realloc(n);
   for (;_end!=_endalloc;++_end){
     *_end=value;
   }
      }
    }
    void erase(_Tp * b,_Tp * e){
      unsigned decal=unsigned(e-b);
      if (!decal)
   return;
      for (_Tp * ptr=e;ptr!=_end;++ptr){
   *(ptr-decal)=*ptr;
      }
      _end -= decal;
    }
    void erase(_Tp * b){
      erase(b,b+1);
    }
    _Tp * insert(_Tp * b, const _Tp& x ){
      if (_endalloc==_end){
   unsigned pos=unsigned(b-_begin);
   unsigned n = unsigned(_end-_begin);
   _realloc(n?2*n:2);
   b=_begin+pos;
      }
      ++_end;
      for (_Tp * ptr=_end-1;ptr!=b;--ptr){
   *ptr=*(ptr-1);
      }
      *b=x;
      return b;
    }
    void insert(_Tp * b, unsigned k,const _Tp& x ){
      if (_endalloc<_end+k){
   unsigned pos=unsigned(b-_begin);
   unsigned n = unsigned(_end-_begin);
   _realloc(n>k?2*n:n+k);
   b=_begin+pos;
      }
      _end += k ;
      for (_Tp * ptr=_end-k;ptr!=b;){
   --ptr;
   *(ptr+k)=*ptr;
      }
      for (unsigned j=0;j<k;++b,++j){
   *b=x;
      }
    }
    void swap(vector<_Tp> & w){
      _Tp * tmp=_begin; _begin=w._begin; w._begin=tmp;
      tmp=_end; _end=w._end; w._end=tmp;
      tmp=_endalloc; _endalloc=w._endalloc; w._endalloc=tmp;
    }
    void assign(size_t n_,const _Tp & value=_Tp()){
      unsigned n=unsigned(n_);
      _realloc(n);
      _end = _begin +n;
      for (_Tp * ptr=_begin;ptr!=_end;++ptr){
   *ptr=value;
      }
    }
    void assign(const _Tp * b,const _Tp * e){
      unsigned n=unsigned(e-b);
      _realloc(n);
      _end = _begin +n;
   for (_Tp * ptr=_begin;b!=e;++b,++ptr){
   *ptr=*b;
      }
    }
    unsigned max_size() const {
      return 1 << 30;
    }
    _Tp & at(size_t n){
      if (n>_end-_begin)
   return _Tp(); // should be defined somewhere else
      return *(_begin+n);
    }
    const _Tp at(size_t n) const {
      if (n>_end-_begin)
   return _Tp(); // should be defined somewhere else
      return *(_begin+n);
    }
  };

  template<typename _Tp>
    inline bool operator==(const vector<_Tp>& __x, const vector<_Tp>& __y){
    if (__x.size() != __y.size())
      return false;
    for (const _Tp * xptr=__x.begin(), * yptr=__y.begin();xptr!=__x.end();++yptr,++xptr){
      if (*xptr!=*yptr)
   return false;
    }
    return true;
  }

  // template<typename _Tp> inline bool operator!=(const vector<_Tp>& __x, const vector<_Tp>& __y){ return !(__x==__y); }

  template<typename _Tp>
    inline bool operator < (const vector<_Tp>& __x, const vector<_Tp>& __y){
    if (__x.size() != __y.size())
      return __x.size()<__y.size();
    for (const _Tp * xptr=__x.begin(), * yptr=__y.begin();xptr!=__x.end();++yptr,++xptr){
      if (*xptr!=*yptr)
   return *xptr<*yptr;
    }
    return false;
  }

  template<typename _Tp>
    inline bool operator > (const _Tp & __x, const _Tp & __y){
    return __y<__x;
  }

  template<typename _Tp>
    inline bool operator >= (const _Tp & __x, const _Tp & __y){
    return !(__x<__y);
  }

  template<typename _Tp>
    inline bool operator <= (const _Tp & __x, const _Tp & __y){
    return !(__y<__x);
  }

}

#endif // GIAC_VECTOR_H