Add C11 generic support

Makefile.in

@@ -296,7 +296,7 @@ clean: $(CILLYDIR)/Makefile
 
 .PHONY: test
 test:
-	cd test; CC=@CC@ ./testcil -r --regrtest || { cat cil.log; exit 1; }
+	cd test; CC=@CC@ ./testcil -r --regrtest || { echo "Check test/cil.log for raw output"; exit 1; }
 
 ########################################################################
 

src/frontc/cabs.ml

@@ -80,6 +80,7 @@ type typeSpecifier = (* Merge all specifiers into one type *)
   | Tenum of string * enum_item list option * attribute list
   | TtypeofE of expression                      (* GCC __typeof__ *)
   | TtypeofT of specifier * decl_type       (* GCC __typeof__ *)
+  | Tdefault (** "default" in generic associations *)
 
 and storage =
     NO_STORAGE | AUTO | STATIC | EXTERN | REGISTER
@@ -281,6 +282,7 @@ and expression =
   | MEMBEROFPTR of expression * string
   | GNU_BODY of block
   | EXPR_PATTERN of string     (* pattern variable, and name *)
+  | GENERIC of expression * ((specifier * expression) list)
 
 and constant =
   | CONST_INT of string   (* the textual representation *)

src/frontc/cabs2cil.ml

@@ -1589,7 +1589,38 @@ type combineWhat =
  * that are known to be equal *)
 let isomorphicStructs : (string * string, bool) H.t = H.create 15
 
