This project is mirrored from https://repo.or.cz/tinycc.git. Pull mirroring updated .
  1. 06 Jul, 2021 1 commit
  2. 04 Jul, 2021 2 commits
  3. 02 Jul, 2021 1 commit
  4. 01 Jul, 2021 3 commits
  5. 28 Jun, 2021 1 commit
  6. 22 Jun, 2021 1 commit
  7. 04 May, 2021 1 commit
  8. 27 Apr, 2021 2 commits
  9. 24 Apr, 2021 11 commits
  10. 14 Apr, 2021 2 commits
  11. 13 Apr, 2021 2 commits
  12. 09 Apr, 2021 2 commits
    • Christian Jullien's avatar
      035ae7d7
    • grischka's avatar
      stdatomics: tidy & cleanup · 48df89e1
      grischka authored
      - remove any error messages that were just for debugging the
        templates really
      - don't use c99 in tcc (array designators etc.)
      - remove memory model type (cannot be an own type really)
        and move memory model defines from built-in to stdatomics.h
      - apply normal casts to non-pointer atomic_function arguments
      - tidy the library support
      - add some tests for errors/warnings
      
      Also:
      - Makefile: move GIT_HASH stuff from CFLAGS to DEFINES and into
        main section (away from what is included by tests for example)
      - tccelf.c/tccgen.c: avoid some warnings with newer GCC
      48df89e1
  13. 06 Apr, 2021 1 commit
  14. 02 Apr, 2021 2 commits
  15. 01 Apr, 2021 2 commits
  16. 26 Mar, 2021 1 commit
    • Dmitry Selyutin's avatar
      stdatomic: ld/st/xchg/cmpxchg on simple types · 47da8e45
      Dmitry Selyutin authored
      Some complex types can still be small and simple enough to fit into
      register. Other compilers allow some operations on these types, and it
      seems to be quite a reasonable choice. From now on, we should be able
      to compile the following artificial example:
      
          struct combo {
              uint16_t lo;
              uint16_t hi;
          };
      
          struct combo load(const _Atomic(struct combo) *atom)
          {
              return atomic_load(atom);
          }
      
          void store(_Atomic(struct combo) *atom, struct combo value)
          {
              atomic_store(atom, value);
          }
      
          struct combo xchg(_Atomic(struct combo) *atom, struct combo value)
          {
              return atomic_exchange(atom, value);
          }
      
          bool cmpxchg(_Atomic(struct combo) *atom,
                  struct combo *cmp, struct combo xchg)
          {
              return atomic_compare_exchange_strong(atom, cmp, xchg);
          }
      
      This might be useful for some corner cases, though it is quite likely
      that many programmers will prefer operating on a single 32-bit value
      instead of using the structure consisting of 16-bit pair.
      
      Things will work as long as the overall structure size happens to be
      the same as for any integer type we support in atomics.
      47da8e45
  17. 19 Mar, 2021 1 commit
  18. 17 Mar, 2021 2 commits
  19. 09 Mar, 2021 1 commit
  20. 21 Feb, 2021 1 commit