1. 10 12月, 2018 7 次提交
  2. 02 12月, 2018 1 次提交
  3. 20 11月, 2018 1 次提交
    • R
      fix regression in access to optopt object · 39ef612a
      Rich Felker 提交于
      commit b9410061 inadvertently omitted
      optopt from the "dynamic list", causing it to be split into separate
      objects that don't share their value if the main program contains a
      copy relocation for it (for non-PIE executables that access it, and
      some PIE ones, depending on arch and toolchain versions/options).
      39ef612a
  4. 09 11月, 2018 1 次提交
    • R
      optimize two-way strstr and memmem bad character shift · 122d67f8
      Rich Felker 提交于
      first, the condition (mem && k < p) is redundant, because mem being
      nonzero implies the needle is periodic with period exactly p, in which
      case any byte that appears in the needle must appear in the last p
      bytes of the needle, bounding the shift (k) by p.
      
      second, the whole point of replacing the shift k by mem (=l-p) is to
      prevent shifting by less than mem when discarding the memory on shift,
      in which case linear time could not be guaranteed. but as written, the
      check also replaced shifts greater than mem by mem, reducing the
      benefit of the shift. there is no possible benefit to this reduction of
      the shift; since mem is being cleared, the full shift is valid and
      more optimal. so only replace the shift by mem when it would be less
      than mem.
      122d67f8
  5. 03 11月, 2018 6 次提交
    • R
      fix regression in setlocale for LC_ALL with per-category setting · 04e18b61
      Rich Felker 提交于
      commit d88e5dfa inadvertently changed
      the argument pased to __get_locale from part (the current ;-delimited
      component) to name (the full string).
      04e18b61
    • R
      fix failure to flush stderr when fflush(0) is called · 79f653c6
      Rich Felker 提交于
      commit ddc947ed fixed the
      corresponding bug for exit which was introduced when commit
      0b80a7b0 added support for
      caller-provided buffers, making it possible for stderr to be a
      buffered stream.
      79f653c6
    • R
      fix deadlock and buffered data loss race in fclose · 4a086030
      Rich Felker 提交于
      fflush(NULL) and __stdio_exit lock individual FILEs while holding the
      open file list lock to walk the list. since fclose first locked the
      FILE to be closed, then the ofl lock, it could deadlock with these
      functions.
      
      also, because fclose removed the FILE to be closed from the open file
      list before flushing and closing it, a concurrent fclose or exit could
      complete successfully before fclose flushed the FILE it was closing,
      resulting in data loss.
      
      reorder the body of fclose to first flush and close the file, then
      remove it from the open file list only after unlocking it. this
      creates a window where consumers of the open file list can see dead
      FILE objects, but in the absence of undefined behavior on the part of
      the application, such objects will be in an inactive-buffer state and
      processing them will have no side effects.
      
      __unlist_locked_file is also moved so that it's performed only for
      non-permanent files. this change is not necessary, but preserves
      consistency (and thereby provides safety/hardening) in the case where
      an application uses one of the standard streams after closing it while
      holding an explicit lock on it. such usage is of course undefined
      behavior.
      4a086030
    • A
      __libc_start_main: slightly simplify stage2 pointer setup · 00bd3b7d
      Alexander Monakov 提交于
      Use "+r" in the asm instead of implementing a non-transparent copy by
      applying "0" constraint to the source value. Introduce a typedef for
      the function type to avoid spelling it out twice.
      00bd3b7d
    • R
      remove commented-out debug printf from strstr · 0239cd06
      Rich Felker 提交于
      this was leftover from before the initial commit.
      0239cd06
    • R
      fix spuriously slow check in twoway strstr/memmem cores · 8f5a820d
      Rich Felker 提交于
      mem0 && mem && ... is redundant since mem can only be nonzero when
      mem0 is nonzero.
      8f5a820d
  6. 23 10月, 2018 1 次提交
  7. 22 10月, 2018 2 次提交
    • R
      make the default locale (& a variant) failure-free cases for newlocale · 5af1f594
      Rich Felker 提交于
      commit aeeac9ca introduced fail-safe
      invariants that creating a locale_t object for the C locale or C.UTF-8
      locale will always succeed. extend the guarantee to also cover the
      following:
      
      - newlocale(LC_ALL_MASK, "", 0)
      - newlocale(LC_ALL_MASK-LC_CTYPE_MASK, "C", 0)
      
      provided that the LANG/LC_* environment variables have not been
      changed by the program. these usages are idiomatic for getting the
      default locale, and for getting a locale that behaves as the C locale
      except for honoring the default locale's character encoding.
      5af1f594
    • R
      simplify newlocale and allow failure for explicit locale names · 74e70400
      Rich Felker 提交于
      unify the code paths for allocated and non-allocated locale objects,
      always using a tmp object. this is necessary to avoid clobbering the
      base locale object too soon if we allow for the possibility that
      looking up an explicitly requested locale name may fail, and makes the
      code simpler and cleaner anyway.
      
      eliminate the complex and fragile logic for checking whether one of
      the non-allocated locale objects can be used for the result, and
      instead just memcmp against each of them.
      74e70400
  8. 21 10月, 2018 2 次提交
  9. 19 10月, 2018 4 次提交
    • R
      adjust types in FILE struct to make line buffering check less expensive · 8084d6ab
      Rich Felker 提交于
      the choice of signed char for lbf was a theoretically space-saving
      hack that was not helping, and was unwantedly expensive. while
      comparing bytes against a byte-sized member sounds easy, the trick
      here was that the byte to be compared was unsigned while the lbf
      member was signed, making it possible to set lbf negative to disable
      line buffering. however, this imposed a requirement to promote both
      operands, zero-extending one and sign-extending the other, in order to
      compare them.
      
      to fix this, repurpose the waiters count slot (unused since commit
      c21f7507). while we're at it, switch
      mode (orientation) from signed char to int as well. this makes no
      semantic difference (its only possible values are -1, 0, and 1) but it
      might help on archs where byte access is awkward.
      8084d6ab
    • R
      optimize internal putc_unlocked macro used in putc · d8870dcf
      Rich Felker 提交于
      to check whether flush due to line buffering is needed, the int-type
      character argument must be truncated to unsigned char for comparison.
      if the original value is subsequently passed to __overflow, it must be
      preserved, adding to register pressure. since it doesn't matter,
      truncate all uses so the original value is no longer live.
      d8870dcf
    • R
      fix wrong result for putc variants due to operator precedence · a21a6092
      Rich Felker 提交于
      the internal putc_unlocked macro was wrongly returning a meaningless
      boolean result rather than the written character or EOF.
      
      bug was found by reading (very surprising) asm.
      a21a6092
    • R
      further optimize getc/putc when locking is needed · 9dd19122
      Rich Felker 提交于
      check whether the lock is free before loading the calling thread's
      tid. if so, just use a dummy tid value that cannot compare equal to
      any actual thread id (because it's one bit wider). this also avoids
      the need to save the tid and pass it to locking_getc or locking_putc,
      reducing register pressure.
      
      this change might slightly hurt the case where the caller already
      holds the lock, but it does not affect the single-threaded case, and
      may significantly improve the multi-threaded case, especially on archs
      where loading the thread pointer is disproportionately expensive like
      early mips and arm ISA levels. but even on i386 it helps, at least on
      some machines; I measured roughly a 10-15% improvement.
      9dd19122
  10. 18 10月, 2018 8 次提交
    • R
      use prototype for function pointer in static link libc init barrier · 7eda27d0
      Rich Felker 提交于
      this is not needed for correctness, but doesn't hurt, and in some
      cases the compiler may pessimize the call assuming the callee might be
      variadic when it lacks a prototype.
      7eda27d0
    • R
      fix error in constraints for static link libc init barrier · ba0d83e8
      Rich Felker 提交于
      commit 4390383b inadvertently used "r"
      instead of "0" for the input constraint, which only happened to work
      for the configuration I tested it on because it usually makes sense
      for the compiler to choose the same input and output register.
      ba0d83e8
    • R
      fix build regression due to missing file for putc changes · ab5e1e34
      Rich Felker 提交于
      commit d664061a inadvertently omitted
      the new file putc.h.
      ab5e1e34
    • R
      bypass indirection through pointer objects to access stdin/out/err · d8f2efa7
      Rich Felker 提交于
      by ABI, the public stdin/out/err macros use extern pointer objects,
      and this is necessary to avoid copy relocations that would be
      expensive and make the size of the FILE structure part of the ABI.
      however, internally it makes sense to access the underlying FILE
      objects directly. this avoids both an indirection through the GOT to
      find the address of the stdin/out/err pointer objects (which can't be
      computed PC-relative because they may have been moved to the main
      program by copy relocations) and an indirection through the resulting
      pointer object.
      
      in most places this is just a minor optimization, but in the case of
      getchar and putchar (and the unlocked versions thereof), ipa constant
      propagation makes all accesses to members of stdin/out PC-relative or
      GOT-relative, possibly reducing register pressure as well.
      d8f2efa7
    • R
      optimize hot paths of putc with manual shrink-wrapping · d664061a
      Rich Felker 提交于
      this is the analog of commit dd8f02b7,
      but for putc.
      d664061a
    • R
      optimize hot paths of getc with manual shrink-wrapping · dd8f02b7
      Rich Felker 提交于
      with these changes, in a program that has not created any threads
      besides the main thread and that has not called f[try]lockfile, getc
      performs indistinguishably from getc_unlocked. this was measured on
      several i386 and x86_64 models, and should hold on other archs too
      simply by the properties of the code generation.
      
      the case where the caller already holds the lock (via flockfile) is
      improved significantly as well (40-60% reduction in time on machines
      tested) and the case where locking is needed is improved somewhat
      (roughly 10%).
      
      the key technique used here is forcing the non-hot path out-of-line
      and enabling it to be a tail call. a static noinline function
      (conditional on __GNUC__) is used rather than the extern hiddens used
      elsewhere for this purpose, so that the compiler can choose
      non-default calling conventions, making it possible to tail-call to a
      callee that takes more arguments than the caller on archs where
      arguments are passed on the stack or must have space reserved on the
      stack for spilling the. the tid could just be reloaded via the thread
      pointer in locking_getc, but that would be ridiculously expensive on
      some archs where thread pointer load requires a trap or syscall.
      dd8f02b7
    • R
      document and make explicit desired noinline property for __init_libc · 7136836e
      Rich Felker 提交于
      on multiple occasions I've started to flatten/inline the code in
      __init_libc, only to rediscover the reason it was not inlined: GCC
      fails to deallocate its stack (and now, with the changes in commit
      4390383b, fails to produce a tail call
      to the stage 2 function; see PR #87639) before calling main if it was
      inlined.
      
      document this with a comment and use an explicit noinline attribute if
      __GNUC__ is defined so that even with CFLAGS that heavily favor
      inlining it won't get inlined.
      7136836e
    • R
      impose barrier between thread pointer setup and use for static linking · 4390383b
      Rich Felker 提交于
      this is the analog of commit 1c84c999
      for static linking. unlike with dynamic linking, we don't have
      symbolic lookup to use as a barrier. use a dummy (target-agnostic)
      degenerate inline asm fragment instead. this technique has precedent
      in commit 05ac345f where it's used for
      explicit_bzero. if it proves problematic in any way, loading the
      address of the stage 2 function from a pointer object whose address
      leaks to kernelspace during thread pointer init could be used as an
      even stronger barrier.
      4390383b
  11. 17 10月, 2018 5 次提交
  12. 16 10月, 2018 2 次提交