Use `wasm` rather than `wasm32` as the as the default WebAssembly arch name

[sbc100]

Summary

Keep wasm32 as an alias for wasm.

This is inline with many other arches such as: ppc, sparc, spir, amdil, hsail, x86.
All these use the basename of the arch for the 32-bit variant and add the 64 bit
suffix for 64-bit case.

The motivation for this is that wasm64 doesn't even exist yet so having the
distinction everywhere and exposing it to the users of the tools is rather pointless
and confusing.

If this change is unpopular I could invert it and make wasm an alias for wasm32?

On place I particularly want to avoid the 32 is in the tool names:
wasm32-unknown-unknown-clang is bad enough, wasm-unknown-unknown-clang
better. Ideally just wasm-clang.

[sbc100]

clang change is here: https://reviews.llvm.org/D43035

[sunfish]

In my experience it's not uncommon to see a reference to "x86" where it's not clear whether it applies to both 32-bit and 64-bit x86, or really just 32-bit x86. Also, I think many of the old architectures have names that predate the existence of their 64-bit variants. For example MIPS was originally 32-bit only. In contrast, RISC-V is an example of a new architecture with a 64-bit variant present from the start, and they call their 32-bit variant riscv32. Consequently, I've been trying to only say "wasm" for things that apply to both wasm32 and wasm64.

[sunfish]

As an example, you can have code like this:

#ifdef __wasm__
  // do stuff with __builtin_wasm_mem_grow and __builtin_wasm_mem_size
#endif

which works for both wasm32 and wasm64.

On place I particularly want to avoid the 32 is in the tool names: wasm32-unknown-unknown-clang is bad enough, wasm-unknown-unknown-clang better.

I also hear people complain about the "unknown-unknown" part...

Ideally just wasm-clang.

Is there something using "wasm32-clang" today?

include/llvm/ADT/Triple.h

enum ArchType {
     amdil64,        // AMDIL with 64-bit pointers
     hsail,          // AMD HSAIL
     hsail64,        // AMD HSAIL with 64-bit pointers
     spir,           // SPIR: standard portable IR for OpenCL 32-bit version
     spir64,         // SPIR: standard portable IR for OpenCL 64-bit version
     kalimba,        // Kalimba: generic kalimba
     shave,          // SHAVE: Movidius vector VLIW processors
     lanai,          // Lanai: Lanai 32-bit
-    wasm32,         // WebAssembly with 32-bit pointers
+    wasm,           // WebAssembly with 32-bit pointers
     wasm64,         // WebAssembly with 64-bit pointers
     renderscript32, // 32-bit RenderScript
     renderscript64, // 64-bit RenderScript
     LastArchType = renderscript64
   };
   enum SubArchType {
     NoSubArch,
 

include/llvm/Object/ELFObjectFile.h

template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
 
   case ELF::EM_SPARC:
   case ELF::EM_SPARC32PLUS:
     return IsLittleEndian ? Triple::sparcel : Triple::sparc;
   case ELF::EM_SPARCV9:
     return Triple::sparcv9;
   case ELF::EM_WEBASSEMBLY:
     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
-    case ELF::ELFCLASS32: return Triple::wasm32;
+    case ELF::ELFCLASS32: return Triple::wasm;
     case ELF::ELFCLASS64: return Triple::wasm64;
     default: return Triple::UnknownArch;
     }
 
   case ELF::EM_AMDGPU: {
     if (!IsLittleEndian)
       return Triple::UnknownArch;
 

lib/Object/WasmObjectFile.cpp

section_iterator WasmObjectFile::section_end() const {
   Ref.d.a = Sections.size();
   return section_iterator(SectionRef(Ref, this));
 }
 
 uint8_t WasmObjectFile::getBytesInAddress() const { return 4; }
 
 StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
 
-Triple::ArchType WasmObjectFile::getArch() const { return Triple::wasm32; }
+Triple::ArchType WasmObjectFile::getArch() const { return Triple::wasm; }
 
 SubtargetFeatures WasmObjectFile::getFeatures() const {
   return SubtargetFeatures();
 }
 
 bool WasmObjectFile::isRelocatableObject() const {
   return HasLinkingSection;
 }

lib/Support/Triple.cpp

StringRef Triple::getArchTypeName(ArchType Kind) {
   case amdil64:        return "amdil64";
   case hsail:          return "hsail";
   case hsail64:        return "hsail64";
   case spir:           return "spir";
   case spir64:         return "spir64";
   case kalimba:        return "kalimba";
   case lanai:          return "lanai";
   case shave:          return "shave";
-  case wasm32:         return "wasm32";
+  case wasm:           return "wasm";
   case wasm64:         return "wasm64";
   case renderscript32: return "renderscript32";
   case renderscript64: return "renderscript64";
   }
 
   llvm_unreachable("Invalid ArchType!");
 }
 
