[WebAssembly] clang-format (NFC)

[aheejin]

Summary

This patch runs clang-format on all wasm-only files.

[aheejin]

Ping! Can we land this because this is fairly small?

[aheejin]

Ping pong

lib/Driver/ToolChains/WebAssembly.h

private:
   bool UseObjCMixedDispatch() const override;
   bool isPICDefault() const override;
   bool isPIEDefault() const override;
   bool isPICDefaultForced() const override;
   bool IsIntegratedAssemblerDefault() const override;
   bool hasBlocksRuntime() const override;
   bool SupportsProfiling() const override;
   bool HasNativeLLVMSupport() const override;
-  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
-                             llvm::opt::ArgStringList &CC1Args,
-                             Action::OffloadKind DeviceOffloadKind) const override;
+  void
+  addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
   RuntimeLibType GetDefaultRuntimeLibType() const override;
   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
-  void AddClangSystemIncludeArgs(
-      const llvm::opt::ArgList &DriverArgs,
+  void
+  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
   void AddClangCXXStdlibIncludeArgs(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
   std::string getThreadModel() const override;
 
   const char *getDefaultLinker() const override { return "wasm-ld"; }

lib/Driver/ToolChains/WebAssembly.cpp

 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 wasm::Linker::Linker(const ToolChain &TC)
     : GnuTool("wasm::Linker", "lld", TC) {}
 
-bool wasm::Linker::isLinkJob() const {
-  return true;
-}
+bool wasm::Linker::isLinkJob() const { return true; }
 
-bool wasm::Linker::hasIntegratedCPP() const {
-  return false;
-}
+bool wasm::Linker::hasIntegratedCPP() const { return false; }
 
 void wasm::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                 const InputInfo &Output,
                                 const InputInfoList &Inputs,
                                 const ArgList &Args,
                                 const char *LinkingOutput) const {
 
   const ToolChain &ToolChain = getToolChain();
void wasm::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   C.addCommand(llvm::make_unique<Command>(JA, *this, Linker, CmdArgs, Inputs));
 }
 
 WebAssembly::WebAssembly(const Driver &D, const llvm::Triple &Triple,
                          const llvm::opt::ArgList &Args)
     : ToolChain(D, Triple, Args) {
 
   assert(Triple.isArch32Bit() != Triple.isArch64Bit());
 
   getProgramPaths().push_back(getDriver().getInstalledDir());
 
   getFilePaths().push_back(getDriver().SysRoot + "/lib");
 }
 
if (DriverArgs.hasFlag(clang::driver::options::OPT_fuse_init_array,
                          options::OPT_fno_use_init_array, true))
     CC1Args.push_back("-fuse-init-array");
 }
 
 ToolChain::RuntimeLibType WebAssembly::GetDefaultRuntimeLibType() const {
   return ToolChain::RLT_CompilerRT;
 }
 
-ToolChain::CXXStdlibType WebAssembly::GetCXXStdlibType(const ArgList &Args) const {
+ToolChain::CXXStdlibType
+WebAssembly::GetCXXStdlibType(const ArgList &Args) const {
   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
     StringRef Value = A->getValue();
     if (Value != "libc++")
       getDriver().Diag(diag::err_drv_invalid_stdlib_name)
           << A->getAsString(Args);
   }
   return ToolChain::CST_Libcxx;
 }