+(** [typeAttrs], which doesn't add inner attributes. *)
+let typeAttrsOuter = function
+  | TVoid a -> a
+  | TInt (_, a) -> a
+  | TFloat (_, a) -> a
+  | TNamed (_, a) -> a
+  | TPtr (_, a) -> a
+  | TArray (_, _, a) -> a
+  | TComp (_, a) -> a
+  | TEnum (_, a) -> a
+  | TFun (_, _, _, a) -> a
+  | TBuiltin_va_list a -> a
+
+let partitionQualifierAttributes al =
+  List.partition (function
+      | Attr (("const" | "volatile" | "restrict"), []) -> true
+      | _ -> false
+    ) al
+
+let removeOuterQualifierAttributes t =
+  let a = typeAttrsOuter t in
+  let (_, a') = partitionQualifierAttributes a in
+  setTypeAttrs t a'
+
 let rec combineTypes (what: combineWhat) (oldt: typ) (t: typ) : typ =
+  let (oldq, olda) = partitionQualifierAttributes (typeAttrsOuter oldt) in
+  let (q, a) = partitionQualifierAttributes (typeAttrsOuter t) in
+  if oldq <> q then
+    raise (Failure "different type qualifiers")
+  else if q <> [] then
+    combineTypes what (setTypeAttrs oldt olda) (setTypeAttrs t a)
+  else
   match oldt, t with
   | TVoid olda, TVoid a -> TVoid (cabsAddAttributes olda a)
   | TInt (oldik, olda), TInt (ik, a) ->
@@ -1762,7 +1793,7 @@ let rec combineTypes (what: combineWhat) (oldt: typ) (t: typ) : typ =
                    combineTypes
                      (if what = CombineFundef then
                        CombineFunarg else CombineOther)
-                     ot' at
+                     (removeOuterQualifierAttributes ot') (removeOuterQualifierAttributes at)
                  in
                  let a = addAttributes oa aa in
                  (n, t, a))
@@ -2458,6 +2489,7 @@ let rec doSpecList (suggestedAnonName: string) (* This string will be part of
     | [A.Tfloat128] -> TFloat(FLongDouble, []) (* TODO: Correct? *)
 
      (* Now the other type specifiers *)
+    | [A.Tdefault] -> E.s (error "Default outside generic associations")
     | [A.Tnamed n] -> begin
         if n = "__builtin_va_list" &&
           !Machdep.theMachine.Machdep.__builtin_va_list then begin
@@ -4844,6 +4876,38 @@ and doExp (asconst: bool)   (* This expression is used as a constant *)
 
     | A.EXPR_PATTERN _ -> E.s (E.bug "EXPR_PATTERN in cabs2cil input")
 
+    | A.GENERIC (e, al) ->
+        let is_default = function
+          | [SpecType Tdefault] -> true (* exactly matches cparser *)
+          | _ -> false
+        in
+        let (al_default, al_nondefault) = List.partition (fun (at, _) -> is_default at) al in
+
+        let typ_compatible t1 t2 =
+          match combineTypes CombineOther t1 t2 with (* combineTypes seems to do "compatible types" check *)
+          | _ -> true
+          | exception (Failure _) -> false
+        in
+        (* cppreference mentions "lvalue conversions" on e before compatibility: https://en.cppreference.com/w/c/language/generic.
+           C11 standard section 6.5.1.1.3 does not mention anything.
+           TODO: Which is it and does doExp already do this? *)
+        let (_, _, e_typ) = doExp false e (AExp None) in
+        let e_typ = removeOuterQualifierAttributes e_typ in
+        let al_compatible = List.filter (fun (at, _) -> typ_compatible e_typ (doOnlyType at JUSTBASE)) al_nondefault in
+
+        (* TODO: error when multiple compatible associations or defaults even when unused? *)
+
+        begin match al_compatible with
+          | [(_, ae)] -> doExp false ae (AExp None)
+          | [] ->
+            begin match al_default with
+              | [(_, ae)] -> doExp false ae (AExp None)
+              | [] -> E.s (error "No compatible associations or default in generic")
+              | _ -> E.s (error "Multiple defaults in generic")
+            end
+          | _ -> E.s (error "Multiple compatible associations in generic")
+        end
+
   with e when continueOnError -> begin
     (*ignore (E.log "error in doExp (%s)" (Printexc.to_string e));*)
     E.hadErrors := true;

src/frontc/cabsvisit.ml

@@ -538,6 +538,16 @@ and childrenExpression vis e =
       let b' = visitCabsBlock vis b in
       if b' != b then GNU_BODY b' else e
   | EXPR_PATTERN _ -> e
+  | GENERIC (e, al) ->
+      let e' = ve e in
+      let al' = mapNoCopy (fun ((at, ae) as a) ->
+          let at' = visitCabsSpecifier vis at in
+          let ae' = ve ae in
+          if at' != at || ae' != ae then (at', ae') else a
+        ) al
+      in
+      if e' != e || al' != al then GENERIC (e', al') else e
+
 
 and visitCabsInitExpression vis (ie: init_expression) : init_expression =
   doVisit vis vis#vinitexpr childrenInitExpression ie

src/frontc/clexer.mll

@@ -225,6 +225,7 @@ let init_lexicon _ =
                          THREAD loc
                        else
                          IDENT ("__thread", loc));
+      ("_Generic", fun loc -> GENERIC loc);
     ]
 
 (* Mark an identifier as a type name. The old mapping is preserved and will

src/frontc/cparser.mly

@@ -257,6 +257,7 @@ let transformOffsetOf (speclist, dtype) member =
 %token EOF
 %token<Cabs.cabsloc> CHAR INT BOOL DOUBLE FLOAT VOID INT64 INT32
 %token<Cabs.cabsloc> INT128 FLOAT128 COMPLEX /* C99 */
+%token<Cabs.cabsloc> GENERIC /* C11 */
 %token<Cabs.cabsloc> ENUM STRUCT TYPEDEF UNION
 %token<Cabs.cabsloc> SIGNED UNSIGNED LONG SHORT
 %token<Cabs.cabsloc> VOLATILE EXTERN STATIC CONST RESTRICT AUTO REGISTER
@@ -475,8 +476,19 @@ primary_expression:                     /*(* 6.5.1. *)*/
      /*(* Next is Scott's transformer *)*/
 |               AT_EXPR LPAREN IDENT RPAREN         /* expression pattern variable */
                          { EXPR_PATTERN(fst $3), $1 }
+|   GENERIC LPAREN assignment_expression COMMA generic_assoc_list RPAREN {GENERIC ((fst $3), $5), $1}
 ;
 
+/* (specifier, expression) list */
+generic_assoc_list: 
+| generic_association {[$1]}
+| generic_assoc_list COMMA generic_association {$3 :: $1}
+
+/* specifier, expression */
+generic_association:
+| type_name COLON assignment_expression {fst $1, fst $3}
+| DEFAULT COLON assignment_expression {[SpecType(Tdefault)], fst $3}
+
 postfix_expression:                     /*(* 6.5.2 *)*/
 |               primary_expression
                         { $1 }

src/frontc/cprint.ml

@@ -196,6 +196,7 @@ and print_type_spec = function
       (print_enum_items enum_items)
   | TtypeofE e -> printl ["__typeof__";"("]; print_expression e; print ") "
   | TtypeofT (s,d) -> printl ["__typeof__";"("]; print_onlytype (s, d); print ") "
+  | Tdefault -> print "default " (* TODO: is this right? *)
 
 
 (* print "struct foo", but with specified keyword and a list of
@@ -403,6 +404,7 @@ and get_operator exp =
   | TYPE_SIZEOF _ -> ("", 16)
   | EXPR_ALIGNOF exp -> ("", 16)
   | TYPE_ALIGNOF _ -> ("", 16)
+  | GENERIC _ -> ("", 16) (* TODO: is this right? *)
   | IMAG exp -> ("", 16)
   | REAL exp -> ("", 16)
   | CLASSIFYTYPE exp -> ("", 16)
@@ -538,6 +540,21 @@ and print_expression_level (lvl: int) (exp : expression) =
       printl ["__alignof__";"("];
       print_onlytype (bt, dt);
       print ")"
+  | GENERIC (exp, lst) -> 
+      (* TODO: is this right? *)
+      let print_generic_list l =
+        match l with 
+        [] -> ()
+        | (s, e) :: tl ->
+          print ", ";
+          print_onlytype (s, JUSTBASE); 
+          print ": ";
+          print_expression_level 0 e;
+      in
+      printl ["_Generic";"("];
+      print_expression_level 0 exp;
+      print_generic_list lst;
+      print ")"
   | IMAG exp ->
       printl ["__imag__";"("];
       print_expression_level 0 exp;

test/Makefile

@@ -193,6 +193,12 @@ testrunc99/% : $(SMALL1)/%.c
 	cd $(SMALL1); ./$*.exe
 	echo SUCCESS
 
+testrunc11/% : $(SMALL1)/%.c
+	cd $(SMALL1); $(CILLY) --nomerge  --commPrintLn  \
+	       $(CFLAGS) -std=c11 $(EXEOUT)$*.exe $*.c -lm
+	cd $(SMALL1); ./$*.exe
+	echo SUCCESS
+
 testrungcc/% : $(SMALL1)/%.c mustbegcc
 	cd $(SMALL1); $(CILLY) --nomerge  --commPrintLn  \
 	       $(CFLAGS) $(EXEOUT)$*.exe $*.c

test/small1/c11-generic.c

@@ -0,0 +1,27 @@
+#include "testharness.h"
+#define type1(x) _Generic((x), char: 1, unsigned int:2, default:0)
+#define type2(x) _Generic((x), char: 1, unsigned int:2, const int:3, default:0)
+
+// This fails to compile but is perfectly legal, since int and const int are not compatible
+#define type3(x) _Generic((x), int:1, const int:2, default:0)
+
+int main() {
+    unsigned char v_uchar;
+    char v_char;
+    int v_int;
+    const int v_intconst;
+
+    if(type1(v_int) != 0) { E(1); }
+    if(type1(v_uchar) != 0) { E(2); }
+    if(type1(v_char) != 1) { E(3); }
+
+    if(type2(v_int) != 0) { E(4); } // This fails but should succeed
+    if(type2(v_intconst) != 0) { E(5); } // This fails but should succeed
+    if(type3(v_int) != 1) { E(6); }
+    if(type3(v_intconst) != 1) { E(7); }
+
+    if(type3((const int)v_int) != 1) { E(8); }
+    if(type3((const int)v_intconst) != 1) { E(9); }
+
+    SUCCESS;
+}

test/testcil.pl

@@ -411,7 +411,6 @@ sub addToGroup {
 addTest("testrun/lval1 _GNUCC=1");
 #MIA: addTest("test/bind2 EXTRAARGS=--allowInlineAssembly");
 #addToGroup("test/bind2", "slow");
-addTest("testrun/decl1 _GNUCC=1");
 addTest("testrun/addr-array");
 addTest("testrun/addr-string");
 addTest("combine1 ");
@@ -713,6 +712,7 @@ sub addToGroup {
 addTest("combinec99inline");
 addBadComment("combinec99inline", "C99 inline semantic not fully supported.");
 
+addTest("testrunc11/c11-generic");
 
 # ---------------- c-torture -------------
 ## if we have the c-torture tests add them