Begin implementing Plan 9 C extensions.

[pcc]

Summary

This makes a start on implementing a number of extensions provided by the Plan
9 C compiler, from which Go's "cc" C compiler is derived. These extensions
are required for building some parts of the Go standard library.

This patch introduces the -fplan9-extensions flag and causes it to enable
an extension which allows typedefs to be declared multiple times.

[thakis]

Is there a list of extensions you want to support?

Could the go standard library not use plan9 extensions, if it's interested
in being compiled with more than 1 compiler?

[ruiu]

Go will be rewritten in Go after Go 1.3 release which is planned on June 1.
I don't know the time frame, if Go 1.4 is coming soon, you don't need to
implement Plan 9 C extensions in Clang, do you?

[• alexchandel]

This is probably a necessary step to targeting Plan 9 as well.

[• arthur.j.odwyer]

lib/Sema/SemaDecl.cpp

1772

"as do C11 and Plan 9"

[• alexchandel]

There are a few other extensions that should be supported. Plan9-style C also supports accessing anonymous structure and union members by type name iff they are declared using a typedef name. For example, p.Point in:

typedef struct Point
{
    int x, y;
} Point;

struct
{
    int type;
    Point;
} p;

void take(Point* point);

It also supports using the address of the parent struct without a cast anywhere that the address of the anonymous member is used, as in take(p). The compiler should automatically promote the type, adjust the address, and suppress the otherwise germane [-Wincompatible-pointer-types] warning.

I'm not sure whether these two extensions are leveraged in the Go 1.3 compiler, but they are frequently used in Plan 9 itself, and are necessary for compiling it.

[• alexchandel]

any updates?

[rsmith]

If someone wants to pick this up and run with it, this patch is fine as a starting point (though will need to be rebased).

include/clang/Basic/LangOptions.def

 #endif
 
 LANGOPT(C99               , 1, 0, "C99")
 LANGOPT(C11               , 1, 0, "C11")
 LANGOPT(MSVCCompat        , 1, 0, "Microsoft Visual C++ full compatibility mode")
 LANGOPT(MicrosoftExt      , 1, 0, "Microsoft C++ extensions")
 LANGOPT(AsmBlocks         , 1, 0, "Microsoft inline asm blocks")
 LANGOPT(Borland           , 1, 0, "Borland extensions")
+LANGOPT(Plan9Ext          , 1, 0, "Plan 9 extensions")
 LANGOPT(CPlusPlus         , 1, 0, "C++")
 LANGOPT(CPlusPlus11       , 1, 0, "C++11")
 LANGOPT(CPlusPlus1y       , 1, 0, "C++1y")
 LANGOPT(ObjC1             , 1, 0, "Objective-C 1")
 LANGOPT(ObjC2             , 1, 0, "Objective-C 2")
 BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0,
                "Objective-C auto-synthesized properties")
 BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0,

include/clang/Driver/Options.td

def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Recognize and construct Pascal-style string literals">;
 def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Override the default ABI to return all structs on the stack">;
 def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>;
 def fpic : Flag<["-"], "fpic">, Group<f_Group>;
 def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>;
 def fpie : Flag<["-"], "fpie">, Group<f_Group>;
 def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
+def fplan9_extensions : Flag<["-"], "fplan9-extensions">, Group<f_Group>, Flags<[CC1Option]>;
+def fno_plan9_extensions : Flag<["-"], "fno-plan9-extensions">, Group<f_Group>;
 def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>;
 def fprofile_generate : Flag<["-"], "fprofile-generate">, Group<f_Group>;
 def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
 def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>;
 def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Override the default ABI to return small structs in registers">;
 def frtti : Flag<["-"], "frtti">, Group<f_Group>;
 def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;

lib/Driver/Tools.cpp

   }
 
 
   // -fno-borland-extensions is default.
   if (Args.hasFlag(options::OPT_fborland_extensions,
                    options::OPT_fno_borland_extensions, false))
     CmdArgs.push_back("-fborland-extensions");
 
+  // -fno-plan9-extensions is default.
+  if (Args.hasFlag(options::OPT_fplan9_extensions,
+                   options::OPT_fno_plan9_extensions, false))
+    CmdArgs.push_back("-fplan9-extensions");
+
   // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
   // needs it.
   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
                    options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
     CmdArgs.push_back("-fdelayed-template-parsing");
 
   // -fgnu-keywords default varies depending on language; only pass if
   // specified.

lib/Frontend/CompilerInvocation.cpp

Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
                                    Opts.DollarIdents);
   Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
   Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
   Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
   Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
   Opts.MSCVersion = getLastArgIntValue(Args, OPT_fmsc_version, 0, Diags);
   Opts.VtorDispMode = getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags);
   Opts.Borland = Args.hasArg(OPT_fborland_extensions);
+  Opts.Plan9Ext = Args.hasArg(OPT_fplan9_extensions);
   Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
   Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
                                    Opts.ConstStrings);
   if (Args.hasArg(OPT_fno_lax_vector_conversions))
     Opts.LaxVectorConversions = 0;
   if (Args.hasArg(OPT_fno_threadsafe_statics))
     Opts.ThreadsafeStatics = 0;
   Opts.Exceptions = Args.hasArg(OPT_fexceptions);

lib/Sema/SemaDecl.cpp

if (!isa<TypedefNameDecl>(Old))
       return;
 
     Diag(New->getLocation(), diag::err_redefinition)
       << New->getDeclName();
     Diag(Old->getLocation(), diag::note_previous_definition);
     return New->setInvalidDecl();
   }
 
-  // Modules always permit redefinition of typedefs, as does C11.
-  if (getLangOpts().Modules || getLangOpts().C11)
+  // Modules always permit redefinition of typedefs, as does C11 and Plan 9.
+  if (getLangOpts().Modules || getLangOpts().C11 || getLangOpts().Plan9Ext)
     return;
   
   // If we have a redefinition of a typedef in C, emit a warning.  This warning
   // is normally mapped to an error, but can be controlled with
   // -Wtypedef-redefinition.  If either the original or the redefinition is
   // in a system header, don't emit this for compatibility with GCC.
   if (getDiagnostics().getSuppressSystemWarnings() &&
       (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||

test/Sema/c11-typedef-redef.c

 // RUN: %clang_cc1 -std=c11 %s -verify
+// RUN: %clang_cc1 -fplan9-extensions %s -verify
 
 typedef int type;
 typedef type type;
 typedef int type;
 
 void f(int N) {
   typedef int type2;
   typedef type type2;