test/CodeGen/builtins-wasm.c

 // RUN: %clang_cc1 -triple wasm32-unknown-unknown -O3 -emit-llvm -o - %s \
 // RUN:   | FileCheck %s -check-prefix=WEBASSEMBLY32
 // RUN: %clang_cc1 -triple wasm64-unknown-unknown -O3 -emit-llvm -o - %s \
 // RUN:   | FileCheck %s -check-prefix=WEBASSEMBLY64
 
 __SIZE_TYPE__ f0(void) {
   return __builtin_wasm_memory_size(0);
   // WEBASSEMBLY32: call {{i.*}} @llvm.wasm.memory.size.i32(i32 0)
   // WEBASSEMBLY64: call {{i.*}} @llvm.wasm.memory.size.i64(i32 0)
 }
 
 __SIZE_TYPE__ f1(__SIZE_TYPE__ delta) {
   return __builtin_wasm_memory_grow(0, delta);
   // WEBASSEMBLY32: call i32 @llvm.wasm.memory.grow.i32(i32 0, i32 %{{.*}})
   // WEBASSEMBLY64: call i64 @llvm.wasm.memory.grow.i64(i32 0, i64 %{{.*}})
 }
 
 __SIZE_TYPE__ f2(void) {
   return __builtin_wasm_mem_size(0);
   // WEBASSEMBLY32: call {{i.*}} @llvm.wasm.mem.size.i32(i32 0)
   // WEBASSEMBLY64: call {{i.*}} @llvm.wasm.mem.size.i64(i32 0)
 }
 
 __SIZE_TYPE__ f3(__SIZE_TYPE__ delta) {
   return __builtin_wasm_mem_grow(0, delta);
   // WEBASSEMBLY32: call i32 @llvm.wasm.mem.grow.i32(i32 0, i32 %{{.*}})
   // WEBASSEMBLY64: call i64 @llvm.wasm.mem.grow.i64(i32 0, i64 %{{.*}})
 }
 
 __SIZE_TYPE__ f4(void) {
   return __builtin_wasm_current_memory();
   // WEBASSEMBLY32: call {{i.*}} @llvm.wasm.current.memory.i32()
   // WEBASSEMBLY64: call {{i.*}} @llvm.wasm.current.memory.i64()
 }
 
 __SIZE_TYPE__ f5(__SIZE_TYPE__ delta) {
   return __builtin_wasm_grow_memory(delta);
   // WEBASSEMBLY32: call i32 @llvm.wasm.grow.memory.i32(i32 %{{.*}})
   // WEBASSEMBLY64: call i64 @llvm.wasm.grow.memory.i64(i64 %{{.*}})
 }
 
 void f6(unsigned int tag, void *obj) {
   return __builtin_wasm_throw(tag, obj);
   // WEBASSEMBLY32: call void @llvm.wasm.throw(i32 %{{.*}}, i8* %{{.*}})
   // WEBASSEMBLY64: call void @llvm.wasm.throw(i32 %{{.*}}, i8* %{{.*}})
 }
 
 void f7(void) {
   return __builtin_wasm_rethrow();
   // WEBASSEMBLY32: call void @llvm.wasm.rethrow()
   // WEBASSEMBLY64: call void @llvm.wasm.rethrow()
 }
 
 int f8(int *addr, int expected, long long timeout) {
   return __builtin_wasm_atomic_wait_i32(addr, expected, timeout);
   // WEBASSEMBLY32: call i32 @llvm.wasm.atomic.wait.i32(i32* %{{.*}}, i32 %{{.*}}, i64 %{{.*}})
   // WEBASSEMBLY64: call i32 @llvm.wasm.atomic.wait.i32(i32* %{{.*}}, i32 %{{.*}}, i64 %{{.*}})
 }
 
 int f9(long long *addr, long long expected, long long timeout) {
   return __builtin_wasm_atomic_wait_i64(addr, expected, timeout);
   // WEBASSEMBLY32: call i32 @llvm.wasm.atomic.wait.i64(i64* %{{.*}}, i64 %{{.*}}, i64 %{{.*}})
   // WEBASSEMBLY64: call i32 @llvm.wasm.atomic.wait.i64(i64* %{{.*}}, i64 %{{.*}}, i64 %{{.*}})
 }
 
 unsigned int f10(int *addr, int count) {
   return __builtin_wasm_atomic_notify(addr, count);
   // WEBASSEMBLY32: call i32 @llvm.wasm.atomic.notify(i32* %{{.*}}, i32 %{{.*}})
   // WEBASSEMBLY64: call i32 @llvm.wasm.atomic.notify(i32* %{{.*}}, i32 %{{.*}})
 }

test/CodeGen/wasm-arguments.c

 // WEBASSEMBLY32: define void @f5(i8 signext %a, i16 signext %b)
 // WEBASSEMBLY64: define void @f5(i8 signext %a, i16 signext %b)
 void f5(char a, short b) {}
 
 // WEBASSEMBLY32: define void @f6(i8 zeroext %a, i16 zeroext %b)
 // WEBASSEMBLY64: define void @f6(i8 zeroext %a, i16 zeroext %b)
 void f6(unsigned char a, unsigned short b) {}
 
-
 enum my_enum {
   ENUM1,
   ENUM2,
   ENUM3,
 };
 // Enums should be treated as the underlying i32.
 // WEBASSEMBLY32: define void @f7(i32 %a)
 // WEBASSEMBLY64: define void @f7(i32 %a)

