[Driver] Fix wchar_t and wint_t definitions on Solaris

[ro]

Summary

Clang :: Sema/wchar.c has long been failing on Solaris:

error: 'error' diagnostics expected but not seen: 
  File /vol/llvm/src/clang/local/test/Sema/wchar.c Line 22: initializing wide char array with non-wide string literal
error: 'error' diagnostics seen but not expected: 
  File /vol/llvm/src/clang/local/test/Sema/wchar.c Line 20: array initializer must be an initializer list
  File /vol/llvm/src/clang/local/test/Sema/wchar.c Line 22: array initializer must be an initializer list

It turns out the definition is wrong, as can be seen in GCC's gcc/config/sol2.h:

/* wchar_t is called differently in <wchar.h> for 32 and 64-bit
   compilations.  This is called for by SCD 2.4.1, p. 6-83, Figure 6-65
   (32-bit) and p. 6P-10, Figure 6.38 (64-bit).  */

#undef WCHAR_TYPE
#define WCHAR_TYPE (TARGET_64BIT ? "int" : "long int")

The following patch implements this, and at the same time corrects the wint_t
definition which is the same:

/* Same for wint_t.  See SCD 2.4.1, p. 6-83, Figure 6-66 (32-bit).  There's
   no corresponding 64-bit definition, but this is what Solaris 8
   <iso/wchar_iso.h> uses.  */

#undef WINT_TYPE
#define WINT_TYPE (TARGET_64BIT ? "int" : "long int")

Clang :: Preprocessor/wchar_t.c needs to be adjusted to account for that, however
there's one regesssion in Clang :: Sema/format-strings.c I don't know how best to handle:

error: 'warning' diagnostics seen but not expected:
  File /vol/llvm/src/clang/local/test/Sema/format-strings.c Line 332: format specifies type 'int' but the argument has type 'wchar_t' (aka 'long')

