diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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. diff --git a/llvm-pretty.cabal b/llvm-pretty.cabal --- a/llvm-pretty.cabal +++ b/llvm-pretty.cabal @@ -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 diff --git a/src/Text/LLVM.hs b/src/Text/LLVM.hs --- a/src/Text/LLVM.hs +++ b/src/Text/LLVM.hs @@ -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 () diff --git a/src/Text/LLVM/AST.hs b/src/Text/LLVM/AST.hs --- a/src/Text/LLVM/AST.hs +++ b/src/Text/LLVM/AST.hs @@ -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)