copilot-c99: Pass output arrays as arguments to trigger argument functions. Refs #431.

Copilot's C99 backend generates incorrect code for trigger argument functions
that return constant arrays. Currently, the code will return a pointer to a
stack-allocated array. That memory may be used for something else after the
call to the trigger argument function, so it may be overwritten or freed by the
time the array is used. This may lead to the array holding incorrect values.

This is almost the same issue that was noticed in #386, except that #386 was
specifically about stream generator functions, whereas this issue is
specifically about trigger argument functions.

This commit changes array trigger argument functions so that they receive a
pointer to an array for the output argument. The part of the generated code
that applies the trigger argument functions has also been updated accordingly
such that when the argument has an array type, the output array is passed
directly as an argument (e.g., `f_arg0(temp_array)`) rather than being assigned
(e.g., `temp_array = f_arg0()`).

Because we pass output arrays directly to trigger argument functions, we no
longer have to have a special case in the code for declaring temporary
variables for output arrays as pointers (e.g., `int* temp_array;`). Instead, we
can declare these temporary variables directly as arrays (e.g., `int
temp_array[2];`). This makes the intent clearer and simplifies the
implementation in `copilot-c99`.

Author: RyanGlScott

copilot-c99/src/Copilot/Compile/C99/CodeGen.hs

@@ -250,22 +250,8 @@ mkStep cSettings streams triggers exts =
         aTmpDeclns = zipWith declare args aTempNames
           where
             declare :: UExpr -> C.Ident -> C.Decln
-            declare arg tmpVar =
-              C.VarDecln Nothing (tempType arg) tmpVar Nothing
-
-            -- Type of the temporary variable used to store values of the type
-            -- of a given expression.
-            tempType :: UExpr -> C.Type
-            tempType (UExpr { uExprType = ty }) =
-              case ty of
-                -- If a temporary variable is being used to store an array,
-                -- declare the type of the temporary variable as a pointer, not
-                -- an array. The problem with declaring it as an array is that
-                -- the `arg` function will return a pointer, not an array, and
-                -- C doesn't make it easy to cast directly from an array to a
-                -- pointer.
-                Array ty' -> C.Ptr $ transType ty'
-                _         -> transType ty
+            declare (UExpr { uExprType = ty }) tmpVar =
+              C.VarDecln Nothing (transType ty) tmpVar Nothing
 
         triggerCheckStmt :: C.Stmt
         triggerCheckStmt = C.If guard' fireTrigger
@@ -283,13 +269,21 @@ mkStep cSettings streams triggers exts =
               where
                 -- List of assignments of values of temporary variables.
                 argAssigns :: [C.Expr]
-                argAssigns = zipWith assign aTempNames args'
+                argAssigns = zipWith3 assign aTempNames aArgNames args
 
-                assign :: C.Ident -> C.Expr -> C.Expr
-                assign aTempName = C.AssignOp C.Assign (C.Ident aTempName)
+                assign :: C.Ident -> C.Ident -> UExpr -> C.Expr
+                assign aTempName aArgName (UExpr { uExprType = ty }) =
+                  case ty of
+                    Array _ -> argCall aArgName [C.Ident aTempName]
+                    _       -> C.AssignOp C.Assign
+                                          (C.Ident aTempName)
+                                          (argCall aArgName [])
+
+                aArgNames :: [C.Ident]
+                aArgNames = take (length args) (argNames name)
 
-                args'         = take (length args) (map argCall (argNames name))
-                argCall name' = C.Funcall (C.Ident name') []
+                argCall :: C.Ident -> [C.Expr] -> C.Expr
+                argCall name' = C.Funcall (C.Ident name')
 
                 -- Build an expression to pass a temporary variable as argument
                 -- to a trigger handler.

copilot-c99/src/Copilot/Compile/C99/Compile.hs

@@ -130,7 +130,10 @@ compileC cSettings spec = C.TransUnit declns funs
             argDefs  = zipWith argGen (argNames name) args
 
             argGen :: String -> UExpr -> C.FunDef
-            argGen argName (UExpr ty expr) = mkGenFun argName expr ty
+            argGen argName (UExpr ty expr) =
+              case ty of
+                Array _ -> mkGenFunArray argName (argName ++ "_output") expr ty
+                _       -> mkGenFun argName expr ty
 
 -- | Generate the .h file from a 'Spec'.
 compileH :: CSettings -> Spec -> C.TransUnit