Fix problems with LLVM compilation

 - extern functions with by-value structures
 - extern functions with tuples
Add test case for extern record byval
Migrate #defines to static inline to work with LLVM

The LLVM backend can't handle using macros that
are complicated, so we use static inline functions
instead. One day it will work with macros...
Add skipifs for tests relying on C backend
Merge remote-tracking branch 'upstream/master' into llvm-fixes-6
Add some (debugging) asserts for LLVM
Fix problem with convertValueToType force

I had gone too far in making it more conservative...
Add an example of using the targetLocales method on arrays
Temporary workaround for --llvm errors about S_IRWXU

Here we just disable the error... You'll get a different
error if we try to use these.
Fix passing sync/single variables by ref/blank intent.
Merge branch 'master' of github.com:chapel-lang/chapel into dist-primer-lsq
Adding exampels for the 'localSubdomain(s)' functions
Report error when assigning to const arrays/domains.
Addd a work around for non-default size bools in ref temp removal

Non-default sized bools don't have their sizes properly preserved in
codegen. Removing ref temps causes these issues to be exposed. For now
just dont remove ref temps for any bool in a no-local compilation.
Fix for a pointer truncation bug that is surfaced on Mac OS-X
Followed up on reviewers' comments.
Added tests. Retired a future.
Added another isX test; strengthened type-tests.chpl.
type-tests.todo.chpl is now covered by type-tests.chpl,
so I removed it.
More test adjustments.
Also allowed sync/singles in tuple *types*
- see parallel/sync/diten/tupleOfSync.chpl
Fix for io_test C compilation error.

The error message being displayed by the C compiler (GCC version 4.4.1 or newer) is
meaningful.  It warns that the program is attempting to free something that is not
heap-allocated -- in this case "\n" and the definitions of other ioLiterals.

The reason why the error only appears when --fast is supplied is that aggressive inlining
brings the call to free() into the function where an ioLiteral is passed to it, so under
those circumstances the C compiler can see that something stupid is being attempted.

In the original code, the author thought is was safe to free by explicitly avoiding known
cases where the contents of a c_string was owned by another program entity.  However,
since the IO module also supplies unowned c_strings it is unsafe in general to delete
them.  I added comments liberally to the module code where c_strings are accessed, so
future programmers are warned away from this practice.

Looking forward, except where performance is a concern, strings should be used in
preference to c_strings.  The new implementation of strings will manage memory correctly,
so the programmer who uses such objects need not concern himself with ownership details.
Followed up on the second round of Brad's comments.

Two TODOs:
* [ ] David's review of test/modules/diten/moduleNotInitialized.chpl
* [ ] why passing sync/single by reference is specific to ref/blank intents?