[WebAssembly] Fix build error in wasm YAML code

[sbc100]

Summary

This warning didn't show up on my local build
but is causing the bots to fail. Seems like a
bad idea to have types and variables with the
same name anyhow.

llvm/trunk/include/llvm/ObjectYAML/WasmYAML.h

 };
 
 struct Import {
   StringRef Module;
   StringRef Field;
   ExportKind Kind;
   union {
     uint32_t SigIndex;
-    Global Global;
-    Table Table;
+    Global GlobalImport;
+    Table TableImport;
     Limits Memory;
   };
 };
 
 struct LocalDecl {
   ValueType Type;
   uint32_t Count;
 };

llvm/trunk/lib/ObjectYAML/WasmYAML.cpp

 void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
                                               WasmYAML::Import &Import) {
   IO.mapRequired("Module", Import.Module);
   IO.mapRequired("Field", Import.Field);
   IO.mapRequired("Kind", Import.Kind);
   if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
     IO.mapRequired("SigIndex", Import.SigIndex);
   } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) {
-    IO.mapRequired("GlobalType", Import.Global.Type);
-    IO.mapRequired("GlobalMutable", Import.Global.Mutable);
+    IO.mapRequired("GlobalType", Import.GlobalImport.Type);
+    IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable);
   } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) {
-    IO.mapRequired("Table", Import.Table);
+    IO.mapRequired("Table", Import.TableImport);
   } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY ) {
     IO.mapRequired("Memory", Import.Memory);
   } else {
     llvm_unreachable("unhandled import type");
   }
 }
 
 void MappingTraits<WasmYAML::Export>::mapping(IO &IO,

llvm/trunk/tools/obj2yaml/wasm2yaml.cpp

case wasm::WASM_SEC_IMPORT: {
         Im.Module = Import.Module;
         Im.Field = Import.Field;
         Im.Kind = Import.Kind;
         switch (Im.Kind) {
         case wasm::WASM_EXTERNAL_FUNCTION:
           Im.SigIndex = Import.SigIndex;
           break;
         case wasm::WASM_EXTERNAL_GLOBAL:
-          Im.Global.Type = Import.Global.Type;
-          Im.Global.Mutable = Import.Global.Mutable;
+          Im.GlobalImport.Type = Import.Global.Type;
+          Im.GlobalImport.Mutable = Import.Global.Mutable;
           break;
         case wasm::WASM_EXTERNAL_TABLE:
-          Im.Table = make_table(Import.Table);
+          Im.TableImport = make_table(Import.Table);
           break;
         case wasm::WASM_EXTERNAL_MEMORY:
           Im.Memory = make_limits(Import.Memory);
           break;
         }
         ImportSec->Imports.push_back(Im);
       }
       S = std::move(ImportSec);

llvm/trunk/tools/yaml2obj/yaml2wasm.cpp

for (const WasmYAML::Import &Import : Section.Imports) {
     writeStringRef(Import.Module, OS);
     writeStringRef(Import.Field, OS);
     encodeULEB128(Import.Kind, OS);
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
       encodeULEB128(Import.SigIndex, OS);
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
-      encodeSLEB128(Import.Global.Type, OS);
-      writeUint8(OS, Import.Global.Mutable);
+      encodeSLEB128(Import.GlobalImport.Type, OS);
+      writeUint8(OS, Import.GlobalImport.Mutable);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
       writeLimits(Import.Memory, OS);
       break;
     case wasm::WASM_EXTERNAL_TABLE:
-      encodeSLEB128(Import.Table.ElemType, OS);
-      writeLimits(Import.Table.TableLimits, OS);
+      encodeSLEB128(Import.TableImport.ElemType, OS);
+      writeLimits(Import.TableImport.TableLimits, OS);
       break;
     default:
       errs() << "Unknown import type: " << Import.Kind;
       return 1;
     }
   }
   return 0;
 }