Support newer inline asm codes

One code (`CST_CODE_INLINEASM_OLD3`) was introduced in LLVM 13, and another
(`CST_CODE_INLINEASM`) was introduced in LLVM 14. For the most part, they are
parsed identically to previous inline `asm` codes, but with some minor
differences. I have consolidated the logic for parsing all inline `asm` codes
into a single `parseInlineAsm` function.

The existing `disasm-test/tests/callbr.ll` test case ensures that we handle all
of these different `inline asm` codes correctly. As an added bonus, it's
portable across multiple LLVM versions!

Fixes #184.

src/Data/LLVM/BitCode/IR/Constants.hs

@@ -360,19 +360,8 @@ parseConstantEntry t (getTy,cs) (fromEntry -> Just r) =
     return (getTy, Typed (PrimType (Integer 1)) (ValConstExpr cst):cs)
 
   18 -> label "CST_CODE_INLINEASM_OLD" $ do
-    let field = parseField r
-    ty    <- getTy
-    flags <- field 0 numeric
-    let sideEffect = testBit (flags :: Int) 0
-        alignStack = (flags `shiftR` 1) == 1
-
-    alen <- field 1 numeric
-    asm  <- UTF8.decode <$> parseSlice r 2 alen char
-
-    clen <- field (2+alen) numeric
-    cst  <- UTF8.decode <$> parseSlice r (3+alen) clen char
-
-    return (getTy, Typed ty (ValAsm sideEffect alignStack asm cst):cs)
+    tv <- parseInlineAsm InlineAsmCode18 getTy r
+    return (getTy, tv:cs)
 
   19 -> label "CST_CODE_CE_SHUFFLEVEC_EX" $ do
     notImplemented
@@ -415,28 +404,9 @@ parseConstantEntry t (getTy,cs) (fromEntry -> Just r) =
       FloatType Double   -> build (ValDouble . castDouble)
       x                  -> Assert.unknownEntity "element type" x
 
-  23 -> label "CST_CODE_INLINEASM" $ do
-    let field = parseField r
-    mask <- field 0 numeric
-
-    let test = testBit (mask :: Word32)
-        hasSideEffects = test 0
-        isAlignStack   = test 1
-        _asmDialect    = mask `shiftR` 2
-
-    asmStrSize <- field 1 numeric
-    Assert.recordSizeGreater r (1 + asmStrSize)
-
-    constStrSize <- field (2 + asmStrSize) numeric
-    Assert.recordSizeGreater r (2 + asmStrSize + constStrSize)
-
-    asmStr   <- fmap UTF8.decode $ parseSlice r  2               asmStrSize   char
-    constStr <- fmap UTF8.decode $ parseSlice r (3 + asmStrSize) constStrSize char
-
-    ty <- getTy
-    let val = ValAsm hasSideEffects isAlignStack asmStr constStr
-
-    return (getTy, Typed ty val : cs)
+  23 -> label "CST_CODE_INLINEASM_OLD2" $ do
+    tv <- parseInlineAsm InlineAsmCode23 getTy r
+    return (getTy, tv:cs)
 
   -- [opty, flags, n x operands]
   24 -> label "CST_CODE_CE_GEP_WITH_INRANGE_INDEX" $ do
@@ -461,6 +431,20 @@ parseConstantEntry t (getTy,cs) (fromEntry -> Just r) =
     ty <- getTy
     return (getTy, Typed ty ValPoison : cs)
 
+  27 -> label "CST_CODE_DSO_LOCAL_EQUIVALENT" $ do
+    notImplemented
+
+  28 -> label "CST_CODE_INLINEASM_OLD3" $ do
+    tv <- parseInlineAsm InlineAsmCode28 getTy r
+    return (getTy, tv:cs)
+
+  29 -> label "CST_CODE_NO_CFI_VALUE" $ do
+    notImplemented
+
+  30 -> label "CST_CODE_INLINEASM" $ do
+    tv <- parseInlineAsm InlineAsmCode30 getTy r
+    return (getTy, tv:cs)
+
   code -> Assert.unknownEntity "constant record code" code
 
 parseConstantEntry _ st (abbrevDef -> Just _) =
@@ -498,6 +482,61 @@ resolveNull ty = case typeNull ty of
   HasNull nv    -> return nv
   ResolveNull i -> resolveNull =<< getType' =<< getTypeId i
 
+-- | The different codes for inline @asm@ constants. Each one has minor
+-- differences in how they are parsed.
+data InlineAsmCode
+  = InlineAsmCode18
+    -- ^ @CST_CODE_INLINEASM_OLD = 18@. The original.
+  | InlineAsmCode23
+    -- ^ @CST_CODE_INLINEASM_OLD2 = 23@. This adds an @asmdialect@ field.
+  | InlineAsmCode28
+    -- ^ @CST_CODE_INLINEASM_OLD3 = 28@. This adds an @unwind@ field (which is
+    -- referred to as @canThrow@ in the LLVM source code).
+  | InlineAsmCode30
+    -- ^ @CST_CODE_INLINEASM = 30@. This adds an explicit function type field.
+
+-- | Parse a 'ValAsm' value. There are several variations on this theme that are
+-- captured in the 'InlineAsmCode' argument.
+parseInlineAsm :: InlineAsmCode -> Parse Type -> Record -> Parse (Typed PValue)
+parseInlineAsm code getTy r = do
+  let field = parseField r
+
+  -- If using InlineAsmCode30 or later, we parse the type as an explicit
+  -- field.
+  let parseTy  = do ty <- getType =<< field 0 numeric
+                    return (PtrTo ty, 1)
+  -- If using an older InlineAsmCode, then we retrieve the type from the
+  -- current context.
+  let useCurTy = do ty <- getTy
+                    return (ty, 0)
+  (ty, ix) <- case code of
+                InlineAsmCode18 -> useCurTy
+                InlineAsmCode23 -> useCurTy
+                InlineAsmCode28 -> useCurTy
+                InlineAsmCode30 -> parseTy
+
+  mask <- field ix numeric
+
+  let test = testBit (mask :: Word32)
+      hasSideEffects = test 0
+      isAlignStack   = test 1
+      -- We don't store these in the llvm-pretty AST at the moment:
+      _asmDialect    = test 2 -- Only with InlineAsmCode23 or later
+      _canThrow      = test 3 -- Only with InlineAsmCode28 or later
+
+  asmStrSize <- field (ix + 1) numeric
+  Assert.recordSizeGreater r (ix + 1 + asmStrSize)
+
+  constStrSize <- field (ix + 2 + asmStrSize) numeric
+  Assert.recordSizeGreater r (ix + 2 + asmStrSize + constStrSize)
+
+  asmStr   <- fmap UTF8.decode $ parseSlice r (ix + 2)              asmStrSize   char
+  constStr <- fmap UTF8.decode $ parseSlice r (ix + 3 + asmStrSize) constStrSize char
+
+  let val = ValAsm hasSideEffects isAlignStack asmStr constStr
+
+  return (Typed ty val)
+
 
 -- Float/Double Casting --------------------------------------------------------