A module to produce bitcode from llvm module descriptions.

• Extend the call instruction to carry the symbol, signature and calling conv, the call is performed with, and verify that the symbols type matches the signature; and calling conv if symbol is a Function Symbol. If Symbol is a reference ensure that the signature matches. (Data.BitCode.LLVM should automatically insert the required ptr cast if the symbol does not match). Also error if neither a Reference with matching signature nor a Function. I don't think calling anything else makes any sense?
• Drop the stupid Type first item from the instruction records. This should be computed using instTy.
• Make instTy work for getElementPointer.
• Write tests to verify that instTy works as expected.
• Verify, e.g. in mkInstRec for Call (e.g. everywhere where we do not use instTy that the type we encode matches the one we should expect.
• Fix getValue. We currently assume that we have no fwd references. And hence can always load the value, but llvm does not work that way for fwd references. There the value and type are encoded after each other (ValueId, TypeId). If it's non fwd reference, it's just ValueId. (see getValueTypePair in BitCodeReader). Similarly this is required to support fwd references in ToBitCode.
• Collapse constants.

• Stop handrolling your monads. (Use transformers, and derive!)
• Better error reporting (e.g. see preliminaries in Data.BitCode.LLVM.Util) Maybe using ExceptT to give good hints as to what faild?
• More type verification. (E.g. let's try to make sure you just can not construct invalid code)