StringRef Triple::getArchTypePrefix(ArchType Kind) {
   case hsail:
   case hsail64:     return "hsail";
 
   case spir:
   case spir64:      return "spir";
   case kalimba:     return "kalimba";
   case lanai:       return "lanai";
   case shave:       return "shave";
-  case wasm32:
+  case wasm:
   case wasm64:      return "wasm";
 
   case riscv32:
   case riscv64:     return "riscv";
   }
 }
 
 StringRef Triple::getVendorTypeName(VendorType Kind) {
return StringSwitch<Triple::ArchType>(Name)
     .Case("amdil64", amdil64)
     .Case("hsail", hsail)
     .Case("hsail64", hsail64)
     .Case("spir", spir)
     .Case("spir64", spir64)
     .Case("kalimba", kalimba)
     .Case("lanai", lanai)
     .Case("shave", shave)
-    .Case("wasm32", wasm32)
-    .Case("wasm64", wasm64)
+    .Case("wasm32", wasm)
+    .Case("wasm", wasm64)
     .Case("renderscript32", renderscript32)
     .Case("renderscript64", renderscript64)
     .Default(UnknownArch);
 }
 
 static Triple::ArchType parseARMArch(StringRef ArchName) {
   ARM::ISAKind ISA = ARM::parseArchISA(ArchName);
   ARM::EndianKind ENDIAN = ARM::parseArchEndian(ArchName);
auto AT = StringSwitch<Triple::ArchType>(ArchName)
     .Case("amdil64", Triple::amdil64)
     .Case("hsail", Triple::hsail)
     .Case("hsail64", Triple::hsail64)
     .Case("spir", Triple::spir)
     .Case("spir64", Triple::spir64)
     .StartsWith("kalimba", Triple::kalimba)
     .Case("lanai", Triple::lanai)
     .Case("shave", Triple::shave)
-    .Case("wasm32", Triple::wasm32)
+    .Cases("wasm", "wasm32", Triple::wasm)
     .Case("wasm64", Triple::wasm64)
     .Case("renderscript32", Triple::renderscript32)
     .Case("renderscript64", Triple::renderscript64)
     .Default(Triple::UnknownArch);
 
   // Some architectures require special parsing logic just to compute the
   // ArchType result.
   if (AT == Triple::UnknownArch) {
case Triple::xcore:
     return Triple::ELF;
 
   case Triple::ppc:
   case Triple::ppc64:
     if (T.isOSDarwin())
       return Triple::MachO;
     return Triple::ELF;
 
-  case Triple::wasm32:
+  case Triple::wasm:
   case Triple::wasm64:
     return Triple::Wasm;
   }
   llvm_unreachable("unknown architecture");
 }
 
 /// \brief Construct a triple from the string representation provided.
 ///
static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
   case llvm::Triple::x86:
   case llvm::Triple::xcore:
   case llvm::Triple::amdil:
   case llvm::Triple::hsail:
   case llvm::Triple::spir:
   case llvm::Triple::kalimba:
   case llvm::Triple::lanai:
   case llvm::Triple::shave:
-  case llvm::Triple::wasm32:
+  case llvm::Triple::wasm:
   case llvm::Triple::renderscript32:
     return 32;
 
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
   case llvm::Triple::amdgcn:
   case llvm::Triple::bpfel:
   case llvm::Triple::bpfeb:
Triple Triple::get32BitArchVariant() const {
   case Triple::tce:
   case Triple::tcele:
   case Triple::thumb:
   case Triple::thumbeb:
   case Triple::x86:
   case Triple::xcore:
   case Triple::lanai:
   case Triple::shave:
-  case Triple::wasm32:
+  case Triple::wasm:
   case Triple::renderscript32:
     // Already 32-bit.
     break;
 
   case Triple::aarch64:        T.setArch(Triple::arm);     break;
   case Triple::aarch64_be:     T.setArch(Triple::armeb);   break;
   case Triple::le64:           T.setArch(Triple::le32);    break;
   case Triple::mips64:         T.setArch(Triple::mips);    break;
   case Triple::mips64el:       T.setArch(Triple::mipsel);  break;
   case Triple::nvptx64:        T.setArch(Triple::nvptx);   break;
   case Triple::ppc64:          T.setArch(Triple::ppc);     break;
   case Triple::sparcv9:        T.setArch(Triple::sparc);   break;
   case Triple::riscv64:        T.setArch(Triple::riscv32); break;
   case Triple::x86_64:         T.setArch(Triple::x86);     break;
   case Triple::amdil64:        T.setArch(Triple::amdil);   break;
   case Triple::hsail64:        T.setArch(Triple::hsail);   break;
   case Triple::spir64:         T.setArch(Triple::spir);    break;
-  case Triple::wasm64:         T.setArch(Triple::wasm32);  break;
+  case Triple::wasm64:         T.setArch(Triple::wasm);    break;
   case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
   }
   return T;
 }
 
 Triple Triple::get64BitArchVariant() const {
   Triple T(*this);
   switch (getArch()) {
Triple Triple::get64BitArchVariant() const {
   case Triple::sparc:           T.setArch(Triple::sparcv9);    break;
   case Triple::riscv32:         T.setArch(Triple::riscv64);    break;
   case Triple::x86:             T.setArch(Triple::x86_64);     break;
   case Triple::amdil:           T.setArch(Triple::amdil64);    break;
   case Triple::hsail:           T.setArch(Triple::hsail64);    break;
   case Triple::spir:            T.setArch(Triple::spir64);     break;
   case Triple::thumb:           T.setArch(Triple::aarch64);    break;
   case Triple::thumbeb:         T.setArch(Triple::aarch64_be); break;
-  case Triple::wasm32:          T.setArch(Triple::wasm64);     break;
+  case Triple::wasm:            T.setArch(Triple::wasm64);     break;
   case Triple::renderscript32:  T.setArch(Triple::renderscript64);     break;
   }
   return T;
 }
 
 Triple Triple::getBigEndianArchVariant() const {
   Triple T(*this);
   // Already big endian.
Triple Triple::getBigEndianArchVariant() const {
   case Triple::nvptx64:
   case Triple::nvptx:
   case Triple::r600:
   case Triple::riscv32:
   case Triple::riscv64:
   case Triple::shave:
   case Triple::spir64:
   case Triple::spir:
-  case Triple::wasm32:
+  case Triple::wasm:
   case Triple::wasm64:
   case Triple::x86:
   case Triple::x86_64:
   case Triple::xcore:
   case Triple::renderscript32:
   case Triple::renderscript64:
 
   // ARM is intentionally unsupported here, changing the architecture would
bool Triple::isLittleEndian() const {
   case Triple::r600:
   case Triple::riscv32:
   case Triple::riscv64:
   case Triple::shave:
   case Triple::sparcel:
   case Triple::spir64:
   case Triple::spir:
   case Triple::thumb:
-  case Triple::wasm32:
+  case Triple::wasm:
   case Triple::wasm64:
   case Triple::x86:
   case Triple::x86_64:
   case Triple::xcore:
   case Triple::tcele:
   case Triple::renderscript32:
   case Triple::renderscript64:
     return true;

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyELFObjectWriter.cpp

unsigned WebAssemblyELFObjectWriter::getRelocType(MCContext &Ctx,
   // pointer to a function, we must use a special relocation type.
   if (const MCSymbolRefExpr *SyExp =
           dyn_cast<MCSymbolRefExpr>(Fixup.getValue()))
     if (SyExp->getKind() == MCSymbolRefExpr::VK_WebAssembly_FUNCTION)
       return ELF::R_WEBASSEMBLY_FUNCTION;
 
   switch (Fixup.getKind()) {
   case FK_Data_4:
-    assert(!is64Bit() && "4-byte relocations only supported on wasm32");
+    assert(!is64Bit() && "4-byte relocations not supported on wasm64");
     return ELF::R_WEBASSEMBLY_DATA;
   case FK_Data_8:
-    assert(is64Bit() && "8-byte relocations only supported on wasm64");
+    assert(is64Bit() && "8-byte relocations not supported on wasm");
     return ELF::R_WEBASSEMBLY_DATA;
   default:
     llvm_unreachable("unimplemented fixup kind");
   }
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWebAssemblyELFObjectWriter(raw_pwrite_stream &OS,
                                        bool Is64Bit,
                                        uint8_t OSABI) {
   auto MOTW = llvm::make_unique<WebAssemblyELFObjectWriter>(Is64Bit, OSABI);
   return createELFObjectWriter(std::move(MOTW), OS, /*IsLittleEndian=*/true);
 }

lib/Target/WebAssembly/TargetInfo/WebAssemblyTargetInfo.cpp

Target &llvm::getTheWebAssemblyTarget32() {
   return TheWebAssemblyTarget32;
 }
 Target &llvm::getTheWebAssemblyTarget64() {
   static Target TheWebAssemblyTarget64;
   return TheWebAssemblyTarget64;
 }
 
 extern "C" void LLVMInitializeWebAssemblyTargetInfo() {
-  RegisterTarget<Triple::wasm32> X(getTheWebAssemblyTarget32(), "wasm32",
-                                   "WebAssembly 32-bit", "WebAssembly");
+  RegisterTarget<Triple::wasm> X(getTheWebAssemblyTarget32(), "wasm32",
   RegisterTarget<Triple::wasm64> Y(getTheWebAssemblyTarget64(), "wasm64",
                                    "WebAssembly 64-bit", "WebAssembly");
 }

lib/Target/WebAssembly/WebAssemblyInstrControl.td

 def : Pat<(brcond (i32 (setne I32:$cond, 0)), bb:$dst),
           (BR_IF bb_op:$dst, I32:$cond)>;
 def : Pat<(brcond (i32 (seteq I32:$cond, 0)), bb:$dst),
           (BR_UNLESS bb_op:$dst, I32:$cond)>;
 
 let Defs = [ARGUMENTS] in {
 
 // TODO: SelectionDAG's lowering insists on using a pointer as the index for
-// jump tables, so in practice we don't ever use BR_TABLE_I64 in wasm32 mode
+// jump tables, so in practice we don't ever use BR_TABLE_I64 in wasm mode
 // currently.
 // Set TSFlags{0} to 1 to indicate that the variable_ops are immediates.
 // Set TSFlags{1} to 1 to indicate that the immediates represent labels.
 let isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
 def BR_TABLE_I32 : I<(outs), (ins I32:$index, variable_ops),
                      [(WebAssemblybr_table I32:$index)],
                      "br_table \t$index", 0x0e> {
   let TSFlags{0} = 1;

lib/Transforms/IPO/LowerTypeTests.cpp

 
 /// Given a disjoint set of type identifiers and functions, build the bit sets
 /// and lower the llvm.type.test calls, architecture dependently.
 void LowerTypeTestsModule::buildBitSetsFromFunctions(
     ArrayRef<Metadata *> TypeIds, ArrayRef<GlobalTypeMember *> Functions) {
   if (Arch == Triple::x86 || Arch == Triple::x86_64 || Arch == Triple::arm ||
       Arch == Triple::thumb || Arch == Triple::aarch64)
     buildBitSetsFromFunctionsNative(TypeIds, Functions);
-  else if (Arch == Triple::wasm32 || Arch == Triple::wasm64)
+  else if (Arch == Triple::wasm || Arch == Triple::wasm64)
     buildBitSetsFromFunctionsWASM(TypeIds, Functions);
   else
     report_fatal_error("Unsupported architecture for jump tables");
 }
 
 void LowerTypeTestsModule::moveInitializerToModuleConstructor(
     GlobalVariable *GV) {
   if (WeakInitializerFn == nullptr) {

test/MC/WebAssembly/file-headers.ll

 ; RUN: llc -filetype=obj %s -o - | llvm-readobj -file-headers | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; CHECK: Format: WASM{{$}}
-; CHECK: Arch: wasm32{{$}}
+; CHECK: Arch: wasm{{$}}
 ; CHECK: AddressSize: 32bit{{$}}
 ; CHECK: Version: 0x1{{$}}

test/MC/WebAssembly/sections.ll

 ; local function
 define i32 @f1() {
 entry:
     %tmp1 = call i32 @a()
     ret i32 %tmp1
 }
 
 ; CHECK: Format: WASM
-; CHECK: Arch: wasm32
+; CHECK: Arch: wasm
 ; CHECK: AddressSize: 32bit
 ; CHECK: Sections [
 ; CHECK:   Section {
 ; CHECK:     Type: TYPE (0x1)
 ; CHECK:   }
 ; CHECK:  Section {
 ; CHECK:    Type: IMPORT (0x2)
 ; CHECK:  }

test/tools/llvm-readobj/file-headers.test

 ELF-LANAI-NEXT:   ProgramHeaderEntrySize: 0
 ELF-LANAI-NEXT:   ProgramHeaderCount: 0
 ELF-LANAI-NEXT:   SectionHeaderEntrySize: 40
 ELF-LANAI-NEXT:   SectionHeaderCount: 8
 ELF-LANAI-NEXT:   StringTableSectionIndex: 1
 ELF-LANAI-NEXT: }
 
 WASM: Format: WASM
-WASM-NEXT: Arch: wasm32
+WASM-NEXT: Arch: wasm
 WASM-NEXT: AddressSize: 32bit
 WASM-NEXT: Version: 0x1