test/CodeGen/wasm-varargs.c

 // CHECK:   store i64 [[R4]], i64* [[V]], align 8
 // CHECK:   [[VA2:%[^,=]+]] = bitcast i8** [[VA]] to i8*
 // CHECK:   call void @llvm.va_end(i8* [[VA2]])
 // CHECK:   [[R5:%[^,=]+]] = load i64, i64* [[V]], align 8
 // CHECK:   ret i64 [[R5]]
 // CHECK: }
 
 struct S {
-    int x;
-    int y;
-    int z;
 };
 
 struct S test_struct(char *fmt, ...) {
   va_list va;
 
   va_start(va, fmt);
   struct S v = va_arg(va, struct S);
   va_end(va);

test/CodeGenCXX/static-init-wasm.cpp

 // WEBASSEMBLY64-NEXT:  br i1 %[[R2]], label %[[CHECK:.+]], label %[[END:.+]],
 // WEBASSEMBLY64:       [[CHECK]]
 // WEBASSEMBLY64:       call i32 @__cxa_guard_acquire
 // WEBASSEMBLY64:       [[END]]
 // WEBASSEMBLY64:       call void @__cxa_guard_release
 
 // Test various aspects of static constructor calls.
 struct A {
-    A();
 };
 
 A theA;
 
 // WEBASSEMBLY32: define internal void @__cxx_global_var_init() #3 {
 // WEBASSEMBLY32: call %struct.A* @_ZN1AC1Ev(%struct.A* @theA)
 // WEBASSEMBLY32: define internal void @_GLOBAL__sub_I_static_init_wasm.cpp() #3 {
 // WEBASSEMBLY32: call void @__cxx_global_var_init()
 //
 // WEBASSEMBLY64: define internal void @__cxx_global_var_init() #3 {
 // WEBASSEMBLY64: call %struct.A* @_ZN1AC1Ev(%struct.A* @theA)
 // WEBASSEMBLY64: define internal void @_GLOBAL__sub_I_static_init_wasm.cpp() #3 {
 // WEBASSEMBLY64: call void @__cxx_global_var_init()

test/CodeGenCXX/wasm-args-returns.cpp

 // RUN: %clang_cc1 -O1 -triple wasm32-unknown-unknown -emit-llvm -o - %s \
 // RUN:   | FileCheck %s
 // RUN: %clang_cc1 -O1 -triple wasm64-unknown-unknown -emit-llvm -o - %s \
 // RUN:   | FileCheck %s
 
-#define concat_(x, y) x ## y
+#define concat_(x, y) x##y
 #define concat(x, y) concat_(x, y)
 
-#define test(T) \
+#define test(T)                \
   T forward(T x) { return x; } \
-  void use(T x); \
-  T concat(def_, T)(void); \
+  void use(T x);               \
+  T concat(def_, T)(void);     \
   void concat(test_, T)(void) { use(concat(def_, T)()); }
 
-struct one_field { double d; };
+struct one_field {
+  double d;
+};
 test(one_field);
 // CHECK: define double @_Z7forward9one_field(double returned %{{.*}})
 //
 // CHECK: define void @_Z14test_one_fieldv()
 // CHECK: %[[call:.*]] = tail call double @_Z13def_one_fieldv()
 // CHECK: tail call void @_Z3use9one_field(double %[[call]])
 // CHECK: ret void
 //
 // CHECK: declare void @_Z3use9one_field(double)
 // CHECK: declare double @_Z13def_one_fieldv()
 
-struct two_fields { double d, e; };
+struct two_fields {
+  double d, e;
+};
 test(two_fields);
 // CHECK: define void @_Z7forward10two_fields(%struct.two_fields* noalias nocapture sret %{{.*}}, %struct.two_fields* byval nocapture readonly align 8 %{{.*}})
 //
 // CHECK: define void @_Z15test_two_fieldsv()
 // CHECK: %[[tmp:.*]] = alloca %struct.two_fields, align 8
 // CHECK: call void @_Z14def_two_fieldsv(%struct.two_fields* nonnull sret %[[tmp]])
 // CHECK: call void @_Z3use10two_fields(%struct.two_fields* byval nonnull align 8 %[[tmp]])
 // CHECK: ret void
 //
 // CHECK: declare void @_Z3use10two_fields(%struct.two_fields* byval align 8)
 // CHECK: declare void @_Z14def_two_fieldsv(%struct.two_fields* sret)
 
 struct copy_ctor {
-    double d;
-    copy_ctor(copy_ctor const&);
+  copy_ctor(copy_ctor const &);
 };
 test(copy_ctor);
 // CHECK: define void @_Z7forward9copy_ctor(%struct.copy_ctor* noalias sret %{{.*}}, %struct.copy_ctor* %{{.*}})
 //
 // CHECK: declare %struct.copy_ctor* @_ZN9copy_ctorC1ERKS_(%struct.copy_ctor* returned, %struct.copy_ctor* dereferenceable(8))
 //
 // CHECK: define void @_Z14test_copy_ctorv()
 // CHECK: %[[tmp:.*]] = alloca %struct.copy_ctor, align 8
 // CHECK: call void @_Z13def_copy_ctorv(%struct.copy_ctor* nonnull sret %[[tmp]])
 // CHECK: call void @_Z3use9copy_ctor(%struct.copy_ctor* nonnull %[[tmp]])
 // CHECK: ret void
 //
 // CHECK: declare void @_Z3use9copy_ctor(%struct.copy_ctor*)
 // CHECK: declare void @_Z13def_copy_ctorv(%struct.copy_ctor* sret)
 
 struct __attribute__((aligned(16))) aligned_copy_ctor {
-    double d, e;
-    aligned_copy_ctor(aligned_copy_ctor const&);
+  aligned_copy_ctor(aligned_copy_ctor const &);
 };
 test(aligned_copy_ctor);
 // CHECK: define void @_Z7forward17aligned_copy_ctor(%struct.aligned_copy_ctor* noalias sret %{{.*}}, %struct.aligned_copy_ctor* %{{.*}})
 //
 // CHECK: declare %struct.aligned_copy_ctor* @_ZN17aligned_copy_ctorC1ERKS_(%struct.aligned_copy_ctor* returned, %struct.aligned_copy_ctor* dereferenceable(16))
 //
 // CHECK: define void @_Z22test_aligned_copy_ctorv()
 // CHECK: %[[tmp:.*]] = alloca %struct.aligned_copy_ctor, align 16

 // CHECK: tail call void @_Z9def_emptyv()
 // CHECK: tail call void @_Z3use5empty()
 // CHECK: ret void
 //
 // CHECK: declare void @_Z3use5empty()
 // CHECK: declare void @_Z9def_emptyv()
 
 struct one_bitfield {
-    int d:3;
+  int d : 3;
 };
 test(one_bitfield);
 // CHECK: define i32 @_Z7forward12one_bitfield(i32 returned %{{.*}})
 //
 // CHECK: define void @_Z17test_one_bitfieldv()
 // CHECK: %[[call:.*]] = tail call i32 @_Z16def_one_bitfieldv()
 // CHECK: tail call void @_Z3use12one_bitfield(i32 %[[call]])
 // CHECK: ret void
 //
 // CHECK: declare void @_Z3use12one_bitfield(i32)
 // CHECK: declare i32 @_Z16def_one_bitfieldv()

test/Driver/wasm32-unknown-unknown.cpp

 
 // CHECK: @align_l = hidden global i32 4
 int align_l = __alignof(long);
 
 // CHECK: @align_ll = hidden global i32 8
 int align_ll = __alignof(long long);
 
 // CHECK: @align_p = hidden global i32 4
-int align_p = __alignof(void*);
+int align_p = __alignof(void *);
 
 // CHECK: @align_f = hidden global i32 4
 int align_f = __alignof(float);
 
 // CHECK: @align_d = hidden global i32 8
 int align_d = __alignof(double);
 
 // CHECK: @align_ld = hidden global i32 16

 // CHECK: float @check_float()
 float check_float() { return 0; }
 
 // CHECK: double @check_double()
 double check_double() { return 0; }
 
 // CHECK: fp128 @check_longdouble()
 long double check_longdouble() { return 0; }
-
 }
 
