-- @generated
{-# OPTIONS_GHC -Wno-unused-matches #-}
module Glean.RTS.Bytecode.Gen.Issue
  ( inputNat
  , inputByte
  , inputBytes
  , inputSkipUntrustedString
  , inputShiftLit
  , inputShiftBytes
  , inputSkipNat
  , inputSkipTrustedString
  , resetOutput
  , outputNat
  , outputNatImm
  , outputByte
  , outputByteImm
  , outputBytes
  , outputStringToLower
  , outputRelToAbsByteSpans
  , outputUnpackByteSpans
  , outputStringReverse
  , getOutput
  , getOutputSize
  , loadConst
  , loadLiteral
  , move
  , subConst
  , sub
  , addConst
  , add
  , ptrDiff
  , loadLabel
  , jump
  , jumpReg
  , jumpIf0
  , jumpIfNot0
  , jumpIfEq
  , jumpIfNe
  , jumpIfGt
  , jumpIfGe
  , jumpIfLt
  , jumpIfLe
  , decrAndJumpIfNot0
  , decrAndJumpIf0
  , callFun_0_1
  , callFun_0_2
  , callFun_1_1
  , callFun_1_0
  , callFun_2_1
  , callFun_2_0
  , callFun_3_0
  , callFun_4_0
  , callFun_3_1
  , callFun_5_0
  , callFun_5_1
  , callFun_2_2
  , callFun_2_5
  , select
  , raise
  , trace
  , traceReg
  , suspend
  , ret
  ) where

import Data.ByteString (ByteString)
import Data.Word (Word64)
import Glean.RTS.Bytecode.Gen.Instruction (Insn(..))
import Glean.RTS.Bytecode.Code
import Glean.Bytecode.Types

inputNat :: Register 'DataPtr -> Register 'DataPtr -> Register 'Word -> Code ()
inputNat begin end dst = do
  issue $ InputNat begin end dst

inputByte :: Register 'DataPtr -> Register 'DataPtr -> Register 'Word -> Code ()
inputByte begin end dst = do
  issue $ InputByte begin end dst

inputBytes :: Register 'DataPtr -> Register 'DataPtr -> Register 'Word -> Code ()
inputBytes begin end size = do
  issue $ InputBytes begin end size

inputSkipUntrustedString :: Register 'DataPtr -> Register 'DataPtr -> Code ()
inputSkipUntrustedString begin end = do
  issue $ InputSkipUntrustedString begin end

inputShiftLit :: Register 'DataPtr -> Register 'DataPtr -> ByteString -> Register 'Word -> Code ()
inputShiftLit begin end lit match = do
  lit_i <- literal lit
  issue $ InputShiftLit begin end lit_i match

inputShiftBytes :: Register 'DataPtr -> Register 'DataPtr -> Register 'DataPtr -> Register 'DataPtr -> Register 'Word -> Code ()
inputShiftBytes begin end ptr ptrend match = do
  issue $ InputShiftBytes begin end ptr ptrend match

inputSkipNat :: Register 'DataPtr -> Register 'DataPtr -> Code ()
inputSkipNat begin end = do
  issue $ InputSkipNat begin end

inputSkipTrustedString :: Register 'DataPtr -> Register 'DataPtr -> Code ()
inputSkipTrustedString begin end = do
  issue $ InputSkipTrustedString begin end

resetOutput :: Register 'BinaryOutputPtr -> Code ()
resetOutput output = do
  issue $ ResetOutput output

outputNat :: Register 'Word -> Register 'BinaryOutputPtr -> Code ()
outputNat src output = do
  issue $ OutputNat src output

outputNatImm :: Word64 -> Register 'BinaryOutputPtr -> Code ()
outputNatImm src output = do
  issue $ OutputNatImm src output

outputByte :: Register 'Word -> Register 'BinaryOutputPtr -> Code ()
outputByte src output = do
  issue $ OutputByte src output

outputByteImm :: Word64 -> Register 'BinaryOutputPtr -> Code ()
outputByteImm src output = do
  issue $ OutputByteImm src output

outputBytes :: Register 'DataPtr -> Register 'DataPtr -> Register 'BinaryOutputPtr -> Code ()
outputBytes ptr end output = do
  issue $ OutputBytes ptr end output

outputStringToLower :: Register 'DataPtr -> Register 'DataPtr -> Register 'BinaryOutputPtr -> Code ()
outputStringToLower begin end dst = do
  issue $ OutputStringToLower begin end dst

outputRelToAbsByteSpans :: Register 'DataPtr -> Register 'DataPtr -> Register 'BinaryOutputPtr -> Code ()
outputRelToAbsByteSpans begin end dst = do
  issue $ OutputRelToAbsByteSpans begin end dst

outputUnpackByteSpans :: Register 'DataPtr -> Register 'DataPtr -> Register 'BinaryOutputPtr -> Code ()
outputUnpackByteSpans begin end dst = do
  issue $ OutputUnpackByteSpans begin end dst

outputStringReverse :: Register 'DataPtr -> Register 'DataPtr -> Register 'BinaryOutputPtr -> Code ()
outputStringReverse begin end dst = do
  issue $ OutputStringReverse begin end dst

getOutput :: Register 'BinaryOutputPtr -> Register 'DataPtr -> Register 'DataPtr -> Code ()
getOutput output ptr end = do
  issue $ GetOutput output ptr end

getOutputSize :: Register 'BinaryOutputPtr -> Register 'Word -> Code ()
getOutputSize output dst = do
  issue $ GetOutputSize output dst

loadConst :: Word64 -> Register 'Word -> Code ()
loadConst imm dst = do
  issue $ LoadConst imm dst

loadLiteral :: ByteString -> Register 'DataPtr -> Register 'DataPtr -> Code ()
loadLiteral lit ptr end = do
  lit_i <- literal lit
  issue $ LoadLiteral lit_i ptr end

move :: Register a -> Register a -> Code ()
move src dst = do
  issue $ Move src dst

subConst :: Word64 -> Register 'Word -> Code ()
subConst imm dst = do
  issue $ SubConst imm dst

sub :: Addable a b => Register b -> Register a -> Code ()
sub src dst = do
  issue $ Sub src dst

addConst :: Addable a 'Word => Word64 -> Register a -> Code ()
addConst imm dst = do
  issue $ AddConst imm dst

add :: Addable a b => Register b -> Register a -> Code ()
add src dst = do
  issue $ Add src dst

ptrDiff :: Register 'DataPtr -> Register 'DataPtr -> Register 'Word -> Code ()
ptrDiff src1 src2 dst = do
  issue $ PtrDiff src1 src2 dst

loadLabel :: Label -> Register 'Offset -> Code ()
loadLabel lbl dst = do
  issue $ LoadLabel lbl dst

jump :: Label -> Code ()
jump tgt = do
  issueEndBlock $ Jump tgt

jumpReg :: Register 'Offset -> Code ()
jumpReg tgt = do
  issueEndBlock $ JumpReg tgt

jumpIf0 :: Register 'Word -> Label -> Code ()
jumpIf0 reg tgt = do
  issue $ JumpIf0 reg tgt

jumpIfNot0 :: Register 'Word -> Label -> Code ()
jumpIfNot0 reg tgt = do
  issue $ JumpIfNot0 reg tgt

jumpIfEq :: Register a -> Register a -> Label -> Code ()
jumpIfEq reg1 reg2 tgt = do
  issue $ JumpIfEq reg1 reg2 tgt

jumpIfNe :: Register a -> Register a -> Label -> Code ()
jumpIfNe reg1 reg2 tgt = do
  issue $ JumpIfNe reg1 reg2 tgt

jumpIfGt :: Ordered a => Register a -> Register a -> Label -> Code ()
jumpIfGt reg1 reg2 tgt = do
  issue $ JumpIfGt reg1 reg2 tgt

jumpIfGe :: Ordered a => Register a -> Register a -> Label -> Code ()
jumpIfGe reg1 reg2 tgt = do
  issue $ JumpIfGe reg1 reg2 tgt

jumpIfLt :: Ordered a => Register a -> Register a -> Label -> Code ()
jumpIfLt reg1 reg2 tgt = do
  issue $ JumpIfLt reg1 reg2 tgt

jumpIfLe :: Ordered a => Register a -> Register a -> Label -> Code ()
jumpIfLe reg1 reg2 tgt = do
  issue $ JumpIfLe reg1 reg2 tgt

decrAndJumpIfNot0 :: Register 'Word -> Label -> Code ()
decrAndJumpIfNot0 reg tgt = do
  issue $ DecrAndJumpIfNot0 reg tgt

decrAndJumpIf0 :: Register 'Word -> Label -> Code ()
decrAndJumpIf0 reg tgt = do
  issue $ DecrAndJumpIf0 reg tgt

callFun_0_1 :: Register ('Fun '[ 'WordPtr ]) -> Register 'Word -> Code ()
callFun_0_1 fun args1 = do
  issue $ CallFun_0_1 fun args1

callFun_0_2 :: Register ('Fun '[ 'WordPtr,'WordPtr ]) -> Register 'Word -> Register 'Word -> Code ()
callFun_0_2 fun args1 args2 = do
  issue $ CallFun_0_2 fun args1 args2

callFun_1_1 :: Register ('Fun '[ 'Word,'WordPtr ]) -> Register 'Word -> Register 'Word -> Code ()
callFun_1_1 fun args1 args2 = do
  issue $ CallFun_1_1 fun args1 args2

callFun_1_0 :: Register ('Fun '[ 'Word ]) -> Register 'Word -> Code ()
callFun_1_0 fun args1 = do
  issue $ CallFun_1_0 fun args1

callFun_2_1 :: Register ('Fun '[ 'Word,'Word,'WordPtr ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_2_1 fun args1 args2 args3 = do
  issue $ CallFun_2_1 fun args1 args2 args3

callFun_2_0 :: Register ('Fun '[ 'Word,'Word ]) -> Register 'Word -> Register 'Word -> Code ()
callFun_2_0 fun args1 args2 = do
  issue $ CallFun_2_0 fun args1 args2

callFun_3_0 :: Register ('Fun '[ 'Word,'Word,'Word ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_3_0 fun args1 args2 args3 = do
  issue $ CallFun_3_0 fun args1 args2 args3

callFun_4_0 :: Register ('Fun '[ 'Word,'Word,'Word,'Word ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_4_0 fun args1 args2 args3 args4 = do
  issue $ CallFun_4_0 fun args1 args2 args3 args4

callFun_3_1 :: Register ('Fun '[ 'Word,'Word,'Word,'WordPtr ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_3_1 fun args1 args2 args3 args4 = do
  issue $ CallFun_3_1 fun args1 args2 args3 args4

callFun_5_0 :: Register ('Fun '[ 'Word,'Word,'Word,'Word,'Word ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_5_0 fun args1 args2 args3 args4 args5 = do
  issue $ CallFun_5_0 fun args1 args2 args3 args4 args5

callFun_5_1 :: Register ('Fun '[ 'Word,'Word,'Word,'Word,'Word,'WordPtr ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_5_1 fun args1 args2 args3 args4 args5 args6 = do
  issue $ CallFun_5_1 fun args1 args2 args3 args4 args5 args6

callFun_2_2 :: Register ('Fun '[ 'Word,'Word,'WordPtr,'WordPtr ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_2_2 fun args1 args2 args3 args4 = do
  issue $ CallFun_2_2 fun args1 args2 args3 args4

callFun_2_5 :: Register ('Fun '[ 'Word,'Word,'WordPtr,'WordPtr,'WordPtr,'WordPtr,'WordPtr ]) -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Register 'Word -> Code ()
callFun_2_5 fun args1 args2 args3 args4 args5 args6 args7 = do
  issue $ CallFun_2_5 fun args1 args2 args3 args4 args5 args6 args7

select :: Register 'Word -> [Label] -> Code ()
select sel tgts = do
  issue $ Select sel tgts

raise :: ByteString -> Code ()
raise msg = do
  msg_i <- literal msg
  issueEndBlock $ Raise msg_i

trace :: ByteString -> Code ()
trace msg = do
  msg_i <- literal msg
  issue $ Trace msg_i

traceReg :: ByteString -> Register 'Word -> Code ()
traceReg msg reg = do
  msg_i <- literal msg
  issue $ TraceReg msg_i reg

suspend :: Register 'Word -> Label -> Code ()
suspend unused cont = do
  issueEndBlock $ Suspend unused cont

ret :: Code ()
ret = do
  issueEndBlock $ Ret