IRef refers to any memory location in any parts of the Mu memory,
including both heap, stack and global. The common part about them is
that Mu knows the types (at least the location of reference fields) of
all of them. We use the term "conceptually boxed" and "conceptually
unboxed" to describe the difference between the destination of "iref"
and "uptr": irefs always refer into "conceptually boxed" things (boxed
in the sense that Mu knows their field types (at least reference
fields)). Heap objects are obviously boxed. We can consider each stack
as a huge box, and the entire global space as a huge box. "iref" can
only be obtained from the allocation operations in Mu. But uptrs may
point outside the Mu memory, which can be literally anywhere. They can
even be created by C functions, such as "malloc".

Given all arguments (including all type arguments, signature arguments
and value arguments), the micro VM always knows how many results an
instruction has.

The CCALL instruction's design allows not only untraced function
pointers as the callee, but also allow system calls and so on. The
separation of "callee type" and "callee signature" -- where the callee
type is usually just `ufunctpr<sig>` -- may cause some confusion.

Now I explicitly stated that the destination clause is used only for
designating intra-function destinations, that is, cannot have basic
blocks in other function versions as destinations. This does not change
the semantics, but just make it explicit.

When it is a C NULL pointer, it behaves as if the initial threadlocal
objref is a Mu NULL ref.

These types have unspecified sizes and alignments, and are unaccessible
to C programs.

Fixed a bug where the last param of new_thread_nor should be
MuArraySize.

Removed MuIRNodeRefValue to make MuIRNode unique.

muapi.h also includes the common instruction names in the comment after
the macro. Improved the API parser for this purpose.

Now the IR Builder API is also available as common instructions. We keep
muapi.h as the canonical definition, and the semantics of common
instructions maps to that of the API functions.

As we migrated to GitLab, GitLab expects the .rst suffix instead of
.rest which GitHub expects. I also renamed some files using this
opportunity.

Non-top-level nodes are local to function definitions.

p.s. This should be the last commit on GitHub. Migrating to
https://gitlab.anu.edu.au/mu/mu-spec

Improved the annotations in muapi.h so that it is easier to generate
language bindings automatically.

The muapiparser.py is copied from refimpl2 for convenience.

Cast constant macros to their respective types so that they will have
proper sizes and signedness.

MuAtomicRMWOp is renamed to MuAtomicRMWOptr, in order not to confuse
"operator" and "operand".

The new_thread API call is split into two functions, one continues
normally and the other throws exception. This interface will be more
C-style.

It will be convenient if there is a program that parses the muapi.h and
generates language bindings (for Python, Scala, etc.). Some annotations
are added in the muapi.h file to make this process easier. For example,
when passing an array, C functions usually take two parameters: a
pointer and a size. The param:array:sz annotation tells the parser that
the "param" parameter points to an array whose size is determined by the
"sz" parameter. "param:bool" tells the parser that the "int param"
parameter holds a boolean value (non-zero or zero). "param:optional"
tells the parser that the "T* param" parameter may be NULL.

The 'irbuilderref' type is no longer used. 'irnoderef' is the only newly
introduced Mu type. A bundle node now works as a namespace. All other
nodes are children of the bundle node. After a bundle node is loaded
into Mu (or aborted), Mu may de-allocate the bundle node and all of its
children for space efficiency.

irnoderef refers to Mu IR nodes when constructing IR using the API.

Pointer types should have been scalar types. Anything that is not
composite types nor "void" should be scalar.

As we discussed, the bundle loading interface between the client and the
micro VM should be a functional interface. The binary form is still a
parsed format. This commit removes the binary format in the type system
and the instruction set.

Like the `new_thread` API call, the NEWTHREAD instruction needs to take
a thread-local objref as a parameter, too. This clause is optional. If
omitted, it defaults to `NULL`.

The thread-local object reference gives each thread a reference to an
arbitrary object, which can hold thread-local states. New API functions
and new (common) instructions are added. It is also a thread states and
a GC root.

Added MuSeqValue and MuGenRefValue in the muapi.h. Although all MuValue
subtypes are just aliases of void* in the C API, having some annotation
makes the API more readable for the programmer as well as language
binding makers.

Top-level definitions may refer to things defined later, or refer to
each other recursively. It has always been allowed, but someone may
think the following is forbidden:

    .typedef @longptr = uptr<@long> // @long is defined after this line
    .typedef @long = int<64>