diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Revision history for llvm-pretty
 
+## 0.12.1.0 (August 2024)
+
+* Fix for printing NaN and infinite floating point values.
+
+* Add support for more AtomicRWOps.
+
 ## 0.12.0.0 (January 2024)
 
 * Add preliminary support for LLVM versions up through 17.
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@
 features](https://llvm.org/docs/LangRef.html), but there are places where our
 coverage of the LLVM language is incomplete. If you need a LLVM feature that is
 not currently supported by `llvm-pretty`, please [file an
-issue](https://github.com/elliottt/llvm-pretty/issues/new).
+issue](https://github.com/GaloisInc/llvm-pretty/issues/new).
 
 ## `llvm-pretty` versus `llvm-pretty-bc-parser`
 
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.0.0
+Version:             0.12.1.0
 License:             BSD-3-Clause
 License-file:        LICENSE
 Author:              Trevor Elliott
@@ -19,7 +19,7 @@
 
 source-repository head
   type:                 git
-  location:             http://github.com/elliottt/llvm-pretty
+  location:             http://github.com/GaloisInc/llvm-pretty
 
 common common
   Default-language:    Haskell2010
@@ -46,7 +46,7 @@
                        Text.LLVM.Triple.Parse.LookupTable
                        Text.LLVM.Util
 
-  Build-depends:       base             >= 4.9 && < 5,
+  Build-depends:       base             >= 4.11 && < 5,
                        containers       >= 0.4,
                        parsec           >= 3,
                        pretty           >= 1.0.1,
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
@@ -1,3 +1,14 @@
+{- |
+Because this library supports many LLVM versions, it is possible to construct
+an AST with the types in this module that only some LLVM versions will accept.
+These cases are usually documented in the Haddocks for the relevant data types.
+When trying to pretty-print constructions that are unsupported by the current
+LLVM version, pretty-printing may 'error'.
+
+At the same time, while the AST coverage is fairly extensive, it is also
+incomplete: there are some values that new LLVM versions would accept but are
+not yet represented here.
+-}
 {-# LANGUAGE ViewPatterns #-}
 {-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveGeneric #-}
 {-# LANGUAGE PatternGuards #-}
@@ -994,6 +1005,12 @@
   | AtomicMin
   | AtomicUMax
   | AtomicUMin
+  | AtomicFAdd  -- ^ Introduced in LLVM 9
+  | AtomicFSub  -- ^ Introduced in LLVM 9
+  | AtomicFMax  -- ^ Introduced in LLVM 15
+  | AtomicFMin  -- ^ Introduced in LLVM 15
+  | AtomicUIncWrap  -- ^ Introduced in LLVM 16
+  | AtomicUDecWrap  -- ^ Introduced in LLVM 16
     deriving (Data, Eq, Enum, Generic, Ord, Show, Typeable)
 
 data AtomicOrdering
diff --git a/src/Text/LLVM/PP.hs b/src/Text/LLVM/PP.hs
--- a/src/Text/LLVM/PP.hs
+++ b/src/Text/LLVM/PP.hs
@@ -27,6 +27,7 @@
 import Data.List (intersperse)
 import qualified Data.Map as Map
 import Data.Maybe (catMaybes,fromMaybe,isJust)
+import GHC.Float (castDoubleToWord64, castFloatToWord32)
 import Numeric (showHex)
 import Text.PrettyPrint.HughesPJ
 import Data.Int
@@ -95,6 +96,15 @@
 llvmVer :: (?config :: Config) => LLVMVer
 llvmVer = cfgVer ?config
 
+llvmVerToString :: LLVMVer -> String
+llvmVerToString 0 = "3.5"
+llvmVerToString 1 = "3.6"
+llvmVerToString 2 = "3.7"
+llvmVerToString 3 = "3.8"
+llvmVerToString n
+  | n >= 4    = show n
+  | otherwise = error $ "Invalid LLVMVer: " ++ show n
+
 -- | This is a helper function for when a list of parameters is gated by a
 -- condition (usually the llvmVer value).
 when' :: Monoid a => Bool -> a -> a
@@ -546,6 +556,12 @@
 ppAtomicOp AtomicMin  = "min"
 ppAtomicOp AtomicUMax = "umax"
 ppAtomicOp AtomicUMin = "umin"
+ppAtomicOp AtomicFAdd = onlyOnLLVM 9 "AtomicFAdd" "fadd"
+ppAtomicOp AtomicFSub = onlyOnLLVM 9 "AtomicFSub" "fsub"
+ppAtomicOp AtomicFMax = onlyOnLLVM 15 "AtomicFMax" "fmax"
+ppAtomicOp AtomicFMin = onlyOnLLVM 15 "AtomicFMin" "fmin"
+ppAtomicOp AtomicUIncWrap = onlyOnLLVM 16 "AtomicUIncWrap" "uinc_wrap"
+ppAtomicOp AtomicUDecWrap = onlyOnLLVM 16 "AtomicUDecWrap" "udec_wrap"
 
 ppScope ::  Fmt (Maybe String)
 ppScope Nothing = empty
@@ -813,8 +829,15 @@
 ppValue' pp val = case val of
   ValInteger i       -> integer i
   ValBool b          -> ppBool b
-  ValFloat i         -> float i
-  ValDouble i        -> double i
+  -- Note: for +Inf/-Inf/NaNs, we want to output the bit-correct sequence
+  ValFloat f         ->
+    if isInfinite f || isNaN f
+      then text "0x" <> text (showHex (castFloatToWord32 f) "")
+      else float f
+  ValDouble d        ->
+    if isInfinite d || isNaN d
+      then text "0x" <> text (showHex (castDoubleToWord64 d) "")
+      else double d
   ValFP80 (FP80_LongDouble e s) ->
     -- shown as 0xK<<20-hex-digits>>, per
     -- https://llvm.org/docs/LangRef.html#simple-constants
@@ -1345,3 +1368,11 @@
 
 ppMaybe :: Fmt a -> Fmt (Maybe a)
 ppMaybe  = maybe empty
+
+-- | Throw an error if the @?config@ version is older than the given version. The
+-- String indicates which constructor is unavailable in the error message.
+onlyOnLLVM :: (?config :: Config) => LLVMVer -> String -> a -> a
+onlyOnLLVM fromVer name
+  | llvmVer >= fromVer = id
+  | otherwise          = error $ name ++ " is supported only on LLVM >= "
+                                 ++ llvmVerToString fromVer
diff --git a/test/Output.hs b/test/Output.hs
--- a/test/Output.hs
+++ b/test/Output.hs
@@ -13,6 +13,7 @@
 
 import           Control.Monad ( unless )
 import qualified Data.Text as T
+import           GHC.Float (castWord32ToFloat, castWord64ToDouble)
 import qualified Test.Tasty as Tasty
 import           Test.Tasty.HUnit
 import qualified Text.PrettyPrint as PP
@@ -242,6 +243,46 @@
       ; <label>: 123
       --------
       |]
+
+  , testCase "Positive Infinity (float)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValFloat (castWord32ToFloat 0x7F800000)))
+      "0x7f800000"
+
+  , testCase "Negative Infinity (float)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValFloat (castWord32ToFloat 0xFF800000)))
+      "0xff800000"
+
+  , testCase "NaN 1 (float)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValFloat (castWord32ToFloat 0x7FC00000)))
+      "0x7fc00000"
+
+  , testCase "NaN 2 (float)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValFloat (castWord32ToFloat 0x7FD00000)))
+      "0x7fd00000"
+
+  , testCase "Positive Infinity (double)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValDouble (castWord64ToDouble 0x7FF0000000000000)))
+      "0x7ff0000000000000"
+
+  , testCase "Negative Infinity (double)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValDouble (castWord64ToDouble 0xFFF0000000000000)))
+      "0xfff0000000000000"
+
+  , testCase "NaN 1 (double)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValDouble (castWord64ToDouble 0x7FFC000000000000)))
+      "0x7ffc000000000000"
+
+  , testCase "NaN 2 (double)" $
+    assertEqLines
+      (ppToText $ ppLLVM37 ppValue (ValDouble (castWord64ToDouble 0x7FFD000000000000)))
+      "0x7ffd000000000000"
 
   ]
 