-template<int> void Switch();
-template<> void Switch<4>();
-template<> void Switch<8>();
-template<> void Switch<16>();
+template <int>
+void Switch();
+template <>
+void Switch<4>();
+template <>
+void Switch<8>();
+template <>
+void Switch<16>();
 
 void check_pointer_size() {
   // CHECK: SwitchILi4
-  Switch<sizeof(void*)>();
+  Switch<sizeof(void *)>();
 
   // CHECK: SwitchILi8
   Switch<sizeof(long long)>();
 
   // CHECK: SwitchILi4
   Switch<sizeof(va_list)>();
 }

test/Driver/wasm64-unknown-unknown.cpp

 
 // CHECK: @align_l = hidden global i32 8
 int align_l = __alignof(long);
 
 // CHECK: @align_ll = hidden global i32 8
 int align_ll = __alignof(long long);
 
 // CHECK: @align_p = hidden global i32 8
-int align_p = __alignof(void*);
+int align_p = __alignof(void *);
 
 // CHECK: @align_f = hidden global i32 4
 int align_f = __alignof(float);
 
 // CHECK: @align_d = hidden global i32 8
 int align_d = __alignof(double);
 
 // CHECK: @align_ld = hidden global i32 16

 // CHECK: float @check_float()
 float check_float() { return 0; }
 
 // CHECK: double @check_double()
 double check_double() { return 0; }
 
 // CHECK: fp128 @check_longdouble()
 long double check_longdouble() { return 0; }
-
 }
 
-template<int> void Switch();
-template<> void Switch<4>();
-template<> void Switch<8>();
-template<> void Switch<16>();
+template <int>
+void Switch();
+template <>
+void Switch<4>();
+template <>
+void Switch<8>();
+template <>
+void Switch<16>();
 
 void check_pointer_size() {
   // CHECK: SwitchILi8
-  Switch<sizeof(void*)>();
+  Switch<sizeof(void *)>();
 
   // CHECK: SwitchILi8
   Switch<sizeof(long long)>();
 
   // CHECK: SwitchILi8
   Switch<sizeof(va_list)>();
 }