llvm-pretty 0.12.1.0 → 0.13.0.0

raw patch · 4 files changed

+69/−16 lines, 4 filesnew-uploaderPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +7/−0
• llvm-pretty.cabal +3/−3
• src/Text/LLVM.hs +2/−2
• src/Text/LLVM/AST.hs +57/−11

@@ -1,5 +1,12 @@ # Revision history for llvm-pretty +## 0.13.0.0 (March 2025)++* Changed some of the signatures of helper functions in the AST to make them more+  flexible by using `Type' ident` rather than `Type` in their signatures (the+  latter fixes `ident` to be `Ident`). Changed functions: `isAlias`,+  `isPrimTypeOf`, `isVector`, `isVectorOf`, `isArray`, and `isPointer`.+ ## 0.12.1.0 (August 2024)  * Fix for printing NaN and infinite floating point values.

@@ -1,6 +1,6 @@ Cabal-version:       2.2 Name:                llvm-pretty-Version:             0.12.1.0+Version:             0.13.0.0 License:             BSD-3-Clause License-file:        LICENSE Author:              Trevor Elliott@@ -13,7 +13,7 @@   Augustsson.  The library provides a monadic interface to a pretty printer,   that allows functions to be defined and called, generating the corresponding   LLVM assembly when run.-tested-with:         GHC==8.4.3, GHC==8.2.2, GHC==8.0.2+tested-with:         GHC==9.8.4, GHC==9.6.6, GHC==9.4.8 extra-doc-files:     CHANGELOG.md, README.md  @@ -55,7 +55,7 @@                        microlens-th     >= 0.4,                        syb              >= 0.7,                        template-haskell >= 2.7,-                       th-abstraction   >= 0.3.1 && <0.7+                       th-abstraction   >= 0.3.1 && <0.8  Test-suite llvm-pretty-test   Import: common

@@ -700,8 +700,8 @@ -- | Emit a call instruction, and generate a new variable for its result. call :: IsValue a => Typed a -> [Typed Value] -> BB (Typed Value) call sym vs = case typedType sym of-  ty@(PtrTo (FunTy rty _ _)) -> observe rty (Call False ty (toValue sym) vs)-  _                          -> error "invalid function type given to call"+  PtrTo ty@(FunTy rty _ _) -> observe rty (Call False ty (toValue sym) vs)+  _                        -> error "invalid function type given to call"  -- | Emit a call instruction, but don't generate a new variable for its result. call_ :: IsValue a => Typed a -> [Typed Value] -> BB ()

@@ -480,11 +480,11 @@ isFloatingPoint (FloatType _) = True isFloatingPoint _             = False -isAlias :: Type -> Bool+isAlias :: Type' ident -> Bool isAlias Alias{} = True isAlias _       = False -isPrimTypeOf :: (PrimType -> Bool) -> Type -> Bool+isPrimTypeOf :: (PrimType -> Bool) -> Type' ident -> Bool isPrimTypeOf p (PrimType pt) = p pt isPrimTypeOf _ _             = False @@ -496,20 +496,20 @@ isInteger Integer{} = True isInteger _         = False -isVector :: Type -> Bool+isVector :: Type' ident -> Bool isVector Vector{} = True isVector _        = False -isVectorOf :: (Type -> Bool) -> Type -> Bool+isVectorOf :: (Type' ident -> Bool) -> Type' ident -> Bool isVectorOf p (Vector _ e) = p e isVectorOf _ _            = False -isArray :: Type -> Bool+isArray :: Type' ident -> Bool isArray ty = case ty of   Array _ _ -> True   _         -> False -isPointer :: Type -> Bool+isPointer :: Type' ident -> Bool isPointer (PtrTo _) = True isPointer PtrOpaque = True isPointer _         = False@@ -1196,7 +1196,16 @@     | ShuffleVector (Typed (Value' lab)) (Value' lab) (Typed (Value' lab))-+    {- ^ * Constructs a fixed permutation of two input vectors: the first+           and second arguments are input vectors, and the third argument+           is the mask.+         * Middle of basic block.+         * Returns the permuted vector. For each element, the mask selects+           an element from one of the input vectors to copy to the result:+            * non-negative mask values represent an index into the concatenated+              pair of input vectors, and+            * -1 mask value indicates that the output element is poison.+    -}    | Jump lab     {- ^ * Jump to the given basic block.@@ -1208,6 +1217,16 @@          * Ends basic block. -}    | Invoke Type (Value' lab) [Typed (Value' lab)] lab lab+    {- ^ * Calls the specified target function, then branches to the success+           label.  If an exception occurs during the call, the exception unwind+           handling branches to the second label.+         * Arguments:+           1. The function's return type+           2. The function target itself (to be called)+           3. arguments to the function+           4. successful return target label+           5. on-exception unwind target label+         * Ends basic block. -}    | Comment String     -- ^ Comment@@ -1217,21 +1236,48 @@    | Unwind   | VaArg (Typed (Value' lab)) Type+    -- ^ Accesses arguments passed through \"varargs\" areas of a function call.+    -- The argument is a @va_list*@; this instruction returns the value of the+    -- specified type located at the target and increments the pointer.+   | IndirectBr (Typed (Value' lab)) [lab]+    -- ^ Branch via pointer indirection.  The argument is the address of the+    -- label to jump to.  (All) Possible destination targets are provided.    | Switch (Typed (Value' lab)) lab [(Integer,lab)]-    {- ^ * Multi-way branch: the first value determines the direction-           of the branch, the label is a default direction, if the value-           does not appear in the jump table, the last argument is the-           jump table.+    {- ^ * Multi-way branch: the first value determines the target index+           for the jump, which is looked up in the third argument table+           (key values are unique).  The second argument is the default+           destination if the target is not found in the table.          * Ends basic block. -}    | LandingPad Type (Maybe (Typed (Value' lab))) Bool [Clause' lab]+    {- ^ Target of an exception (from the 'Invoke' instruction).+         * Arguments:+           1. The result type (the values set by the personality function+              on re-entry to the function).+           2. The second argument may be the personality function, which defines+              values on re-entry. This is used in older LLVM versions and is+              not supplied for recent LLVM versions.+           3. True if this block is a "cleanup".+           4. The list of clauses to handle the exception;  the clauses are+              used to match the exception thrown.+         * If no clause matches and cleanup not set, continue unwinding up+           the stack (see 'Resume').+         * If cleanup is false, there must be at least one clause+     -}    | Resume (Typed (Value' lab))+    {- ^ Resumes propagation of an in-flight exception whose unwinding was+         interrupted by a 'LandingPad' instruction.+         * Argument: the value of the exception to propagate.+    -}    | Freeze (Typed (Value' lab))     {- ^ * Used to stop propagation of @undef@ and @poison@ values.+         * If the argument is @undef@ or @poison@, returns an arbitrary+           (but fixed) value of that type instead, otherwise a no-op and+           returns its argument.          * Middle of basic block. -}      deriving (Data, Eq, Functor, Generic, Ord, Show, Typeable)