Store load type separately in Load

With opaque pointers, one cannot tell what the type being loaded is by
inspecting the pointer in the `load` instruction. As a result, we now store the
load type separately in the `Load` instruction so that it can be determined
regardless of whether opaque pointers are used or not.

See #102.

src/Text/LLVM.hs

@@ -622,11 +622,8 @@ alloca ty mb align = observe (PtrTo ty) (Alloca ty es align)
   where
   es = fmap toValue `fmap` mb
 
-load :: IsValue a => Typed a -> Maybe Align -> BB (Typed Value)
-load tv ma =
-  case typedType tv of
-    PtrTo ty -> observe ty (Load (toValue `fmap` tv) Nothing ma)
-    _        -> error "load not given a pointer"
+load :: IsValue a => Type -> Typed a -> Maybe Align -> BB (Typed Value)
+load ty ptr ma = observe ty (Load ty (toValue `fmap` ptr) Nothing ma)
 
 store :: (IsValue a, IsValue b) => a -> Typed b -> Maybe Align -> BB ()
 store a ptr ma =

src/Text/LLVM/AST.hs

@@ -814,8 +814,9 @@ data Instr' lab
          * Middle of basic block.
          * Returns a pointer to hold the given number of elements. -}
 
-  | Load (Typed (Value' lab)) (Maybe AtomicOrdering) (Maybe Align)
+  | Load Type (Typed (Value' lab)) (Maybe AtomicOrdering) (Maybe Align)
     {- ^ * Read a value from the given address:
+           type being loaded;
            address to read from;
            atomic ordering;
            assumptions about alignment of the given pointer.

src/Text/LLVM/Labels.hs

@@ -36,7 +36,10 @@ instance HasLabel Instr' where
   relabel f (Alloca t n a)        = Alloca t
                                 <$> traverse (traverse (relabel f)) n
                                 <*> pure a
-  relabel f (Load a mo ma)        = Load <$> traverse (relabel f) a <*> pure mo <*> pure ma
+  relabel f (Load t a mo ma)      = Load t
+                                <$> traverse (relabel f) a
+                                <*> pure mo
+                                <*> pure ma
   relabel f (Store d v mo ma)     = Store
                                 <$> traverse (relabel f) d
                                 <*> traverse (relabel f) v

src/Text/LLVM/PP.hs

@@ -519,7 +519,7 @@ ppInstr instr = case instr of
   Call tc ty f args      -> ppCall tc ty f args
   CallBr ty f args u es  -> ppCallBr ty f args u es
   Alloca ty len align    -> ppAlloca ty len align
-  Load ptr mo ma         -> ppLoad ptr mo ma
+  Load ty ptr mo ma      -> ppLoad ty ptr mo ma
   Store a ptr mo ma      -> ppStore a ptr mo ma
   Fence scope order      -> "fence" <+> ppScope scope <+> ppAtomicOrdering order
   CmpXchg w v p a n s o o' -> "cmpxchg" <+> opt w "weak"
@@ -597,8 +597,8 @@ ppInstr instr = case instr of
   Resume tv           -> "resume" <+> ppTyped ppValue tv
   Freeze tv           -> "freeze" <+> ppTyped ppValue tv
 
-ppLoad :: LLVM => Typed (Value' BlockLabel) -> Maybe AtomicOrdering -> Maybe Align -> Doc
-ppLoad ptr mo ma =
+ppLoad :: LLVM => Type -> Typed (Value' BlockLabel) -> Maybe AtomicOrdering -> Maybe Align -> Doc
+ppLoad ty ptr mo ma =
   "load" <+> (if isAtomic   then "atomic" else empty)
          <+> (if isImplicit then empty    else explicit)
          <+> ppTyped ppValue ptr
@@ -615,10 +615,7 @@ ppLoad ptr mo ma =
       Just ao -> ppAtomicOrdering ao
       _       -> empty
 
-  explicit =
-    case typedType ptr of
-      PtrTo ty -> ppType ty <> comma
-      ty       -> ppType ty <> comma
+  explicit = ppType ty <> comma
 
 ppStore :: LLVM
         => Typed (Value' BlockLabel)