Rune - Clean up strings

* Remove 'char' type, require 'uchar' or 'schar' to remove confusion.
  Note that 'size_t' is still signed in Rune and for now will remain so.

* Add string_p and string_rw_p.  We make 'string_p' basically
  'const uchar *' ... i.e. read-only string pointers.  This will let
  me create a string class for string functions, but I will have to
  add the ability to subclass pointers (not yet in).

Rune - Fix DupExp() bug (2)

* This blew up double-quoted strings due to the ex_Id replacement.
  Fix this a better way, set EXF_PARSE_TYPE to cause DupExp() to
  also duplicate the type.

Rune - Fix DupExp() bug

* When an Exp is duplicated we must clear EX2F_ESCDONE in order
  to ensure that the ex_Type gets properly re-resolved.

Rune - Fix broken comment

* Fix a broken comment from a recent commit.

Rune - Clean up some tests

* Clean up some of the tests/* functions.

Rune - Clean up mmap() and friends

* Clean up mmap(), madvise(), msync().  These functions are
  generic Sys.* functions.

* Give the FdMap class its own versions for the above functions
  for consistency.

* Fix a bug in the mmap() system call code.

Rune - Add __vartype[n] and __type[n]

* Add __vartype[n] and __type[n] to simplify typeof(__vardata[n])
  constructs.

Rune - Add multi-character single-quoted constants

* Supports multi-character single-quoted constants.  Constants
  between 1 and 4 characters are directly encoded by shifting
  each character into the LSB.  The type depends on the length:

  length 0 or 1 uint8_t
  length 2 uint16_t
  length 3 or 4 uint32_t

* Character constants that are 5 characters or longer will be hashed with
  the ISCSI crc32 algorithm, bit 31 of the result is set, and the result
  is returned as an unsigned 32-bit integer.

Rune - Adjust for gcc-8 warnings

* Make adjustments to clean up gcc-8 warnings.

Rune - Fix more 64-bit immediates

* Fix 64-bit immediate move operations that need to
  use movabsq, i.e. where the immediate value exceeds
  a signed-32-bit range.

* sizeof() was improperly being stored in the string
  table as an 32-bit integer when it's 64-bits.  Fix
  by properly passing in a 64-bit value.

* Not completely generic yet but we handle more cases

Rune - Inherit scope for refinement, minor fixes

* Update docs.

Rune - Inherit scope for refinement, minor fixes

* Refining declarations inherit scope from the superclass
  if it is not specified in the refinement.

* Add missing type combinations for ARRAY_ELEMENT_AG().

* Always create sufficient pthreads so cpu-bound rune threads
  do not prevent new (or other) rune threads from running.

Rune - re-enable bypass optimizations

* Re-enable the BYPASS_SKIP optimization and refine the algorithm.
  Previously this bypass optimization could cause one-time-use temporary
  registers to be reserved indefinitely for code inside a conditional
  block, causing RAS to run out of registers.  The refinement should
  fix that problem.

  The refinement involves converting WRITEs to READ|WRITE (read-modify-
  write) in a bypass situation as before, but ONLY if the variable
  does not represent RAF_LIFE_BEG, plus a previous match is present
  (which tends to go hand-in-hand).  Meaning that variables whos
  life-time begins with the WRITE can remain WRITE and not be
  converted to READ|WRITE despite the bypass.

* The same bug also affected BYPASS_ALL and should also now be fixed
  (and even give us not-so-terrible register optimizations).

* Now that this implemented, RAS generates significantly better
  registerization, and the complexity of the brute-force algorithm
  is significantly reduced.

* WARNING!  This is a dangerous change, so if assembly output
  starts to break register use it might be due to this commit.

Rune - Change regsave burden for syscalls

* RuneRunTime_*() already uses ms_abi, also make our system call
  ABI use ms_abi.  This greatly reduces register save/restore actions
  at higher levels in rune-generated code.

* The above also ensures that a good chunk of the FP registers
  become callee-saved, verses none.

* Fix a bug in the run-time where RunGetDeclarationData() did not
  have visibility into (exp->ex_Flags & EXF_ADDRUSED), preventing
  data->mrs from being set in certain call situations involving
  lvalues.

* Rename the *_STD register ABI masks to *_SYS since they are only
  used for system calls.

Ras - Adjust complexity calculation

* Adjust complexity calculation

Rune - Fix runtime random to actually return a 64-bits

* Fix the runtime random to return 64-bits

Rune - Adjust operator precedences

* Adjust precedences to be more compatible with C.

* Closures and structural access are given a
  precedence of 90, the highest (most tightly bound)
  precedence.

* All unary operators have a precedence of 85.

* By default precedence is 80.  This includes multiply,
  divide, and modulo.

* Consider any operator containing a '+' or '-' to
  be like an add or subtract (prec 60)

* Consider any operator beginning with '<<' or '>>' to be
  a shift operator (prec 50).

* Consider any operator containing '<' '=' or '>'
  that isn't a shift operator to be a compare operator
  (prec 40).

* Consider any operator ending with '=' that is
  not a compare operator to be an assignment operator
  (prec 20).

Rune - Add BCHECK and RuneMode

* Add a BCHECK (bounds-check) instruction which allows RAS to
  generate an appropriate cmp/branch/bounds-trap sequence which
  does not require a large regused mask.

* This also removes an explicit branch in the intermediate RAS
  output which significantly reduces block characterization times.

* Implement a RuneMode global which allows Rune to detect
  what mode its in (e.g. compiling, interpreting, running a
  binary, etc).

* Disable the creation or mapping of persistent store when compiling.

* Optimize newly created persistent stores by avoiding the bzero()
  if the file did not previously exist or was 0-length.

Ras - Fix EA2 assertion

* If a double-extension is allowed and ext2 is not specified,
  set ext2 to ext1.

Rune - PCheck, 64-bit cmpq fixes

* PCheck ignores bounds if in_RefStor is NULL (indicating a degenerate
  type.ty_Info structure).

* cmpq $imm64,dea loads the immediate value into a register if
  it cannot be represented as a signed 32-bit integer.

Rune - Change default locking

* Most local variable, procedure arguments, and return values are
  now untracked by default.

* Remove 'N' version of opcodes, e.g. PATOMN, IATOMN

Rune - Fix content initialization gen for persist store

* Fix an assertion in the content initialization code for
  persistent global objects.

Rune - Refactor mmap, madvise, msync, and enhance "project"

* Enhance the "project" directive to allow an absolute path to be
  specified.  This will override normal HOME and USER based pathing
  for shared objects.  However, if the RUNEDATA env exists, an absolute
  project path will be tacked onto it.

* Move mmap(), madvise(), and msync() out of the FdMap class and
  into the Pointer class.  This allows these functions to be used
  on persist objects.

Rune - doc update

* Improve description of persistent storage, add reference to msync()

Rune - Add random support system calls

* Add srandomdev(), srandom(n), and random()

Rune - Fix &ary[i][j] typing.

* The EXF_REQADDROF flag should not be recursively passed into
  sub-expressions for lhs resolution, this will cause the intermediate
  &array[i][j] to type as PtrTo-array[i] instead of array[i], resulting
  in the address of a pointer to the entire subarray instead of an address
  of the subarray element.

Rune - Remove RSRESERVE for persistent objects (2)

* Remove more RSRESERVE.

Rune - Remove RSRESERVE for persistent objects

* Remove header space.  Persistent objects are now directly mmap()'d.

Rune Serialize - Stabilization, Generation, major overhaul

* Interpreter and compiler work on tests/gfxinput2.d again,
  though at the moment most of the threaded test programs are
  unsafe due to changes in defaults (e.g. gfx framework topology).

* The cursorThread() and eventThread() method objects needs to be
  soft-locked to avoid interference.

* Remove 'hard' qualifier on various method procedures, as this is
  now the default for method objects.

* Document the 'untracked', 'unlocked', 'soft', and 'hard' scope
  qualifiers.  Implement all four qualifiers generically in the
  code and make it so they override each other.  Allow all four
  qualifiers to be used in method procedure declarations.

* Rely on Declaration->d_Storage more, remove sanity checks that
  tested d_Storage against SCOPE.

* We no longer assign default SCOPE and SF bits, which caused
  confusion with lock+refd overrides.  Also setup #define's
  for default values.

* Change various default locking modes.  Most default locking
  modes (e.g. arguments, return values, local variables) are
  now REFD.

* Refactor PATOM and PATOMN.  PATOM no longer steals a ref
  from the original info as this can cause it to implode.
  PATOMN (for now) generates an info with no refs and the
  caller is responsible for issuing an appropriate ref.
  Also add INEWN.

* Refactor the implied lock code a bit just to reduce edge
  cases.

* Refactor ptr.new() handling.  The runtime new() function now
  detects the pointer's target locking mode by observing the
  SQFlags in the LValueStor's type.  Also ensure that the SQFlags
  are properly set in FinishDecl().

* GenPointerAddrInfo() no longer needs a GenFixupContent() call
  afterwords.  Also simplify GenPointerLVInfo() (reverse its
  arguments so they are more natural), and GenFixupLVContent().

* Remove GENSTAT_NONE special cases.  Treat all GENSTAT_* lock+refd
  modes orthogonally.

Rune Serialize - Stabilization, Fix boolean casts and unary operator(s)

* Stabilize the interpreter, don't mistreat data->istmp, don't mistreat
  data->storage to fake-out data->istmp operation.

* Allow the resolver to handle scope inheritance.

* Fix default locking modes for intent.

* Get rid of sanity checks against d->d_Storage (allow the resolver to
  have final say on d_Storage mechanics).

* Fix Run64 execution for Floating -> Bool casts.  The floating exp
  was being executed as a Run64 function when it is not compatible with
  int64_t.

* Fix Run64 execution for !exp.  This unary operator returns a boolean,
  so properly return a boolean.  In addition, the rhs might not be
  Run64 compatible so execute normally if the rhs is Floating.

* Fixes tests/float.d output for ! tests.

Rune Serialize - Simplify GenData and RunData

* Remove minfoimplied, crs, and cinfo.  Keep the sideband mrs and minfo
  as these cannot be obtained from the object.  mrs/minfo is implied
  if NULL.  These will be mandatory in situations where they are needed.

  We are getting rid of the side-band 'content' storage, crs and cinfo.
  It is duplicative of the content and just creates confusion.

* We will keep the 'storage' specification and the GENSTAT_* operation.
  However, we will reclassify the default storage modes for many things.

  - Procedure args, return values, local variables, and temporaries
    will now be GENSTAT_NONE by default, unless used as an lvalue or the
    address is taken.  In such cases they will be GENSTAT_REFD to
    maintain compatibility with dynamic and static storage, method
    APIs, etc.  This fixes issues with **ptr's and such.

  - Method procedures will be special-cased.  Method objects are
    serialized by default (the lvalue will be GENSTAT_LOCKH).  If
    scoped 'unserialized', we will use GENSTAT_NONE.  Note that
    the underlying object, if declared on a stack somewhere, will
    still be GENSTAT_REFD.

  - Operators are not method calls and their arguments will be
    GENSTAT_NONE by default.

  - Dynamic and static storage remain GENSTAT_REFD.

  - Temporary storage will be GENSTAT_NONE, meaning that additional
    refs are not maintained on expression evaluation temporaries.

  These changes will significantly improve run-time performance, fix
  operational issues

* Please keep in mind that 'storage' specifications are only applicable
  to references, pointers, lvalues (specifically, the s_Info
  structure), and compound types (it only recurses through compound
  types).  The storage mode for e.g. elements of a class is determined
  by the declarations making up the class.

* We will at least temporarily remove pointer ranges (in_Beg and
  in_End) in order to remove dynamic PointerInfo allocations.
  We will stick with using RefStor-embedded info's and
  type->ty_Info.

* Adjust docs for intent.

Rune - Require minfo in more places

* Allow an expression topology to require minfo for locking
  purposes.

* Fixes global locking that was previously missing, among other
  things.

Rune - Major locking work

* Implement class and procedure 'hard' locking mechanics.

* Refactor SyscallLookup() to return the resolved locking method
  that matches the procedure call declaration's expectations.

  Implement 'new' for unlocked, locked, and now also hard locked.

* Get rid of EXF_UNLOCKEDMTH (since we have to deal with more than
  just normal and unlocked now).  Instead we test the declaration.

* GenAssExp() and other dcopy consumers (for the moment) now make a
  discrete copy, disabling the direct-copy feature, for objects
  that are or contain lvalues, pointers, or references.

  This helps deal with problems with blocking locks causing an
  assignment to lose its lock half way through, and also helps deal
  with self-assignment like 'x = x' which try to release the target
  (lhs) before copying the rhs, and thus also lose the rhs.

* GenPointerLVInfo() and GenPointerAddrInfo() now save the resolved
  info to the sideband ptr->minfo in the target, allowing the code
  to track that a ref on info has already been obtained.

* pointerIndHelper() now always returns sideband minfo in order
  to help deal with callers that need it (i.e. method procedure
  calls passing LValue's).  Previously these consumers would wind up
  using the type default info, which doesn't properly represent the
  pointer's storage.

* GenDropContent() no longer tries to discard cdata->cinfo.  It might
  still be needed by the caller.

* GenFixupLVContent() can now adapt to partial ref/lock state
  in dst via dst->minfo when finalizing the lock state based on
  dst->storage.

* Don't apply SCOPE_UNLOCKED defaulting to procedure declarations.
  It is not applicable and creates confusion.

* Improved lock state assertions.

* Fix numerous pseudo-op bugs in RAS which executed the wrong
  locking primitives for numerous <blah>H instructions.  Due to
  bad cut-n-paste on my part.

Rune - Fix livelock on heavily contended locks

* Fix a livelock on heavily contended locks.  When waking up a list
  of blocked threads, a livelock situation can develop where the threads
  are placed back on the list asynchronously, preventing the iterator
  from ever being able to finish scanning the list.

* Fixed by issuing the wakeup in two passes.  The first pass moves td's
  to be woken up out of the list and onto a safe list.  The second pass
  wakes the tds up via the save list.

* Also fix Declaration layout (@rune_decl...), we added two fields.

Rune - Improve link debug output

* Track line numbers, generate .file and .loc output, ras
  parses .file and .loc output and associated .loc's with
  insns, and outputs .loc's in-context.

  This allows gdb to show the correct line number for
  rune code in rune executables.

* When -g is not specified we can avoid outputting decls
  for statement blocks.

Rune - Update Copyright

* Update the copyright file, push sunset dates back.

Rune - Collapse identical strings

* Strings are placed in a read-only code section, collapse
  identical strings.

Rune - Fix threading bugs

* Try to avoid getting stuck in blocking kevent()s when runnable threads
  are present (anywhere).  Still isn't perfect.

* Fix LastQueue handling.

* Fix the push and pull iterator.

Rune - Fix globaldata pointer assignment offset

* Fix globaldata address generation for compile-time assigned
  pointers.  The offset was not being properly added.

* Fix globaldata info generation and operation for non-pointer
  operations on global variables.  e.g. ++total_count where
  total_count is a global now properly acquires the global
  info lock.

* TODO: Give each global variable its own RefStor for locking
  purposes if needed.

Rune - Allow ++*, --* to work like C

* Allow ++* and --* to work the same way it does in C.
  Any +* or -* sequence is scanned as if there was a space before
  the '*'.

Rune - Fix thread issue

* threadPushRunnable() releases and reacquires SchedMtx, which can
  cause tdnext to become invalid.  Move the call to the target side
  of the switch.  This fixes thread corruption in tests/gfxinput2.d

* Cleanup, use threadSwitchReturn() in threadDetachSynchronous().

Rune - Fix the lock masking during a threaded call detach

* Fix the masking used to reset the lock count to 1 when
  transfering ownership from otd to ntd.

Rune - Refactor interpreter locking a bit

* Hopefully fix a few issues, particularly related to the &array[n]
  and &ptr[n] forms.

* Get rid of the istmp == 2 mode (this used to disable sideband
  locks for rundata elements).

* Fix a few situations where locks were not being released,
  and instead would accumulate on the thread.

Rune - Refactor threaded procedure calls, fix bugs

* Refactor how libruntime deals with threaded procedure calls.

* Fix numerous bugs in the threading code, particularly related to
  the disposal of thread contexts for synchronously-returned threaded
  procedure calls.

* Fix threadSleepWChan().  Also remove TWSleep and just stick with the
  wchan hash array as part of this.

Rune - Add more 'bool' operators

* 'bool' is now its own distinct class.  Add more operators that can
  handle it.  Needs work though, results are not masked and bool is
  currently defined as an 8-bit byte, so operators like '+' and '-' will
  give weird results.

Rune - Add a linked field to frames

* Add a linked field and a checklinked() method to Frame, allowing
  an asynchronous support function to determine if a frame has been
  unlinked before issuing graphics calls on it.

* Fixes an issue where a button which is unlinked while being held down
  does not create a ghost image when the button is released.

Rune - Change subclass and subinterface syntax

* I've decided to change the subclass and subinterface syntax to
  specify the <id> first, for readability.  This way the <id> is
  in the same place in the syntax for class, subclass, interface,
  and subinterface.

* Change from subclass <superclass> as <id>
  Change to   subclass <id> from <superclass>

* Change from subinterface <superclass> as <id>
  Change to   subinterface <id> from <superclass>

Rune - Fix interpreter array index typing

* Use ex_Run64 for RunAryExp() and RunAddrAryExp().  Also,
  RunAddrAryExp() was previously assuming a 32-bit array index.
  This also fixes that.

* Fix a bug in RunCachedConstantExp() when processing unsigned
  integers.  We were testing TF_ISINTEGER before TF_ISUNSIGNED.
  But TF_ISINTEGER also covers TF_ISUNSIGNED.  Process TF_ISUNSIGNED
  first.

* Optimize content adjustments for arrays.  Only iterate the array
  if its content contains the capabilities being adjusted.

* Code cleanup.

Rune - Fix interpreter assignment issue

* The assignment code drops the contents of the destination before
  copying.  This results in a problem when assigning x = x.
  Special-case it.

  The problem is still present in the code generator.

Rune - StreamPair fixes

* Use separately allocated streams for StreamPair (prior commit).

* Clarify variable names.

Rune - Fix thread bugs, add lock debugging

* Fix a number of thread-tracking bugs and races.  We have to set
  RUNNING a little earlier to prevent stolen locks from being stolen
  themselves while we are running.

* Fix a bug in the thread detach code which transfers some of the
  old thread's locks over to the new thread.  The lock count was
  getting mangled.

* Add thread debugging.

* Add lock debugging.

Rune - Add Pointer.lockcount(), misc bug fixes

* Add Pointer.lockcount().  This returns the number of locks held on the
  pointer target.

* Fix a bug in unbuffered fwrite() (M_NONE).  The loop would sometimes
  not terminate.

Rune - Threading fixes, cleanups

* Implement importdesc().  This sets O_NONBLOCK on the descriptor when
  extpread()/extpwrite() are not available.

* Cleanup the Stream and StreamPair class a bit.  Separate the allocation
  for the read and write streams in StreamPair.  This allows accessors to
  separately thread the read and write side without deadlocking each other.

* Fix per-rgd TaskReadAry and TaskWriteAry handling.  Recent threading
  changes now allow all rgd's to maintain their own KQueue.

* Preallocate the array of lists instead of having an array of pointers
  for TaskReadAry and TaskWriteAry.  Its just easier, and the size of
  the array is dynamic anyway (based on number of descriptors).

* Implement I/O support on systems which do not have extpread() and
  extpwrite().

* Fix RunThreads accounting.

* Fix threadPushRunnable() use cases.

* Remove a bunch of LASTQUEUE related debugging.

Rune - Refactor runtime threading for generated code

* Get rid of a large number of bottlenecks by making the timer and
  run queues per-cpu (well, per-GD).

* Fix numerous SMP races in the timer code.

* Fix a few pthread mutex deadlocks.

* Increase various table sizes.

* Do not blindly wakeup all threads on a Timer event's TWSleep[]
  list.  Just wakeup the thread associated with the Timer event.

* Test with 1 million Rune threads.

Rune - Check thread stats more often

* Check the thread stats more often to determine when more real pthreads
  are needed.

Rune - Add 'mpsafe'

* Add the 'mpsafe' scope identifier (really storage qualifier but
  as with 'unlocked', is parsed as a scope identifier to avoid
  confusion in procedural declarations).

  mpsafe scoped sources disable both the lock and the ref on the
  stored version of the pointer or reference, and disables pointer
  range checking on indirections.

  mpsafe scoped destinations (e.g. of an indirection like (a->b) allow
  accesses without any further locks or refs.  If the source is also
  scoped mpsafe, Rune will not bother generating any of its normal
  pointer range checking or lock/ref code for such accesses.

* Clarify handling of 'unlocked', document handling of 'mpsafe'.

* Document 'noinline' scope.  This prevents a procedure from being
  inlined by Rune's code generator.

Rune - Fix global initialization bug

* Fix PointerInfo bug for global initializer.  The info structure
  contains only the pointer's bounds, not the pointer itself.
  Fixes assembler syntax error.

* in_Refs field for argv and argv[n] elements, fixes assertion
  for compiled execution.

Rune - Refactor storage space tracker

* Refactor the storage space tracker for primary and temporary
  data.

* Fixes a bug where temporary storage was not being properly tracked,
  causing some format calls to implode.

Rune - Fix posix_memalign() usage

* Fix posix_memalign() usage.  Arguments were reversed in one case,
  and the minimum allowed alignment is sizeof(void *).

* Fixes various bits of corruption.

Rune - Add bracketed array initializer support

* Add bracketed array initializer support.  That is, something like
  this:

  int array[6] = [ 1, 2, 3, charlie() ];

* Supports compile-time (interpreted) resolvable functions and
  constants like almost everything else.

Rune - Add tests for trig/log/exp functions

* Add test scripts for trig/log/exp functions.

Rune - Fix bug in FNEG generation

* Fix bug in FNEG -> x86 generation.

Rune - Add internal trig, log, pow, exp functions

* Add math support for trig, log, pow, and exp class functions

Rune - Fix debug directive

* Fix stack offset debug directive at procedure entry.

Rune - Flesh out compile-time global initializations

* Flesh out compile-time global initializations.  Fix a recursion
  into the same expression when the code generator invokes the
  interpreter to resolve a global pointer assignment.

* Document more features.

Rune - Fix FP save and restore with mixed ABI calls

* Rune currently uses MSABI which requires XMM6-15, RDI, and RSI
  to be saved by procedures in addition to the standard Linux/BSD
  ABI which requires procedures to save RBX, RBP, and R12-R15.

  We do this because Rune can't inline as well as a C compiler
  and often has to make internal ABI calls (which also use MSABI)
  in the middle of code the programmer might otherwise believe
  does not have to make procedure calls.  We want to be able to
  maintain FP variables in XMM registers without repeated saving
  and restoring.  The addition of RBX and RBP to the callee-saves
  set also helps Rune's register allocator perform better.

* Fix issues when Rune is calling into a linux/BSD ABI (i.e.
  when interfacing with C, making system calls, etc).  In this
  situation, the Rune procedure was not saving registers that
  could get trashed by the system call or C call).

Rune - Remove some debugging

* Remove a bit of debugging

Rune - Copy tracking minfo in GenPointerInd2()

* Copy tracking minfo in GenPointerInd2().  This removes a few
  unnecessary get/put sequences in the generated output.

Rune - Change ABI

* Change the ABI to be more like the microsoft call ABI.  The main reason
  is that fewer registers are scratch across calls, which significantly
  reduces the effort the RAS register allocator must make due to the large
  number of RuneRunTime_*() calls that are made.

Rune - Clarify documentation for ops on reference types

* Clarify the documentation on the limitations of certain types of
  operations on reference types.

Rune - Convert most library pointers to references

* In Rune we want to encourage the use of references over pointers
  at every opportunity.  Since no pointer arithmatic is allowed on a ref
  and because it will either be NULL or valid, Rune can optimize refs
  more easily.

RAS - Fix .zero alignment

* .zero alignment was misintpreted as a fill value.  Generate a separate
  .align pseudo-op for any alignment > 1.

Rune - save/restore errno in signal handlers

* Save and restore errno in signal handlers so as not to interfere
  with mainline code.

Rune - Reorder weak bindings

* Reorder weak bindings for newer versions of GCC which require fully
  formed types for weak bindings.

Rune - Consolidate most RefStor allocations

* Consolidate most RefStor allocations into allocRefStor().

* Start tracking potential PointerInfo extensions to stack frames and
  RefStor's to allow PointerInfo structures to be made static.  This
  isn't set in stone yet and the counter / index fields are not yet
  used.

Rune - Optimize getrgd()

* getrgd() has a specific problem in that GCC is badly broken when it comes
  to accessing TLS variables in a NxM threading scheme.  GCC will cache the
  %fs:0 load into a register and nothing we tell it can get it to throw
  away that cached value.  In a NxM threading scheme, a micro-thread can
  block and wind up on a different pthread when it wakes up.

  This is particularly painful when GCC does heavy optimizations that
  combine what would normally be separate procedural domains.

* The getrgd() I had before was portable, but painfully expensive (two
  subroutine calls!).  I've decided to optimize getrgd() into an inline
  and use __asm to manually retrieve the per-pthread &RuneTLS.  This
  is not really portable, but it's very important the Rune be able to
  switch micro-threads quickly.

Rune - Fix interpreter (tests/gfxinput2.d)

* Bring the interpreter's initialization of the PointerInfo structure
  up-to-date.  type->ty_Info was not being set to PINFO_STATIC.  This
  fixes interpretation of a number of test programs.

Rune - Fix deadlock in rune threading system

* Fix a deadlock in Rune's sideband locks.  An unlock->wakeup->start
  sequence needs to hold two sideband locks.  To avoid the deadlock,
  relock in address-sorted order if the initial attempt to obtain the
  second lock fails (trying with a non-blocking call).

Rune - Start working on registerizing inlined procedure arguments (2)

* Fix a few bugs.  It's a bit fragile so I put the important pieces
  around #ifdef's.

* Enable the feature.

* Make sure that normal procedure call return values are not cached,
  the result vector has to be memory.

Rune - Start working on registerizing inlined procedure arguments

* Start working on registerizing inlined procedure arguments.  Currently
  disabled (it almost works but the tests/gfx* programs have some problems
  so clearly I'm missing something).

Rune - Make code PointerInfo-centric

* The PointerStor and LValueStor structures now contain only two elements,
  the address pointer and a pointer to a PointerInfo structure.

* The PointerInfo structure is now the center of the universe.  Make it
  slightly larger to accomodate a in_Refs field, but ultimately we want
  to incorporate it into related RefStor's and stack contexts and not
  need any dynamic allocation.

* In this new scheme we have to pass a proper PointerInfo element in the
  constructor/destructor (EmitRAS_CallConstructorDestructor()) code.
  Use the method argument's type->ty_Info.  TODO - missing RefStor for
  re-ref case.

* PointerStor and LValueStor are now 16-byte-aligned.  This significantly
  reduces the cost of pointer copies (we can use %xmm0).  There is still
  a C compatibility structure somewhere that requires the __aligned(16)
  extension (which is in-place with this commit) and is getting confused,
  but I'd like to find and fix that with explicit pad.

* TODO - There's a memory leak as of this commit.  PointerInfo's are being
  allocated for lvalue args but not freed.  Will have to change the
  mechanic somewhat.

Rune - Cleanup PointerInfo use in interpreter

* Cleanup PointerInfo handling to track the structure and free it after
  use.

* Optimize NULL handling.

* Scrap StrTable hacks previously used to track PointerInfo for quoted
  strings.

Rune - Initial PointerStor/LValueStor rework

* Initial rework, make PointerStor and LValueStor much smaller structures.
  Basically just { ptr, info } now, and move the fat fields one indirection
  level down into the info.

* This commit I just mocked-up PointerInfo allocations so I could test with
  the interpreter.  They leak like crazy.

Rune - Fix interpreter's BOOL_BINARY_OP

* We can't use the 64-bit short-cut for floating point comparisons.
  Fixed.

Rune - Add Unchecked option (-u)

* Add -u option.  This disables all bounds checking in any generated
  output.  Interpreted programs will still do bounds-checking.

* Generate help if no arguments or unrecognized option specified.

Rune - Select stronger alignment when it makes sense

* Use a larger alignment for arrays, compound expressions, and procedure
  arguments when the type is large enough.

* Improves copying and zeroing by allowing RAS to rollup fields into bigger
  registers and/or use the %xmm registers.

Rune - Fix array passing, optimize constant array indices

* Fix array passing (arrays are pased by value), interpreter and code
  generator.

* Optimize constant array indices, removing unnecessary instructions
  which are only calculating or testing constants.

Rune - Change limport mechanic

* Use quoted import paths to mean as-self (aka limport), and angle-bracketed
  paths to mean under an identifier.  So e.g. one would normally import "sys";
  and import <third_party_library>.

* Implement angle-bracket strings for import.  This also allows ANSI
  string concatenation, including with angle-brackets if you really want to.

* Fix string concatenation by limiting the successive concatenations to the
  same quoting mechanism as the first one.

* Remove the 'limport' keyword.

* This mechanism is more readable in terms of alignment.

Rune - Add labeled blocks

* Allow statement blocks to be labeled.  The statement block associated with
  a procedure body cannot be labeled but may be referred to as "procedure".

* Allow block labels to be specified in the 'break' and 'continue'
  statements.

RAS - Improve register allocator

* Remove the conditional bypass optimization for now, it actually makes
  register allocation worse by messing up register life-time tests even
  in simple procedures.

* Clarify comments a bit.

Rune - Pass-through -O[n], drop more insns in RAS

* The 'rune' command passes -O[n] through to RAS.

* Fix the drop-test in RAS.  A non-WRITE EA could prevent an instruction
  from being dropped.

  This fixes unnecessary double initializations, primarily from pre-zeroing
  of variables on semantic entry which are immediate initialized again via
  the code.

Rune - Handle const array lookups.

* Array lookups on constants (aka strings) are now constant-optimized
  in both the interpreter and the code generator.

Rune - Add strdup(), strcmp(), strncmp()

* Add strdup(), strcmp(), strncmp()

* Flag string functions which can be pure.

Rune - Fix ptr->int cast bug

* Fix var-args ptr-to-int cast, it was improperly taking the
  address of the PointerStor instead of taking PointerStor.s_Addr.

Rune - Stabilization pass (CLOEXEC work, return-storage for internal calls)

* All system calls which create a new file descriptor always return the
  descriptor with O_CLOEXEC set.  open, pipe, socketpair, dup, dup2,
  opendir.

* Implement proper return storage semantics for internal calls that return
  non-trivial structures (aka pointers), and properly pre-initialize the
  return storage.

* Rename some API calls in classes/* and clean-up.

* Fix the exec code for the case where the requested descriptors for
  0, 1, and 2 are mis-ordered.

Rune - Rework resolver

* Change the first pass model to a multi-pass model that allows portions
  of the tree to be requeued for resolve when they cannot be immediately
  resolved.

* Make sure the dynamic methods are properly resolved.  When a method
  call is made through a reference the version of the method in any
  subclass may end up being called and those procedures must be resolved.

  However, we do not have to resolve method procedures in subclasses which
  are never instantiated by the program, since those methods can never be
  called.

* As part of the dynamic method work the various passes must handle
  the recursion to resolve dynamic methods the same way, typically
  by detecting a dynamic method call and iterating through d->d_Sub*
  (recursively).

* Generate the dynamic index for method calls for all possible method
  vectors for consistency.  However, particular vectors which the resolver
  knows will never be executed will be populated as NULL by the code
  generator, significantly reducing the size of the code being output.

* Stabilization pass on some of the tests, fix a few issues here and
  there such as missing ResolveDecl() calls when resolving operators
  and an incorrect EXF_ADDRUSED flag when processing an array lookup.

* Rename functions for consistency.

Rune - Start work on inlining

* Start work on inlining procedures.

* Add ct_ArgBase, abstract-out the argument base.

* Optimize stack allocations a bit by flagging when a procedure might make
  ABI calls.

* Get rid of the Exp 'copy' stuff, dup the Exp earlier rather than later
  (fix several bugs where undup'd exp's were being unintentionally
  modified).

* Detect dynamic method calls, index refined subclass methods via
  d->d_SubBase and d->d_SubNext.

* gfxinput2.d test works but gfxbutton2.d can't resolve due to resolver
  loops.  Resolver is in a bit of a pickle and will have to be written
  after this commit.

Rune - Adjust autocast code to fix implied compound expression

* Check for a cast operator for (scaler) -> (compound) before
  automatically casting the scaler to compound.  Before we automatically
  cast the scaler first and the cast operator (if present) would never
  be run.  (tests/cast.d)

* (scaler) and scaler needs to be deterministic, so treat them both the
  same - as a scaler.  Otherwise simple parenthesis can cause confusion.

  If doing a compound assignment this means we now require a named element
  for a single-scaler compound if the programmer wants the scaler to use
  an actual or implied scaler -> compound cast.

* Cleanup some debugging messages we no longer need.

Rune - Main should exit without waiting for threads

* The main() now exits when it returns, no longer waiting for
  other threads to finish first.

  The programmer can decide to wait for not with Thread.waitThreads();

Rune - refactor resolve-time constant evaluation

* Refactor resolve-time constant evaluations (e.g. in order to be able
  to resolve array types and certain && and || optimizations).

  Remove the conditionalized paths in resolve*() for RESOLVE_CONSTEXP.
  Instead, we evaluate these issues in the storage-alignment pass.

* This makes tests/pure.d work.