void test_unicode_conversions(wchar_t *s) {
[...]
  printf("%c", s[0]);

and

  File /vol/llvm/src/clang/local/test/Sema/format-strings.c Line 405: format specifies type 'wint_t' (aka 'long') but the argument has type 'char'

void pr7981(wint_t c, wchar_t c2) {
  printf("%lc", c); // no-warning
  printf("%lc", 1.0); // expected-warning{{the argument has type 'double'}}
#if __WINT_WIDTH__ == 32
  printf("%lc", (char) 1); // no-warning
#else
  printf("%lc", (char) 1); // expected-warning{{the argument has type 'char'}}
#endif

WINT_WIDTH is 32 before and after my change, just the name of the type
changes.

Tested so far on i386-pc-solaris2.11. Will need testing on Solaris/SPARC and
Linux/x86_64 after the remaining test failure has been adressed.

[ro]

Ping? This has been a week, too. According to gcc/config headers, there are quite a number of targets with long int for wchar_t/wint_t,
so there should be some generic way to handle the Clang :: Sema/format-strings.c failure. Suggestions?

[efriedma]

For format-strings.c, I'm not really happy suggesting #if defined(__sun) && !defined(__LP64__), but I don't think the alternative is better. We could restrict the test so it doesn't run using a Solaris target triple, but we actually want coverage here: the difference in wint_t affects the semantics of "%lc", so we want some coverage of that path.

The other changes look okay.

[ro]

Adapt Sema/format-strings.c.

[ro]

In D62944#1542217, @efriedma wrote:

For format-strings.c, I'm not really happy suggesting #if defined(__sun) && !defined(__LP64__), but I don't think the alternative is better. We could restrict the test so it doesn't run using a Solaris target triple, but we actually want coverage here: the difference in wint_t affects the semantics of "%lc", so we want some coverage of that path.

Agreed. While gcc supports quite a number of targets with long int for wchar_t/wint_t, Solaris is the only one in clang. I've now adapted
the test accordingly. Should there be more in the future, we can look for a more generic solution.

Tested on i386-pc-solaris2.11, x86_64-pc-solaris2.11, and x86_64-pc-linux-gnu. Ok for trunk now?

[efriedma]

LGTM

cfe/trunk/lib/Basic/Targets/OSTargets.h

if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     if (this->HasFloat128)
       Builder.defineMacro("__FLOAT128__");
   }
 
 public:
   SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
-    // FIXME: WIntType should be SignedLong
+    if (this->PointerWidth == 64) {
+      this->WCharType = this->WIntType = this->SignedInt;
+    } else {
+      this->WCharType = this->WIntType = this->SignedLong;
+    }
     switch (Triple.getArch()) {
     default:
       break;
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       this->HasFloat128 = true;
       break;
     }

cfe/trunk/test/Preprocessor/wchar_t.c

 // RUN: %clang_cc1 -triple i386-pc-solaris -dM -E %s -o - | FileCheck %s -check-prefix CHECK-SOLARIS
 // CHECK-SOLARIS-DAG: #define __WCHAR_MAX__ 2147483647
-// CHECK-SOLARIS-DAG: #define __WCHAR_TYPE__ int
+// CHECK-SOLARIS-DAG: #define __WCHAR_TYPE__ long int
 // CHECK-SOLARIS-NOT: #define __WCHAR_UNSIGNED__ 0
 
+// RUN: %clang_cc1 -triple x86_64-pc-solaris -dM -E %s -o - | FileCheck %s -check-prefix CHECK-SOLARIS64
+// CHECK-SOLARIS64-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-SOLARIS64-DAG: #define __WCHAR_TYPE__ int
+// CHECK-SOLARIS64-NOT: #define __WCHAR_UNSIGNED__ 0
+
 // RUN: %clang_cc1 -triple avr-unknown-unknown -fwchar-type=int -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-AVR
 // CHECK-AVR-DAG: #define __WCHAR_MAX__ 32767
 // CHECK-AVR-DAG: #define __WCHAR_TYPE__ int
 // CHECK-AVR-NOT: #define __WCHAR_UNSIGNED__ 0
 
 // RUN: %clang_cc1 -triple arm-unknown-none-gnu -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM-APCS
 // CHECK-ARM-APCS-DAG: #define __WCHAR_MAX__ 2147483647
 // CHECK-ARM-APCS-DAG: #define __WCHAR_TYPE__ int

cfe/trunk/test/Sema/format-strings.c

 
 // Unicode test cases.  These are possibly specific to Mac OS X.  If so, they should
 // eventually be moved into a separate test.
 
 void test_unicode_conversions(wchar_t *s) {
   printf("%S", s); // no-warning
   printf("%s", s); // expected-warning{{format specifies type 'char *' but the argument has type 'wchar_t *'}}
   printf("%C", s[0]); // no-warning
+#if defined(__sun) && !defined(__LP64__)
+  printf("%c", s[0]); // expected-warning{{format specifies type 'int' but the argument has type 'wchar_t' (aka 'long')}}
+#else
   printf("%c", s[0]);
+#endif
   // FIXME: This test reports inconsistent results. On Windows, '%C' expects
   // 'unsigned short'.
   // printf("%C", 10);
   printf("%S", "hello"); // expected-warning{{but the argument has type 'char *'}}
 }
 
 // Mac OS X supports positional arguments in format strings.
 // This is an IEEE extension (IEEE Std 1003.1).
void bug7377_bad_length_mod_usage() {
   printf("%-+f", 1.23); // no-warning
 }
 
 // PR 7981 - handle '%lc' (wint_t)
 
 void pr7981(wint_t c, wchar_t c2) {
   printf("%lc", c); // no-warning
   printf("%lc", 1.0); // expected-warning{{the argument has type 'double'}}
-#if __WINT_WIDTH__ == 32
+#if __WINT_WIDTH__ == 32 && !(defined(__sun) && !defined(__LP64__))
   printf("%lc", (char) 1); // no-warning
 #else
   printf("%lc", (char) 1); // expected-warning{{the argument has type 'char'}}
 #endif
   printf("%lc", &c); // expected-warning{{the argument has type 'wint_t *'}}
   // If wint_t and wchar_t are the same width and wint_t is signed where
   // wchar_t is unsigned, an implicit conversion isn't possible.
 #if defined(__WINT_UNSIGNED__) || !defined(__WCHAR_UNSIGNED__) ||   \

cfe/trunk/test/Sema/wchar.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify
 // RUN: %clang_cc1 %s -fsyntax-only -fwchar-type=short -fno-signed-wchar -verify -DSHORT_WCHAR
 
 typedef __WCHAR_TYPE__ wchar_t;
 
 #if defined(_WIN32) || defined(_M_IX86) || defined(__CYGWIN__) \
  || defined(_M_X64) || defined(__ORBIS__) || defined(SHORT_WCHAR)
   #define WCHAR_T_TYPE unsigned short
 #elif defined(__arm) || defined(__aarch64__)
   #define WCHAR_T_TYPE unsigned int
 #elif defined(__sun)
+  #if defined(__LP64__)
+    #define WCHAR_T_TYPE int
+  #else
     #define WCHAR_T_TYPE long
+  #endif
 #else /* Solaris. */
   #define WCHAR_T_TYPE int
 #endif
  
 int check_wchar_size[sizeof(*L"") == sizeof(wchar_t) ? 1 : -1];
  
 void foo() {
   WCHAR_T_TYPE t1[] = L"x";
   wchar_t tab[] = L"x";
   WCHAR_T_TYPE t2[] = "x";     // expected-error {{initializing wide char array with non-wide string literal}}
   char t3[] = L"x";   // expected-error {{initializing char array with wide string literal}}
 }