[WebAssembly] Initial support for reference type externref in clang

[pmatos]

Summary

This patch introduces a new type externref_t that denotes a WebAssembly opaque
reference type. It also implements builtin builtin_wasm_ref_null_extern(),
that returns a null value of __externref_t. This lays the ground work
for further builtins and reference types.

[asb]

I've left one minor comment. My other suggestion would be to absorb in the semantic restrictions work from here.

llvm/lib/IR/Type.cpp

309

With the move to opaque pointers, I think this and getWasm_FuncRefTy could be updated to just return a pointer to addrspace 10 and 20 respectively?

[pmatos]

Incorporate @asb semantic restrictions patch.
Generate test CHECK using update_cc_* script.

[pmatos]

rebase on top of D128282

[pmatos]

Updated patch over current main. Fixed all failint tests. Ready for review.

[pmatos]

Remove some extraneous spaces I hadn't noticed before.

[pmatos]

Rebase on top of main.

[pmatos]

It would be great to get this landed. Can someone pls take a look at it? It's quite independent from the remainder of the work and self-contained.

maybe @tlively ping?

[tlively]

Very nice! This LGTM with all these small comments addressed. Sorry for the long delay in reviewing.

clang/include/clang/AST/ASTContext.h

1129

I have no idea what's going on here in the code, but it seems that the existing convention is to put CanQualType SingletonId; on a separate line.

clang/include/clang/AST/Type.h

2031

Looks like there should be a newline here.

clang/include/clang/Basic/AddressSpaces.h

59–60 ↗

(On Diff #446405)

What is wasm_var? It would be good to have a short comment here (and newline afterward).

clang/include/clang/Basic/Builtins.def

50 ↗

(On Diff #446405)

clang/include/clang/Basic/BuiltinsWebAssembly.def

194

Looks like this comment about polymorphism is out of date. (Also it would be good to add a newline after this.)

clang/include/clang/Basic/WebAssemblyReferenceTypes.def

10

Maybe we should only mention externref_t for now.

clang/lib/AST/ASTContext.cpp

2267

I assume things will break if you say 0 here, but would 1 work?

4012

Do we need Target.getTriple().isWasm() here as well?

clang/lib/AST/ItaniumMangle.cpp

3143

Our MangledName is not the same as our InternalName, so it looks like this condition will never be true. Should be follow the simpler pattern from the previous two targets instead?

clang/lib/Basic/Targets/DirectX.h

44–45 ↗

(On Diff #446405)

What are these for? I'm surprised we need to do anything here in the DirectX target. Same for the similar lines in other targets.

clang/lib/CodeGen/CGDebugInfo.cpp

825–826

How did you choose this?

clang/lib/CodeGen/TargetInfo.h

366

missing whitespace.

clang/test/CodeGen/WebAssembly/wasm-externref.c

12–14

Do we need this here since the builtin is also tested in builtins-wasm.c? Are there more ways to use externref_t that we should test here?

clang/test/Sema/wasm-refs-and-tables.c

4

Should this file be just wasm-refs.c since it doesn't do anything with tables yet? Same for the next one.

clang/test/SemaTemplate/address_space-dependent.cpp

46

Maybe this test can be split off into a separate tiny PR since it doesn't look directly related to the rest.

[aaron.ballman]

Adding new types to the type system is quite invasive; was there an RFC for this you can point me to along with a design document? I have no idea how to review this because I don't know what the semantics of this type are supposed to be.

clang/include/clang/AST/ASTContext.h

1479

clang/include/clang/AST/Type.h

2030–2031

It's unfortunate to name this with ReferenceType given that we already have a considerable number of APIs that assume "reference type" to mean & or &&. We run into similar problems with "pointer type" and objective-c pointers.

Basically, I worry we're setting ourselves up for another isObjCObjectPointerType()/isPointerType() situation.

clang/include/clang/Basic/AddressSpaces.h

59–60 ↗

(On Diff #446405)

Agreed; I'm not certain why wasm_var is part of this changeset.

clang/include/clang/Basic/Attr.td

3937–3944 ↗

(On Diff #417212)

No new undocumented attributes, please. No need for the Args field, and please add the newline back to the end of the file.

clang/include/clang/Basic/Builtins.def

50 ↗

(On Diff #446405)

How often do you expect to use this marking? If it's only going to be used once or twice, it might make sense to not steal a letter but instead use custom checking for the signature.

clang/include/clang/Basic/DiagnosticSemaKinds.td

11763–11766

These can be combined with a %select

11767–11770

These can also be combined with a %select

clang/include/clang/Basic/WebAssemblyReferenceTypes.def

17

What kind of mangling is this name? Itanium? Microsoft? Something else?

clang/lib/AST/ASTContext.cpp

933–934

How did you arrive at these values?

clang/lib/AST/ItaniumMangle.cpp

3143

I'm not an Itanium mangling expert, but doesn't this *have* to use the u marking per https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangle.builtin-type because this is definitely a vendor extension type.

clang/lib/AST/MicrosoftMangle.cpp

2494–2495

Is it reasonable that this simply cannot mangle in Microsoft ABI mode?

clang/lib/AST/Type.cpp

2353–2356

clang/lib/Sema/SemaType.cpp

2200–2205

2282–2287

[pmatos]

clang/include/clang/AST/Type.h

2030–2031

I understand this concern. However, unsure what else to call it given that's what it is. It's a WebAssembly Reference Type, which indeed is different from a C/C++ ReferenceType. Could call it OpaqueType but that would be even worse. Not only it's not called an opaque type in Wasm, it's also not what LLVM users will think of as Opaque Types.

clang/include/clang/Basic/Builtins.def

50 ↗

(On Diff #446405)

Ah yes, that probably makes sense. I will use a custom typechecker instead.

[aaron.ballman]

clang/include/clang/AST/Type.h

2030–2031

Yeah, I think this is as good of a name as we're likely to find; I certainly haven't thought of something better. If we do think of something later, we can refactor then.

[pmatos]

Fix a few of the issues mentioned in the revision comments.

[pmatos]

Still a few more changes are required.

[pmatos]

clang/include/clang/AST/Type.h

2030–2031

OK - thanks.

[pmatos]

clang/include/clang/Basic/AddressSpaces.h

59–60 ↗

(On Diff #446405)

Yes, it was a mistake during patch splitting. I have removed it. Thanks.

clang/lib/AST/ASTContext.cpp

2267

Yes, 1 seems to work. I am not 100% sure but since externref cannot be written to memory, does it matter?

4012

Might be useful, in case another target has also a feature called reference-types. :)

clang/lib/Basic/Targets/DirectX.h

44–45 ↗

(On Diff #446405)

I was surprised as well, but apparently if you don't add them to all targets, they will not compile. There's an assignment of these Target specific AddrSpaceMaps to the AddrSpaceMap: AddrSpaceMap = &DirectXAddrSpaceMap;, and AddrSpaceMap is a LangAS defined in AddressSpaces.h so anything added there needs to be added to all targets afaiu.

clang/test/Sema/wasm-refs-and-tables.c

4

Tables to be added in a future patch. ;)
But yeah, I will rename for now.

[pmatos]

Further changes - more to come.

[pmatos]

clang/lib/AST/ASTContext.cpp

933–934

How did you arrive at these values?

Same as for funcref, this is the same in the LLVM side of things.

[pmatos]

clang/lib/AST/ASTContext.cpp

2267

Nope... I take that back. builtins-wasm.c seems to break with anything under 8 with the error:

clang: /home/pmatos/dev/llvm-project/llvm/include/llvm/Support/Alignment.h:77: llvm::Align::Align(uint64_t): Assertion `Value > 0 && "Value must not be 0"' failed.

Still need to investigate why a value of Align = 1; here ends up causing a zero alignment value in Alignment.h.

[pmatos]

Address further concerns.

[pmatos]

Current patch addresses most of the concerns - also passed through ./clang/tools/clang-format/git-clang-format.

[pmatos]

Removed address space wasm_externref which is unnecessary with current design.

[pmatos]

Whole integration plan still in the works, so marking as planning changes.

[pmatos]

Ready for review.

RFC: https://discourse.llvm.org/t/rfc-webassembly-reference-types-in-clang/66939

[MoritzS]

Thanks for the patch! I just tried it out and I think this enables many interesting use cases for WebAssembly when using C/C++.

Currently the lowering to wasm does not work when using externrefs when compiling without optimizations. Is that intended behavior?

I have this example C++ program (similar to the wasm-externref.c test):

void extern_func(__externref_t ref);
void my_func(__externref_t ref) {
    extern_func(ref);
}

If I compile this without optimizations (exact command: clang++ --target=wasm32 -mreference-types -c ./test_externref.cpp), I get the following error:

fatal error: error in backend: Cannot select: 0x621000066bd0: externref,ch = load<(dereferenceable load (s0) from %ir.2)> 0x621000066b58, TargetFrameIndex:i32<0>, undef:i32
  0x621000066a68: i32 = TargetFrameIndex<0>
  0x621000066ae0: i32 = undef

The reason for that can be seen when we look at the generated IR for this program:

; Function Attrs: mustprogress noinline optnone
define hidden void @_Z7my_func11externref_t(ptr addrspace(10) %0) #0 {
  %2 = alloca ptr addrspace(10), align 1
  store ptr addrspace(10) %0, ptr %2, align 1
  %3 = load ptr addrspace(10), ptr %2, align 1
  call void @_Z11extern_func11externref_t(ptr addrspace(10) %3)
  ret void
}

declare void @_Z11extern_func11externref_t(ptr addrspace(10)) #1

Apparently when no optimizations are enabled, clang will write all function arguments to an alloca'd variable. This obviously won't work if the value is an externref. The test case in wasm-externref.c also has the alloca and store with an externref value as expected output, which I think should never be generated.

With -O3 this doesn't happen as the alloca'd variables are optimized out. But I still think it should also work with -O0.

[pmatos]

In D122215#3991648, @MoritzS wrote:

Thanks for the patch! I just tried it out and I think this enables many interesting use cases for WebAssembly when using C/C++.

Currently the lowering to wasm does not work when using externrefs when compiling without optimizations. Is that intended behavior?

No - thanks for trying this out. This is definitely not intended behaviour. Somehow I probably didn't test enough without optimizations. I was expecting that the pass mem2reg would get rid of the allocas, but maybe it's not running at those optimization levels. I will have to take a closer look.

[pmatos]

In D122215#3995105, @pmatos wrote:

In D122215#3991648, @MoritzS wrote:

Thanks for the patch! I just tried it out and I think this enables many interesting use cases for WebAssembly when using C/C++.

Currently the lowering to wasm does not work when using externrefs when compiling without optimizations. Is that intended behavior?

No - thanks for trying this out. This is definitely not intended behaviour. Somehow I probably didn't test enough without optimizations. I was expecting that the pass mem2reg would get rid of the allocas, but maybe it's not running at those optimization levels. I will have to take a closer look.

Apparently the code forcing mem2reg was lost during a conflict resolution. My apologies, I will add this to the patch asap.

[pmatos]

Force mem2reg on all optimization levels to avoid allocas.

[pmatos]

In D122215#3991648, @MoritzS wrote:

Thanks for the patch! I just tried it out and I think this enables many interesting use cases for WebAssembly when using C/C++.

Currently the lowering to wasm does not work when using externrefs when compiling without optimizations. Is that intended behavior?

I have posted a new patch that fixed this. Can you please try it again and see if it works as you expect?

[MoritzS]

In D122215#3998105, @pmatos wrote:

In D122215#3991648, @MoritzS wrote:

Thanks for the patch! I just tried it out and I think this enables many interesting use cases for WebAssembly when using C/C++.

Currently the lowering to wasm does not work when using externrefs when compiling without optimizations. Is that intended behavior?

I have posted a new patch that fixed this. Can you please try it again and see if it works as you expect?

Thanks for the quick update, it works now!

Does this affect the debugging experience of the generated wasm programs? If you force mem2reg to run for all programs, no function arguments will be written to the "stack" referenced by the __stack_pointer global variable anymore. I don't know whether any wasm runtime actually uses that for debugging, though.

[pmatos]

In D122215#4000612, @MoritzS wrote:

In D122215#3998105, @pmatos wrote:

In D122215#3991648, @MoritzS wrote:

Thanks for the patch! I just tried it out and I think this enables many interesting use cases for WebAssembly when using C/C++.

Currently the lowering to wasm does not work when using externrefs when compiling without optimizations. Is that intended behavior?

I have posted a new patch that fixed this. Can you please try it again and see if it works as you expect?

Thanks for the quick update, it works now!

Does this affect the debugging experience of the generated wasm programs? If you force mem2reg to run for all programs, no function arguments will be written to the "stack" referenced by the __stack_pointer global variable anymore. I don't know whether any wasm runtime actually uses that for debugging, though.

That's a good point, but I don't think that's a large concern at the moment on the WebAssembly side. I wonder if @tlively or @sbc100 have more to add with respect to the current state of debugging Wasm programs nowadays.

[pmatos]

Rebasing on top of main.

[aaron.ballman]

clang/include/clang/AST/ASTContext.h

1480

getWebAssemblyExternrefType ?

clang/include/clang/Basic/DiagnosticSemaKinds.td

11778

Rewording to avoid using "illegal" (and changes to the singular form).

clang/include/clang/Basic/WebAssemblyReferenceTypes.def

17

Still wondering about this.

clang/lib/AST/ASTContext.cpp

4012–4018

Rather than returning a null type, should we assert we're in a wasm triple? We shouldn't be trying to form the type outside of a wasm target, right?

clang/lib/AST/ItaniumMangle.cpp

3143

Still wondering about this, pinging @rjmccall for Itanium ABI expertise

clang/lib/AST/MicrosoftMangle.cpp

2494–2495

Still wondering about this

[pmatos]

Addressed a few comments downstream. Will upload new patch next.

[pmatos]

Address a couple of comments by @aaron.ballman

[pmatos]

clang/lib/AST/ASTContext.cpp

4012–4018

asserting false with message rather than llvm_unreachable is the right way, correct?

clang/lib/AST/ItaniumMangle.cpp

3143

I think what you both are saying makes sense.

[pmatos]

Deal with Itanium Mangle and assert false outside Wasm triple.

clang/lib/AST/MicrosoftMangle.cpp

2494–2495

@aaron.ballman Why wouldn't externref_t be able to mangle in Microsoft ABI mode? Quite clueless when it comes to ABIs.

[aaron.ballman]

clang/lib/AST/ASTContext.cpp

4012–4018

I'd recommend something like:

assert(Target->getTriple().isWasm() && Target->hasFeature("reference-types") && "shouldn't try to generate type externref outsid of WebAssembly target");
#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS)                  \
  if (BuiltinType::Id == BuiltinType::WasmExternRef)                           \
    return SingletonId;
#include "clang/Basic/WebAssemblyReferenceTypes.def"
  }
llvm_unreachable("couldn't find the externref type?");

so it's clear that you shouldn't call this outside of a wasm target and that it's not an option to not find the type.

clang/lib/AST/MicrosoftMangle.cpp

2494–2495

Including the wasm types here means that in Microsoft mode, use of those types in a context which requires mangling will diagnose (see this snippet just below):

unsigned DiagID = Diags.getCustomDiagID(
    DiagnosticsEngine::Error, "cannot mangle this built-in %0 type yet");
Diags.Report(Range.getBegin(), DiagID)
    << T->getName(Context.getASTContext().getPrintingPolicy()) << Range;

So I'm wondering whether you consider that to be reasonable behavior or not. If you don't want the diagnostic, then you should add a vendor extension mangling for the type.

[pmatos]

clang/lib/CodeGen/CGDebugInfo.cpp

825–826

This is the creation of the debug info for an opaque structure type, although I guess we could use other representations for externref, do you have any suggestions?

clang/test/CodeGen/WebAssembly/wasm-externref.c

12–14

Not at the moment. There's not much you can do with externref without using tables for example which is in another patch. Happy to remove this test as we have something similar indeed in builtins-wasm.c.

[pmatos]

Address all comments except a couple of issues related to ABI and mangling.

[pmatos]

@aaron.ballman many thanks for the thorough reviews on the patches. Happy to see this moving in the right direction.

clang/lib/AST/MicrosoftMangle.cpp

2494–2495

Oh - now I understand your point. I had forgotten I had initially written this 'workaround' to worry with later. Yes, let me add a vendor extension mangling for Microsoft ABI.

[pmatos]

Now under the correct revision: @aaron.ballman Added support for externref mangling in Microsoft. This follows the pattern implemented by OpenCL types.

[aaron.ballman]

clang/lib/AST/MicrosoftMangle.cpp

2479–2483

I don't think the PA bit is correct -- that seems to be specific to OpenCL. So I think that bit can simply be dropped, but CC @rnk for questions about Microsoft ABI.

[pmatos]

clang/lib/AST/MicrosoftMangle.cpp

2479–2483

OK, that makes sense. Although I got the feeling PA stood for Pointer or similar. Maybe @rnk can clarify. I will follow your suggestion for now.

[pmatos]

Update mangling for Microsoft.

[pmatos]

Fix tests after changing name mangling and error messages.

[pmatos]

Rename test that still had tables in its name.

[pmatos]

Rebase on main.

[pmatos]

I feel like the latest patch addresses all concerns until now. What do you think?

clang/include/clang/Basic/WebAssemblyReferenceTypes.def

17

This is just a generic name to base the actual mangling on tbh.

[pmatos]

Rebase on main.

[aaron.ballman]

Aside from a nit about comments, I don't have any further concerns. LGTM!

clang/include/clang/Basic/WebAssemblyReferenceTypes.def

17

Can you clarify the comment then? I'd expect MangledName to be an actual mangling, otherwise, and that's why I was wondering "which mangling?".

[aaron.ballman]

Oops, it helps to actually accept it in Phab. :-D

[pmatos]

Address last comment before landing.

[jgorbe]

clang/lib/AST/ASTContext.cpp

4012–4018

In a non-assert build, doing just assert(false) causes the build to fail if you use -Werror -Wreturn-type.

clang/lib/AST/ASTContext.cpp:4097:1: error: non-void function does not return a value in all control paths [-Werror,-Wreturn-type]

[vitalybuka]

as reverted

[asb]

@pmatos and I have tried and failed to reproduce the assert in the stage3 msan build locally (both of us on separate machines, different environments). We've reached out to @vitalybuka via email for any help in reproducing, because we're somewhat stumped at the moment.

[vitalybuka]

In D122215#4118516, @asb wrote:

@pmatos and I have tried and failed to reproduce the assert in the stage3 msan build locally (both of us on separate machines, different environments). We've reached out to @vitalybuka via email for any help in reproducing, because we're somewhat stumped at the moment.

I will try to reproduce on fresh VM and reply to you with details.

[asb]

In D122215#4119038, @vitalybuka wrote:

In D122215#4118516, @asb wrote:

@pmatos and I have tried and failed to reproduce the assert in the stage3 msan build locally (both of us on separate machines, different environments). We've reached out to @vitalybuka via email for any help in reproducing, because we're somewhat stumped at the moment.

I will try to reproduce on fresh VM and reply to you with details.

Thanks Vitaly - that would be really helpful.

[pmatos]

Rebased against HEAD. Waiting for @vitalybuka go ahead to land.

[vitalybuka]

clang-format

clang/include/clang/AST/ASTContext.h

#define SVE_TYPE(Name, Id, SingletonId) \
   CanQualType SingletonId;
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   CanQualType Id##Ty;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) \
   CanQualType SingletonId;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) CanQualType SingletonId;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 
   // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
   mutable QualType AutoDeductTy;     // Deduction against 'auto'.
   mutable QualType AutoRRefDeductTy; // Deduction against 'auto &&'.
 
   // Decl used to help define __builtin_va_list for some targets.
   // The decl is built when constructing 'BuiltinVaListDecl'.
   mutable Decl *VaListTagDecl = nullptr;
public:
   getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const;
 
   /// Return the unique reference to a scalable vector type of the specified
   /// element type and scalable number of elements.
   ///
   /// \pre \p EltTy must be a built-in type.
   QualType getScalableVectorType(QualType EltTy, unsigned NumElts) const;
 
+  /// Return a WebAssembly externref type.
+  QualType getWebAssemblyExternrefType() const;
+
   /// Return the unique reference to a vector type of the specified
   /// element type and size.
   ///
   /// \pre \p VectorType must be a built-in type.
   QualType getVectorType(QualType VectorType, unsigned NumElts,
                          VectorType::VectorKind VecKind) const;
   /// Return the unique reference to the type for a dependently sized vector of
   /// the specified element type.

clang/include/clang/AST/Type.h

public:
   /// every type is one or the other.  Standard types are all sized;
   /// sizeless types are purely an extension.
   ///
   /// Sizeless types contain data with no specified size, alignment,
   /// or layout.
   bool isSizelessType() const;
   bool isSizelessBuiltinType() const;
 
+  /// Check if this is a WebAssembly Reference Type.
+  bool isWebAssemblyReferenceType() const;
+  bool isWebAssemblyExternrefType() const;
+
   /// Determines if this is a sizeless type supported by the
   /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
   /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
   bool isVLSTBuiltinType() const;
 
   /// Returns the representative type for the element of an SVE builtin type.
   /// This is used to represent fixed-length SVE vectors created with the
   /// 'arm_sve_vector_bits' type attribute as VectorType.

 #define SVE_TYPE(Name, Id, SingletonId) Id,
 #include "clang/Basic/AArch64SVEACLETypes.def"
 // PPC MMA Types
 #define PPC_VECTOR_TYPE(Name, Id, Size) Id,
 #include "clang/Basic/PPCTypes.def"
 // RVV Types
 #define RVV_TYPE(Name, Id, SingletonId) Id,
 #include "clang/Basic/RISCVVTypes.def"
+// WebAssembly reference types
+#define WASM_TYPE(Name, Id, SingletonId) Id,
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 // All other builtin types
 #define BUILTIN_TYPE(Id, SingletonId) Id,
 #define LAST_BUILTIN_TYPE(Id) LastKind = Id
 #include "clang/AST/BuiltinTypes.def"
   };
 
 private:
   friend class ASTContext; // ASTContext creates these.

clang/include/clang/AST/TypeProperties.td

 #define PPC_VECTOR_TYPE(NAME, ID, SIZE) \
       case BuiltinType::ID: return ctx.ID##Ty;
 #include "clang/Basic/PPCTypes.def"
 
 #define RVV_TYPE(NAME, ID, SINGLETON_ID) \
       case BuiltinType::ID: return ctx.SINGLETON_ID;
 #include "clang/Basic/RISCVVTypes.def"
 
+#define WASM_TYPE(NAME, ID, SINGLETON_ID) \
+      case BuiltinType::ID: return ctx.SINGLETON_ID;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
+
 #define BUILTIN_TYPE(ID, SINGLETON_ID) \
       case BuiltinType::ID: return ctx.SINGLETON_ID;
 #include "clang/AST/BuiltinTypes.def"
       }
       llvm_unreachable("unreachable builtin case");
   }]>;
 }
 

clang/include/clang/Basic/BuiltinsWebAssembly.def

 TARGET_BUILTIN(__builtin_wasm_relaxed_trunc_u_zero_i32x4_f64x2, "V4UiV2d", "nc", "relaxed-simd")
 
 TARGET_BUILTIN(__builtin_wasm_relaxed_q15mulr_s_i16x8, "V8sV8sV8s", "nc", "relaxed-simd")
 
 TARGET_BUILTIN(__builtin_wasm_relaxed_dot_i8x16_i7x16_s_i16x8, "V8sV16ScV16Sc", "nc", "relaxed-simd")
 TARGET_BUILTIN(__builtin_wasm_relaxed_dot_i8x16_i7x16_add_s_i32x4, "V4iV16ScV16ScV4i", "nc", "relaxed-simd")
 TARGET_BUILTIN(__builtin_wasm_relaxed_dot_bf16x8_add_f32_f32x4, "V4fV8UsV8UsV4f", "nc", "relaxed-simd")
 
+// Reference Types builtins
+
+TARGET_BUILTIN(__builtin_wasm_ref_null_extern, "i", "nct", "reference-types")
+
 #undef BUILTIN
 #undef TARGET_BUILTIN

clang/include/clang/Basic/DiagnosticSemaKinds.td

 
 // Layout randomization diagnostics.
 def err_non_designated_init_used : Error<
   "a randomized struct can only be initialized with a designated initializer">;
 def err_cast_from_randomized_struct : Error<
   "casting from randomized structure pointer type %0 to %1">;
 
 // LoongArch-specific Diagnostics
 def err_loongarch_builtin_requires_la64 : Error<
   "this builtin requires target: loongarch64">;
 
 // Unsafe buffer usage diagnostics.
 def warn_unsafe_buffer_expression : Warning<
   "unchecked operation on raw buffer in expression">,
   InGroup<UnsafeBufferUsage>, DefaultIgnore;
 def warn_unsafe_buffer_variable : Warning<
   "variable %0 participates in unchecked buffer operations">,
   InGroup<UnsafeBufferUsage>, DefaultIgnore;
 def err_loongarch_builtin_requires_la32 : Error<
   "this builtin requires target: loongarch32">;
+
+// WebAssembly reference type and table diagnostics.
+def err_wasm_reference_pr : Error<
+  "%select{pointer|reference}0 to WebAssembly reference type is not allowed">;
+def err_wasm_ca_reference : Error<
+  "cannot %select{capture|take address of}0 WebAssembly reference">;
 } // end of sema component.

clang/include/clang/Basic/WebAssemblyReferenceTypes.def

+//===-- WebAssemblyReferenceTypes.def - Wasm reference types ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines externref_t.  The macros are:
+//
+//    WASM_TYPE(Name, Id, SingletonId)
+//    WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS)
+//
+// where:
+//
+//  - Name is the name of the builtin type.  MangledName is the mangled name.
+//
+//  - BuiltinType::Id is the enumerator defining the type.
+//
+//  - Context.SingletonId is the global singleton of this type.
+//
+//  - AS indicates the address space for values of this type.
+//
+// To include this file, define either WASM_REF_TYPE or WASM_TYPE, depending on
+// how much information you want.  The macros will be undefined after inclusion.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef WASM_REF_TYPE
+#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS)           \
+  WASM_TYPE(Name, Id, SingletonId)
+#endif
+
+WASM_REF_TYPE("__externref_t", "externref_t", WasmExternRef, WasmExternRefTy, 10)
+
+#undef WASM_TYPE
+#undef WASM_REF_TYPE

clang/include/clang/Sema/Sema.h

private:
   bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                    CallExpr *TheCall);
   bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
   bool CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum);
   bool CheckRISCVBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                      CallExpr *TheCall);
   bool CheckLoongArchBuiltinFunctionCall(const TargetInfo &TI,
                                          unsigned BuiltinID, CallExpr *TheCall);
+  bool CheckWebAssemblyBuiltinFunctionCall(const TargetInfo &TI,
+                                           unsigned BuiltinID,
+                                           CallExpr *TheCall);
 
   bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
   bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
   bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
   bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
   bool SemaBuiltinComplex(CallExpr *TheCall);
   bool SemaBuiltinVSX(CallExpr *TheCall);
   bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
private:
   // Matrix builtin handling.
   ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall,
                                         ExprResult CallResult);
   ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
                                               ExprResult CallResult);
   ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
                                                ExprResult CallResult);
 
+  // WebAssembly builtin handling.
+  bool BuiltinWasmRefNullExtern(CallExpr *TheCall);
+
 public:
   enum FormatStringType {
     FST_Scanf,
     FST_Printf,
     FST_NSString,
     FST_Strftime,
     FST_Strfmon,
     FST_Kprintf,

clang/include/clang/Serialization/ASTBitCodes.h

 #define SVE_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/AArch64SVEACLETypes.def"
 // \brief  PowerPC MMA types with auto numeration
 #define PPC_VECTOR_TYPE(Name, Id, Size) PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/PPCTypes.def"
 // \brief RISC-V V types with auto numeration
 #define RVV_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/RISCVVTypes.def"
+// \brief WebAssembly reference types with auto numeration
+#define WASM_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID,
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 };
 
 /// The number of predefined type IDs that are reserved for
 /// the PREDEF_TYPE_* constants.
 ///
 /// Type IDs for non-predefined types will start at
 /// NUM_PREDEF_TYPE_IDs.
 const unsigned NUM_PREDEF_TYPE_IDS = 300;

clang/include/clang/module.modulemap

module Clang_Basic {
   textual header "Basic/OpenCLExtensionTypes.def"
   textual header "Basic/OpenMPKinds.def"
   textual header "Basic/OperatorKinds.def"
   textual header "Basic/PPCTypes.def"
   textual header "Basic/RISCVVTypes.def"
   textual header "Basic/Sanitizers.def"
   textual header "Basic/TargetCXXABI.def"
   textual header "Basic/TransformTypeTraits.def"
+  textual header "Basic/TokenKinds.def"
+  textual header "Basic/WebAssemblyReferenceTypes.def"
 
   module * { export * }
 }
 module Clang_Basic_TokenKinds {
   requires cplusplus
 
   header "Basic/TokenKinds.h"
   textual header "Basic/TokenKinds.def"

clang/lib/AST/ASTContext.cpp

 }
 
 ParentMapContext &ASTContext::getParentMapContext() {
   if (!ParentMapCtx)
     ParentMapCtx.reset(new ParentMapContext(*this));
   return *ParentMapCtx.get();
 }
 
 static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI,
                                           const LangOptions &LangOpts) {
   switch (LangOpts.getAddressSpaceMapMangling()) {
   case LangOptions::ASMM_Target:
     return TI.useAddressSpaceMapMangling();
   case LangOptions::ASMM_On:
     return true;
   case LangOptions::ASMM_Off:
     return false;
   }
#include "clang/Basic/PPCTypes.def"
   }
 
   if (Target.hasRISCVVTypes()) {
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
   InitBuiltinType(SingletonId, BuiltinType::Id);
 #include "clang/Basic/RISCVVTypes.def"
   }
 
+  if (Target.getTriple().isWasm() && Target.hasFeature("reference-types")) {
+#define WASM_TYPE(Name, Id, SingletonId)                                       \
+  InitBuiltinType(SingletonId, BuiltinType::Id);
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
+  }
+
   // Builtin type for __objc_yes and __objc_no
   ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
                        SignedCharTy : BoolTy);
 
   ObjCConstantStringType = QualType();
 
   ObjCSuperType = QualType();
 
case BuiltinType::Id:                                                        \
     Align = ElBits;                                                            \
     break;
 #define RVV_PREDICATE_TYPE(Name, Id, SingletonId, ElKind)                      \
   case BuiltinType::Id:                                                        \
     Width = 0;                                                                 \
     Align = 8;                                                                 \
     break;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId)                                       \
+  case BuiltinType::Id:                                                        \
+    Width = 0;                                                                 \
+    Align = 8;                                                                 \
+    break;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
     }
     break;
   case Type::ObjCObjectPointer:
     Width = Target->getPointerWidth(LangAS::Default);
     Align = Target->getPointerAlign(LangAS::Default);
     break;
   case Type::BlockPointer:
     AS = cast<BlockPointerType>(T)->getPointeeType().getAddressSpace();
return {ElBits == 16 ? Float16Ty : (ElBits == 32 ? FloatTy : DoubleTy),    \
             llvm::ElementCount::getScalable(NumEls), NF};
 #define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls)                      \
   case BuiltinType::Id:                                                        \
     return {BoolTy, llvm::ElementCount::getScalable(NumEls), 1};
 #include "clang/Basic/RISCVVTypes.def"
   }
 }
 
+/// getExternrefType - Return a WebAssembly externref type, which represents an
+/// opaque reference to a host value.
+QualType ASTContext::getWebAssemblyExternrefType() const {
+  if (Target->getTriple().isWasm() && Target->hasFeature("reference-types")) {
+#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS)                  \
+  if (BuiltinType::Id == BuiltinType::WasmExternRef)                           \
+    return SingletonId;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
+  }
+  assert(false && "shouldn't try to generate type externref outside WebAssembly target");
+}
+
 /// getScalableVectorType - Return the unique reference to a scalable vector
 /// type of the specified element type and size. VectorType must be a built-in
 /// type.
 QualType ASTContext::getScalableVectorType(QualType EltTy,
                                            unsigned NumElts) const {
   if (Target->hasAArch64SVETypes()) {
     uint64_t EltTySize = getTypeSize(EltTy);
 #define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId, NumEls, ElBits,    \
case BuiltinType::SatULongFract:
       // FIXME: potentially need @encodes for these!
       return ' ';
 
 #define SVE_TYPE(Name, Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
       {
         DiagnosticsEngine &Diags = C->getDiagnostics();
         unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                                 "cannot yet @encode type %0");
         Diags.Report(DiagID) << BT->getName(C->getPrintingPolicy());
         return ' ';
       }
 

clang/lib/AST/ASTImporter.cpp

 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id: \
     return Importer.getToContext().Id##Ty;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
   case BuiltinType::Id:                                                        \
     return Importer.getToContext().SingletonId;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId)                                       \
+  case BuiltinType::Id:                                                        \
+    return Importer.getToContext().SingletonId;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 #define SHARED_SINGLETON_TYPE(Expansion)
 #define BUILTIN_TYPE(Id, SingletonId) \
   case BuiltinType::Id: return Importer.getToContext().SingletonId;
 #include "clang/AST/BuiltinTypes.def"
 
   // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
   // context supports C++.
 

clang/lib/AST/ExprConstant.cpp

 #define SVE_TYPE(Name, Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
     case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
       return GCCTypeClass::None;
 
     case BuiltinType::Dependent:
       llvm_unreachable("unexpected dependent type");
     };
     llvm_unreachable("unexpected placeholder type");
 
   case Type::Enum:

clang/lib/AST/ItaniumMangle.cpp

 #include "clang/Basic/PPCTypes.def"
     // TODO: Check the mangling scheme for RISC-V V.
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
   case BuiltinType::Id:                                                        \
     type_name = Name;                                                          \
     Out << 'u' << type_name.size() << type_name;                               \
     break;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS)          \
+  case BuiltinType::Id:                                                        \
+    type_name = MangledName;                                                   \
+    Out << 'u' << type_name.size() << type_name;                               \
+    break;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
   }
 }
 
 StringRef CXXNameMangler::getCallingConvQualifierName(CallingConv CC) {
   switch (CC) {
   case CC_C:
     return "";
 

clang/lib/AST/MicrosoftMangle.cpp

case BuiltinType::Half:
     else
       Out << "$halff@";
     break;
 
   case BuiltinType::BFloat16:
     mangleArtificialTagType(TTK_Struct, "__bf16", {"__clang"});
     break;
 
+#define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS)          \
+  case BuiltinType::Id:                                                        \
+    mangleArtificialTagType(TTK_Struct, MangledName);                          \
+    mangleArtificialTagType(TTK_Struct, MangledName, {"__clang"});             \
+    break;
+
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
   case BuiltinType::ShortAccum:
   case BuiltinType::Accum:
   case BuiltinType::LongAccum:
   case BuiltinType::UShortAccum:
   case BuiltinType::UAccum:
   case BuiltinType::ULongAccum:
   case BuiltinType::ShortFract:
   case BuiltinType::Fract:
   case BuiltinType::LongFract:
   case BuiltinType::UShortFract:

clang/lib/AST/NSAPI.cpp

 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
   case BuiltinType::BoundMember:
   case BuiltinType::Dependent:
   case BuiltinType::Overload:
   case BuiltinType::UnknownAny:
   case BuiltinType::ARCUnbridgedCast:
   case BuiltinType::Half:
   case BuiltinType::PseudoObject:
   case BuiltinType::BuiltinFn:

clang/lib/AST/PrintfFormatString.cpp

 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 #define SIGNED_TYPE(Id, SingletonId)
 #define UNSIGNED_TYPE(Id, SingletonId)
 #define FLOATING_TYPE(Id, SingletonId)
 #define BUILTIN_TYPE(Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
     // Misc other stuff which doesn't make sense here.
     return false;

clang/lib/AST/Type.cpp

bool Type::isSizelessBuiltinType() const {
   if (const BuiltinType *BT = getAs<BuiltinType>()) {
     switch (BT->getKind()) {
       // SVE Types
 #define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
       return true;
+      // WebAssembly reference types
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
+      return true;
     default:
       return false;
     }
   }
   return false;
 }
 
+bool Type::isWebAssemblyReferenceType() const {
+  return isWebAssemblyExternrefType();
+}
+
+bool Type::isWebAssemblyExternrefType() const {
+  if (const auto *BT = getAs<BuiltinType>())
+    return BT->getKind() == BuiltinType::WasmExternRef;
+  return false;
+}
+
 bool Type::isSizelessType() const { return isSizelessBuiltinType(); }
 
 bool Type::isVLSTBuiltinType() const {
   if (const BuiltinType *BT = getAs<BuiltinType>()) {
     switch (BT->getKind()) {
     case BuiltinType::SveInt8:
     case BuiltinType::SveInt16:
     case BuiltinType::SveInt32:

 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case Id: \
     return #Name;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
   case Id:                                                                     \
     return Name;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId)                                       \
+  case Id:                                                                     \
+    return Name;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
   }
 
   llvm_unreachable("Invalid builtin type.");
 }
 
 QualType QualType::getNonPackExpansionType() const {
   // We never wrap type sugar around a PackExpansionType.
   if (auto *PET = dyn_cast<PackExpansionType>(getTypePtr()))

 #define SVE_TYPE(Name, Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
     case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
     case BuiltinType::BuiltinFn:
     case BuiltinType::NullPtr:
     case BuiltinType::IncompleteMatrixIdx:
     case BuiltinType::OMPArraySection:
     case BuiltinType::OMPArrayShaping:
     case BuiltinType::OMPIterator:
       return false;
     }

clang/lib/AST/TypeLoc.cpp

 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
   case BuiltinType::BuiltinFn:
   case BuiltinType::IncompleteMatrixIdx:
   case BuiltinType::OMPArraySection:
   case BuiltinType::OMPArrayShaping:
   case BuiltinType::OMPIterator:
     return TST_unspecified;
   }
 

clang/lib/CodeGen/CGBuiltin.cpp

case WebAssembly::BI__builtin_wasm_nearest_f64x2:
       break;
     default:
       llvm_unreachable("unexpected builtin ID");
     }
     Value *Value = EmitScalarExpr(E->getArg(0));
     Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType()));
     return Builder.CreateCall(Callee, Value);
   }
+  case WebAssembly::BI__builtin_wasm_ref_null_extern: {
+    Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_ref_null_extern);
+    return Builder.CreateCall(Callee);
+  }
   case WebAssembly::BI__builtin_wasm_swizzle_i8x16: {
     Value *Src = EmitScalarExpr(E->getArg(0));
     Value *Indices = EmitScalarExpr(E->getArg(1));
     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_swizzle);
     return Builder.CreateCall(Callee, {Src, Indices});
   }
   case WebAssembly::BI__builtin_wasm_add_sat_s_i8x16:
   case WebAssembly::BI__builtin_wasm_add_sat_u_i8x16:

clang/lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/OpenCLImageTypes.def"
   llvm::DIType *OCLEventDITy = nullptr;
   llvm::DIType *OCLClkEventDITy = nullptr;
   llvm::DIType *OCLQueueDITy = nullptr;
   llvm::DIType *OCLNDRangeDITy = nullptr;
   llvm::DIType *OCLReserveIDDITy = nullptr;
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
   llvm::DIType *Id##Ty = nullptr;
 #include "clang/Basic/OpenCLExtensionTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) llvm::DIType *SingletonId = nullptr;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 
   /// Cache of previously constructed Types.
   llvm::DenseMap<const void *, llvm::TrackingMDRef> TypeCache;
 
   std::map<llvm::StringRef, llvm::StringRef, std::greater<llvm::StringRef>>
       DebugPrefixMap;
 
   /// Cache that maps VLA types to size expressions for that type,

clang/lib/CodeGen/CGDebugInfo.cpp

#include "clang/Basic/RISCVVTypes.def"
       llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
       llvm::DIType *ElemTy =
           getOrCreateType(Info.ElementType, TheCU->getFile());
 
       auto Align = getTypeAlignIfRequired(BT, CGM.getContext());
       return DBuilder.createVectorType(/*Size=*/0, Align, ElemTy,
                                        SubscriptArray);
     }
+
+#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS)                  \
+  case BuiltinType::Id: {                                                      \
+    if (!SingletonId)                                                          \
+      SingletonId =                                                            \
+          DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,       \
+                                     MangledName, TheCU, TheCU->getFile(), 0); \
+    return SingletonId;                                                        \
+  }
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
+
   case BuiltinType::UChar:
   case BuiltinType::Char_U:
     Encoding = llvm::dwarf::DW_ATE_unsigned_char;
     break;
   case BuiltinType::Char_S:
   case BuiltinType::SChar:
     Encoding = llvm::dwarf::DW_ATE_signed_char;
     break;

clang/lib/CodeGen/CodeGenTypes.cpp

 #include "clang/Basic/RISCVVTypes.def"
     {
       ASTContext::BuiltinVectorTypeInfo Info =
           Context.getBuiltinVectorTypeInfo(cast<BuiltinType>(Ty));
       return llvm::ScalableVectorType::get(ConvertType(Info.ElementType),
                                            Info.EC.getKnownMinValue() *
                                            Info.NumVectors);
     }
+#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS)                  \
+  case BuiltinType::Id: {                                                      \
+    if (BuiltinType::Id == BuiltinType::WasmExternRef)                         \
+      ResultType = CGM.getTargetCodeGenInfo().getWasmExternrefReferenceType(); \
+    else                                                                       \
+      llvm_unreachable("Unexpected wasm reference builtin type!");             \
+  } break;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
     case BuiltinType::Dependent:
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
       llvm_unreachable("Unexpected placeholder builtin type!");
     }
     break;
   }

clang/lib/CodeGen/ItaniumCXXABI.cpp

 #define SVE_TYPE(Name, Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
     case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
     case BuiltinType::ShortAccum:
     case BuiltinType::Accum:
     case BuiltinType::LongAccum:
     case BuiltinType::UShortAccum:
     case BuiltinType::UAccum:
     case BuiltinType::ULongAccum:
     case BuiltinType::ShortFract:
     case BuiltinType::Fract:

clang/lib/CodeGen/TargetInfo.h

virtual llvm::Type *getCUDADeviceBuiltinSurfaceDeviceType() const {
     return nullptr;
   }
   /// Return the device-side type for the CUDA device builtin texture type.
   virtual llvm::Type *getCUDADeviceBuiltinTextureDeviceType() const {
     // By default, no change from the original one.
     return nullptr;
   }
 
+  /// Return the WebAssembly externref reference type.
+  virtual llvm::Type *getWasmExternrefReferenceType() const { return nullptr; }
+
   /// Emit the device-side copy of the builtin surface type.
   virtual bool emitCUDADeviceBuiltinSurfaceDeviceCopy(CodeGenFunction &CGF,
                                                       LValue Dst,
                                                       LValue Src) const {
     // DO NOTHING by default.
     return false;
   }
   /// Emit the device-side copy of the builtin texture type.

clang/lib/CodeGen/TargetInfo.cpp

void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
     }
 
     if (auto *FD = dyn_cast_or_null<FunctionDecl>(D)) {
       llvm::Function *Fn = cast<llvm::Function>(GV);
       if (!FD->doesThisDeclarationHaveABody() && !FD->hasPrototype())
         Fn->addFnAttr("no-prototype");
     }
   }
+
+  /// Return the WebAssembly externref reference type.
+  virtual llvm::Type *getWasmExternrefReferenceType() const override {
+    return llvm::Type::getWasm_ExternrefTy(getABIInfo().getVMContext());
+  }
 };
 
 /// Classify argument of given type \p Ty.
 ABIArgInfo WebAssemblyABIInfo::classifyArgumentType(QualType Ty) const {
   Ty = useFirstFieldIfTransparentUnion(Ty);
 
   if (isAggregateTypeForABI(Ty)) {
     // Records with non-trivial destructors/copy-constructors should not be

clang/lib/Index/USRGeneration.cpp

 #define PPC_VECTOR_TYPE(Name, Id, Size) \
         case BuiltinType::Id: \
           Out << "@BT@" << #Name; break;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) \
         case BuiltinType::Id: \
           Out << "@BT@" << Name; break;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
         case BuiltinType::ShortAccum:
           Out << "@BT@ShortAccum"; break;
         case BuiltinType::Accum:
           Out << "@BT@Accum"; break;
         case BuiltinType::LongAccum:
           Out << "@BT@LongAccum"; break;
         case BuiltinType::UShortAccum:
           Out << "@BT@UShortAccum"; break;

clang/lib/Sema/Sema.cpp

#include "clang/Basic/PPCTypes.def"
   }
 
   if (Context.getTargetInfo().hasRISCVVTypes()) {
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
   addImplicitTypedef(Name, Context.SingletonId);
 #include "clang/Basic/RISCVVTypes.def"
   }
 
+  if (Context.getTargetInfo().getTriple().isWasm() &&
+      Context.getTargetInfo().hasFeature("reference-types")) {
+#define WASM_TYPE(Name, Id, SingletonId)                                       \
+  addImplicitTypedef(Name, Context.SingletonId);
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
+  }
+
   if (Context.getTargetInfo().hasBuiltinMSVaList()) {
     DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
     if (IdResolver.begin(MSVaList) == IdResolver.end())
       PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
   }
 
   DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
   if (IdResolver.begin(BuiltinVaList) == IdResolver.end())

clang/lib/Sema/SemaChecking.cpp

bool Sema::CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
   case llvm::Triple::amdgcn:
     return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
   case llvm::Triple::riscv32:
   case llvm::Triple::riscv64:
     return CheckRISCVBuiltinFunctionCall(TI, BuiltinID, TheCall);
   case llvm::Triple::loongarch32:
   case llvm::Triple::loongarch64:
     return CheckLoongArchBuiltinFunctionCall(TI, BuiltinID, TheCall);
+  case llvm::Triple::wasm32:
+  case llvm::Triple::wasm64:
+    return CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
   }
 }
 
 ExprResult
 Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
                                CallExpr *TheCall) {
   ExprResult TheCallResult(TheCall);
 
bool Sema::CheckSystemZBuiltinFunctionCall(unsigned BuiltinID,
   case SystemZ::BI__builtin_s390_vclfnls:
   case SystemZ::BI__builtin_s390_vcfn:
   case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15; break;
   case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15; break;
   }
   return SemaBuiltinConstantArgRange(TheCall, i, l, u);
 }
 
+bool Sema::CheckWebAssemblyBuiltinFunctionCall(const TargetInfo &TI,
+                                               unsigned BuiltinID,
+                                               CallExpr *TheCall) {
+  switch (BuiltinID) {
+  case WebAssembly::BI__builtin_wasm_ref_null_extern:
+    return BuiltinWasmRefNullExtern(TheCall);
+  }
+
+  return false;
+}
+
 /// SemaBuiltinCpuSupports - Handle __builtin_cpu_supports(char *).
 /// This checks that the target supports __builtin_cpu_supports and
 /// that the string argument is constant and valid.
 static bool SemaBuiltinCpuSupports(Sema &S, const TargetInfo &TI,
                                    CallExpr *TheCall) {
   Expr *Arg = TheCall->getArg(0);
 
   // Check if the argument is a string literal.
static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex) {
   Arg = S.PerformCopyInitialization(Entity, SourceLocation(), Arg);
   if (Arg.isInvalid())
     return true;
 
   E->setArg(ArgIndex, Arg.get());
   return false;
 }
 
+bool Sema::BuiltinWasmRefNullExtern(CallExpr *TheCall) {
+  if (TheCall->getNumArgs() != 0)
+    return true;
+
+  TheCall->setType(Context.getWebAssemblyExternrefType());
+
+  return false;
+}
+
 /// We have a call to a function like __sync_fetch_and_add, which is an
 /// overloaded function based on the pointer type of its first argument.
 /// The main BuildCallExpr routines have already promoted the types of
 /// arguments because all of these calls are prototyped as void(...).
 ///
 /// This function goes through and does final semantic checking for these
 /// builtins, as well as generating any warnings.
 ExprResult

clang/lib/Sema/SemaDecl.cpp

void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
   }
 
   if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
     NewVD->setInvalidDecl();
     return;
   }
 
-  if (!NewVD->hasLocalStorage() && T->isSizelessType()) {
+  if (!NewVD->hasLocalStorage() && T->isSizelessType() &&
+      !T->isWebAssemblyReferenceType()) {
     Diag(NewVD->getLocation(), diag::err_sizeless_nonlocal) << T;
     NewVD->setInvalidDecl();
     return;
   }
 
   if (isVM && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_vm);
     NewVD->setInvalidDecl();

clang/lib/Sema/SemaExpr.cpp

if (Ty->isIncompleteType()) {
     if (Ty->isObjCObjectType())
       return VAK_Invalid;
     return VAK_Valid;
   }
 
   if (Ty.isDestructedType() == QualType::DK_nontrivial_c_struct)
     return VAK_Invalid;
 
+  if (Context.getTargetInfo().getTriple().isWasm() &&
+      Ty->isWebAssemblyReferenceType()) {
+    return VAK_Invalid;
+  }
+
   if (Ty.isCXX98PODType(Context))
     return VAK_Valid;
 
   // C++11 [expr.call]p7:
   //   Passing a potentially-evaluated argument of class type (Clause 9)
   //   having a non-trivial copy constructor, a non-trivial move constructor,
   //   or a non-trivial destructor, with no corresponding parameter,
   //   is conditionally-supported with implementation-defined semantics.

 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
 #define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
 #include "clang/AST/BuiltinTypes.def"
     return false;
 
   // We cannot lower out overload sets; they might validly be resolved
   // by the call machinery.
   case BuiltinType::Overload:
if (lval == Expr::LV_IncompleteVoidType) {
     // Example: "extern void x; void* y = &x;".
     Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
   }
 
   // If the operand has type "type", the result has type "pointer to type".
   if (op->getType()->isObjCObjectType())
     return Context.getObjCObjectPointerType(op->getType());
 
+  if (Context.getTargetInfo().getTriple().isWasm() &&
+      op->getType()->isWebAssemblyReferenceType()) {
+    Diag(OpLoc, diag::err_wasm_ca_reference)
+        << 1 << OrigOp.get()->getSourceRange();
+    return QualType();
+  }
+
   CheckAddressOfPackedMember(op);
 
   return Context.getPointerType(op->getType());
 }
 
 static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
   const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
   if (!DRE)
static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var,
   if (!Invalid && BD && S.LangOpts.OpenMP) {
     if (BuildAndDiagnose) {
       S.Diag(Loc, diag::err_capture_binding_openmp) << Var;
       S.Diag(Var->getLocation(), diag::note_entity_declared_at) << Var;
     }
     Invalid = true;
   }
 
+  if (BuildAndDiagnose && S.Context.getTargetInfo().getTriple().isWasm() &&
+      CaptureType.getNonReferenceType()->isWebAssemblyReferenceType()) {
+    S.Diag(Loc, diag::err_wasm_ca_reference) << 0;
+    Invalid = true;
+  }
+
   // Compute the type of the field that will capture this variable.
   if (ByRef) {
     // C++11 [expr.prim.lambda]p15:
     //   An entity is captured by reference if it is implicitly or
     //   explicitly captured but not captured by copy. It is
     //   unspecified whether additional unnamed non-static data
     //   members are declared in the closure type for entities
     //   captured by reference.

 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 #define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
 #define PLACEHOLDER_TYPE(Id, SingletonId)
 #include "clang/AST/BuiltinTypes.def"
     break;
   }
 
   llvm_unreachable("invalid placeholder type!");
 }

clang/lib/Sema/SemaType.cpp

QualType Sema::BuildPointerType(QualType T,
 
   // In ARC, it is forbidden to build pointers to unqualified pointers.
   if (getLangOpts().ObjCAutoRefCount)
     T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ false);
 
   if (getLangOpts().OpenCL)
     T = deduceOpenCLPointeeAddrSpace(*this, T);
 
+  // In WebAssembly, pointers to reference types are illegal.
+  if (getASTContext().getTargetInfo().getTriple().isWasm() &&
+      T->isWebAssemblyReferenceType()) {
+    Diag(Loc, diag::err_wasm_reference_pr) << 0;
+    return QualType();
+  }
+
   // Build the pointer type.
   return Context.getPointerType(T);
 }
 
 /// Build a reference type.
 ///
 /// \param T The type to which we'll be building a reference.
 ///
QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue,
 
   // In ARC, it is forbidden to build references to unqualified pointers.
   if (getLangOpts().ObjCAutoRefCount)
     T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ true);
 
   if (getLangOpts().OpenCL)
     T = deduceOpenCLPointeeAddrSpace(*this, T);
 
+  // In WebAssembly, references to reference types are illegal.
+  if (getASTContext().getTargetInfo().getTriple().isWasm() &&
+      T->isWebAssemblyReferenceType()) {
+    Diag(Loc, diag::err_wasm_reference_pr) << 1;
+    return QualType();
+  }
+
   // Handle restrict on references.
   if (LValueRef)
     return Context.getLValueReferenceType(T, SpelledAsLValue);
   return Context.getRValueReferenceType(T);
 }
 
 /// Build a Read-only Pipe type.
 ///

clang/lib/Serialization/ASTCommon.cpp

case BuiltinType::Id: \
     ID = PREDEF_TYPE_##Id##_ID; \
     break;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
   case BuiltinType::Id:                                                        \
     ID = PREDEF_TYPE_##Id##_ID;                                                \
     break;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId)                                       \
+  case BuiltinType::Id:                                                        \
+    ID = PREDEF_TYPE_##Id##_ID;                                                \
+    break;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
   case BuiltinType::BuiltinFn:
     ID = PREDEF_TYPE_BUILTIN_FN;
     break;
   case BuiltinType::IncompleteMatrixIdx:
     ID = PREDEF_TYPE_INCOMPLETE_MATRIX_IDX;
     break;
   case BuiltinType::OMPArraySection:
     ID = PREDEF_TYPE_OMP_ARRAY_SECTION;

clang/lib/Serialization/ASTReader.cpp

case PREDEF_TYPE_##Id##_ID: \
       T = Context.Id##Ty; \
       break;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) \
     case PREDEF_TYPE_##Id##_ID: \
       T = Context.SingletonId; \
       break;
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId)                                       \
+  case PREDEF_TYPE_##Id##_ID:                                                  \
+    T = Context.SingletonId;                                                   \
+    break;
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
     }
 
     assert(!T.isNull() && "Unknown predefined type");
     return T.withFastQualifiers(FastQuals);
   }
 
   Index -= NUM_PREDEF_TYPE_IDS;
   assert(Index < TypesLoaded.size() && "Type index out-of-range");

clang/test/CodeGen/WebAssembly/wasm-externref.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +reference-types -o - -emit-llvm %s | FileCheck %s
+
+typedef __externref_t externref_t;
+
+void helper(externref_t);
+
+// CHECK-LABEL: @handle(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OBJ_ADDR:%.*]] = alloca ptr addrspace(10), align 1
+// CHECK-NEXT:    store ptr addrspace(10) [[OBJ:%.*]], ptr [[OBJ_ADDR]], align 1
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr addrspace(10), ptr [[OBJ_ADDR]], align 1
+// CHECK-NEXT:    call void @helper(ptr addrspace(10) [[TMP0]])
+// CHECK-NEXT:    ret void
+//
+void handle(externref_t obj) {
+  helper(obj);
+}

clang/test/CodeGen/builtins-wasm.c

-// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY32
-// RUN: %clang_cc1 -triple wasm64-unknown-unknown -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY64
-// RUN: not %clang_cc1 -triple wasm64-unknown-unknown -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefixes MISSING-SIMD
+// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +reference-types -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY32
+// RUN: %clang_cc1 -triple wasm64-unknown-unknown -target-feature +reference-types -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY64
+// RUN: not %clang_cc1 -triple wasm64-unknown-unknown -target-feature +reference-types -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefixes MISSING-SIMD
 
 // SIMD convenience types
 typedef signed char i8x16 __attribute((vector_size(16)));
 typedef short i16x8 __attribute((vector_size(16)));
 typedef int i32x4 __attribute((vector_size(16)));
 typedef long long i64x2 __attribute((vector_size(16)));
 typedef unsigned char u8x16 __attribute((vector_size(16)));
 typedef unsigned short u16x8 __attribute((vector_size(16)));

 }
 
 f32x4 relaxed_dot_bf16x8_add_f32_f32x4(u16x8 a, u16x8 b, f32x4 c) {
   return __builtin_wasm_relaxed_dot_bf16x8_add_f32_f32x4(a, b, c);
   // WEBASSEMBLY: call <4 x float> @llvm.wasm.relaxed.dot.bf16x8.add.f32
   // WEBASSEMBLY-SAME: <8 x i16> %a, <8 x i16> %b, <4 x float> %c)
   // WEBASSEMBLY-NEXT: ret
 }
+
+__externref_t externref_null() {
+  return __builtin_wasm_ref_null_extern();
+  // WEBASSEMBLY: tail call ptr addrspace(10) @llvm.wasm.ref.null.extern()
+  // WEBASSEMBLY-NEXT: ret
+}

clang/test/CodeGenCXX/wasm-reftypes-mangle.cpp

+// REQUIRES: webassembly-registered-target
+// RUN: %clang_cc1 %s -triple wasm32-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s
+// RUN: %clang_cc1 %s -triple wasm64-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s
+
+// CHECK: _Z2f111externref_t
+void f1(__externref_t) {}

clang/test/CodeGenCXX/wasm-reftypes-typeinfo.cpp

+// REQUIRES: webassembly-registered-target
+// RUN: %clang_cc1 %s -triple wasm32-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s
+// RUN: %clang_cc1 %s -triple wasm64-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s
+
+namespace std {
+class type_info;
+};
+
+auto &externref = typeid(__externref_t);
+
+// CHECK-DAG: @_ZTS11externref_t = {{.*}} c"11externref_t\00"
+// CHECK-DAG: @_ZTI11externref_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTS11externref_t

clang/test/Sema/wasm-refs-and-tables.c

+// RUN: %clang_cc1 -fsyntax-only -verify -triple wasm32 -target-feature +reference-types %s
+
+// Note: As WebAssembly references are sizeless types, we don't exhaustively
+// test for cases covered by sizeless-1.c and similar tests.
+
+// Unlike standard sizeless types, reftype globals are supported.
+__externref_t r1;
+extern __externref_t r2;
+static __externref_t r3;
+
+__externref_t *t1;               // expected-error {{pointers to WebAssembly reference types are illegal}}
+__externref_t **t2;              // expected-error {{pointers to WebAssembly reference types are illegal}}
+__externref_t ******t3;          // expected-error {{pointers to WebAssembly reference types are illegal}}
+static __externref_t t4[3];      // expected-error {{array has sizeless element type '__externref_t'}}
+static __externref_t t5[];       // expected-error {{array has sizeless element type '__externref_t'}}
+static __externref_t t6[] = {0}; // expected-error {{array has sizeless element type '__externref_t'}}
+__externref_t t7[0];             // expected-error {{array has sizeless element type '__externref_t'}}
+static __externref_t t8[0][0];   // expected-error {{array has sizeless element type '__externref_t'}}
+
+static __externref_t table[0]; // expected-error {{array has sizeless element type '__externref_t'}}
+
+struct s {
+  __externref_t f1;       // expected-error {{field has sizeless type '__externref_t'}}
+  __externref_t f2[0];    // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t f3[];     // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t f4[0][0]; // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t *f5;      // expected-error {{pointers to WebAssembly reference types are illegal}}
+  __externref_t ****f6;   // expected-error {{pointers to WebAssembly reference types are illegal}}
+};
+
+union u {
+  __externref_t f1;       // expected-error {{field has sizeless type '__externref_t'}}
+  __externref_t f2[0];    // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t f3[];     // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t f4[0][0]; // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t *f5;      // expected-error {{pointers to WebAssembly reference types are illegal}}
+  __externref_t ****f6;   // expected-error {{pointers to WebAssembly reference types are illegal}}
+};
+
+void illegal_argument_1(__externref_t table[]);     // expected-error {{array has sizeless element type '__externref_t'}}
+void illegal_argument_2(__externref_t table[0][0]); // expected-error {{array has sizeless element type '__externref_t'}}
+void illegal_argument_3(__externref_t *table);      // expected-error {{pointers to WebAssembly reference types are illegal}}
+void illegal_argument_4(__externref_t ***table);    // expected-error {{pointers to WebAssembly reference types are illegal}}
+
+__externref_t *illegal_return_1();   // expected-error {{pointers to WebAssembly reference types are illegal}}
+__externref_t ***illegal_return_2(); // expected-error {{pointers to WebAssembly reference types are illegal}}
+
+void varargs(int, ...);
+
+__externref_t func(__externref_t ref) {
+  &ref; // expected-error {{cannot take address of WebAssembly reference}}
+  int foo = 40;
+  (__externref_t *)(&foo);     // expected-error {{pointers to WebAssembly reference types are illegal}}
+  (__externref_t ****)(&foo);  // expected-error {{pointers to WebAssembly reference types are illegal}}
+  sizeof(ref);                 // expected-error {{invalid application of 'sizeof' to sizeless type '__externref_t'}}
+  sizeof(__externref_t);       // expected-error {{invalid application of 'sizeof' to sizeless type '__externref_t'}}
+  sizeof(__externref_t[0]);    // expected-error {{array has sizeless element type '__externref_t'}}
+  sizeof(__externref_t[0][0]); // expected-error {{array has sizeless element type '__externref_t'}}
+  sizeof(__externref_t *);     // expected-error {{pointers to WebAssembly reference types are illegal}}
+  sizeof(__externref_t ***);   // expected-error {{pointers to WebAssembly reference types are illegal}};
+  // expected-warning@+1 {{'_Alignof' applied to an expression is a GNU extension}}
+  _Alignof(ref);                 // expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
+  _Alignof(__externref_t);       // expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
+  _Alignof(__externref_t[]);     // expected-error {{array has sizeless element type '__externref_t'}}
+  _Alignof(__externref_t[0][0]); // expected-error {{array has sizeless element type '__externref_t'}}
+  _Alignof(__externref_t *);     // expected-error {{pointers to WebAssembly reference types are illegal}}
+  _Alignof(__externref_t ***);   // expected-error {{pointers to WebAssembly reference types are illegal}};
+  varargs(1, ref);               // expected-error {{cannot pass expression of type '__externref_t' to variadic function}}
+
+  return ref;
+}

clang/test/SemaCXX/wasm-refs.cpp

+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -std=gnu++11 -triple wasm32 -Wno-unused-value -target-feature +reference-types %s
+
+// This file tests C++ specific constructs with WebAssembly references and
+// tables. See wasm-refs-and-tables.c for C constructs.
+
+__externref_t ref;
+__externref_t &ref_ref1 = ref; // expected-error {{references to WebAssembly reference types are illegal}}
+__externref_t &ref_ref2(ref);  // expected-error {{references to WebAssembly reference types are illegal}}
+
+static __externref_t table[0];                    // expected-error {{array has sizeless element type '__externref_t'}}
+static __externref_t (&ref_to_table1)[0] = table; // expected-error {{array has sizeless element type '__externref_t'}}
+static __externref_t (&ref_to_table2)[0](table);  // expected-error {{array has sizeless element type '__externref_t'}}
+
+void illegal_argument_1(__externref_t &r); // expected-error {{references to WebAssembly reference types are illegal}}
+void illegal_argument_2(__externref_t (&t)[0]); // expected-error {{array has sizeless element type '__externref_t'}}
+
+__externref_t &illegal_return_1(); // expected-error {{references to WebAssembly reference types are illegal}}
+__externref_t (&illegal_return_2())[0]; // expected-error {{array has sizeless element type '__externref_t'}}
+
+void illegal_throw1() throw(__externref_t);   // expected-error {{sizeless type '__externref_t' is not allowed in exception specification}}
+void illegal_throw2() throw(__externref_t *); // expected-error {{pointers to WebAssembly reference types are illegal}}
+void illegal_throw3() throw(__externref_t &); // expected-error {{references to WebAssembly reference types are illegal}}
+void illegal_throw4() throw(__externref_t[0]); // expected-error {{array has sizeless element type '__externref_t'}}
+
+class RefClass {
+  __externref_t f1;       // expected-error {{field has sizeless type '__externref_t'}}
+  __externref_t f2[0];    // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t f3[];     // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t f4[0][0]; // expected-error {{array has sizeless element type '__externref_t'}}
+  __externref_t *f5;      // expected-error {{pointers to WebAssembly reference types are illegal}}
+  __externref_t ****f6;   // expected-error {{pointers to WebAssembly reference types are illegal}}
+  __externref_t (*f7)[0]; // expected-error {{array has sizeless element type '__externref_t'}}
+};
+
+struct AStruct {};
+
+template <typename T>
+struct TemplatedStruct {
+  T f; // expected-error {{field has sizeless type '__externref_t'}}
+  void foo(T);
+  T bar(void);
+  T arr[0]; // expected-error {{array has sizeless element type '__externref_t'}}
+  T *ptr;   // expected-error {{pointers to WebAssembly reference types are illegal}}
+};
+
+void func() {
+  int foo = 40;
+  static_cast<__externref_t>(foo);      // expected-error {{static_cast from 'int' to '__externref_t' is not allowed}}
+  static_cast<__externref_t *>(&foo);   // expected-error {{pointers to WebAssembly reference types are illegal}}
+  static_cast<int>(ref);                // expected-error {{static_cast from '__externref_t' to 'int' is not allowed}}
+  __externref_t(10);                    // expected-error {{functional-style cast from 'int' to '__externref_t' is not allowed}}
+  int i(ref);                           // expected-error {{cannot initialize a variable of type 'int' with an lvalue of type '__externref_t'}}
+  const_cast<__externref_t[0]>(table);  // expected-error {{array has sizeless element type '__externref_t'}}
+  const_cast<__externref_t *>(table);   // expected-error {{pointers to WebAssembly reference types are illegal}}
+  reinterpret_cast<__externref_t>(foo); // expected-error {{reinterpret_cast from 'int' to '__externref_t' is not allowed}}
+  reinterpret_cast<int>(ref);           // expected-error {{reinterpret_cast from '__externref_t' to 'int' is not allowed}}
+  int iarr[0];
+  reinterpret_cast<__externref_t[0]>(iarr); // expected-error {{array has sizeless element type '__externref_t'}}
+  reinterpret_cast<__externref_t *>(iarr);  // expected-error {{pointers to WebAssembly reference types are illegal}}
+  dynamic_cast<__externref_t>(foo);         // expected-error {{invalid target type '__externref_t' for dynamic_cast; target type must be a reference or pointer type to a defined class}}
+  dynamic_cast<__externref_t *>(&foo);      // expected-error {{pointers to WebAssembly reference types are illegal}}
+
+  TemplatedStruct<__externref_t> ts1;    // expected-note {{in instantiation}}
+  TemplatedStruct<__externref_t *> ts2;  // expected-error {{pointers to WebAssembly reference types are illegal}}
+  TemplatedStruct<__externref_t &> ts3;  // expected-error {{references to WebAssembly reference types are illegal}}
+  TemplatedStruct<__externref_t[0]> ts4; // expected-error {{array has sizeless element type '__externref_t'}}
+
+  auto auto_ref = ref;
+
+  auto fn1 = [](__externref_t x) { return x; };
+  auto fn2 = [](__externref_t *x) { return x; };   // expected-error {{pointers to WebAssembly reference types are illegal}}
+  auto fn3 = [](__externref_t &x) { return x; };   // expected-error {{references to WebAssembly reference types are illegal}}
+  auto fn4 = [](__externref_t x[0]) { return x; }; // expected-error {{array has sizeless element type '__externref_t'}}
+  auto fn5 = [&auto_ref](void) { return true; };   // expected-error {{cannot capture WebAssembly reference}}
+  auto fn6 = [auto_ref](void) { return true; };    // expected-error {{cannot capture WebAssembly reference}}
+  auto fn7 = [&](void) { auto_ref; return true; };                        // expected-error {{cannot capture WebAssembly reference}}
+  auto fn8 = [=](void) { auto_ref; return true; };                        // expected-error {{cannot capture WebAssembly reference}}
+
+  alignof(__externref_t);    // expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
+  alignof(ref);              // expected-warning {{'alignof' applied to an expression is a GNU extension}} expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
+  alignof(__externref_t[0]); // expected-error {{array has sizeless element type '__externref_t'}}
+
+  throw ref;  // expected-error {{cannot throw object of sizeless type '__externref_t'}}
+  throw &ref; // expected-error {{cannot take address of WebAssembly reference}}
+
+  try {
+  } catch (__externref_t) { // expected-error {{cannot catch sizeless type '__externref_t'}}
+  }
+  try {
+  } catch (__externref_t *) { // expected-error {{pointers to WebAssembly reference types are illegal}}
+  }
+  try {
+  } catch (__externref_t &) { // expected-error {{references to WebAssembly reference types are illegal}}
+  }
+  try {
+  } catch (__externref_t[0]) { // expected-error {{array has sizeless element type '__externref_t'}}
+  }
+
+  new __externref_t;    // expected-error {{allocation of sizeless type '__externref_t'}}
+  new __externref_t[0]; // expected-error {{allocation of sizeless type '__externref_t'}}
+
+  delete ref;     // expected-error {{cannot delete expression of type '__externref_t'}}
+}

clang/test/SemaTemplate/address_space-dependent.cpp

 
 template <int I>
 void neg() {
   __attribute__((address_space(I))) int *bounds; // expected-error {{address space is negative}}
 }
 
 template <long int I>
 void tooBig() {
   __attribute__((address_space(I))) int *bounds; // expected-error {{address space is larger than the maximum supported (8388587)}}
 }
 
 template <long int I>
 void correct() {
   __attribute__((address_space(I))) int *bounds;
 }
 
 template <int I, int J>

 
 int main() {
   int __attribute__((address_space(1))) * p1;
   int p = GetAddressSpaceValue(p1);
 
   car<1, 2, 3>(); // expected-note {{in instantiation of function template specialization 'car<1, 2, 3>' requested here}}
   HasASTemplateFields<1> HASTF;
   neg<-1>(); // expected-note {{in instantiation of function template specialization 'neg<-1>' requested here}}
-  correct<0x7FFFEB>();
+  correct<0x7FFFEA>();
   tooBig<8388650>(); // expected-note {{in instantiation of function template specialization 'tooBig<8388650L>' requested here}}
 
   __attribute__((address_space(1))) char *x;
   __attribute__((address_space(2))) char *y;
   cmp<1, 2>(x, y); // expected-note {{in instantiation of function template specialization 'cmp<1, 2>' requested here}}
 
   fooFunction<1> ff;
   ff.get_0(); // expected-note {{in instantiation of member function 'fooFunction<1>::get_0' requested here}}
   ff.qf();
   ff.test3(); // expected-note {{in instantiation of member function 'fooFunction<1>::test3' requested here}}
 
   static_assert(partial_spec_deduce_as<int __attribute__((address_space(3))) *>::value == 3, "address space value has been incorrectly deduced");
 
   return 0;
 }

clang/tools/libclang/CIndex.cpp

#include "clang/Basic/OpenCLExtensionTypes.def"
   case BuiltinType::OCLQueue:
   case BuiltinType::OCLReserveID:
 #define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
+#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#include "clang/Basic/WebAssemblyReferenceTypes.def"
 #define BUILTIN_TYPE(Id, SingletonId)
 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
     break;
 

llvm/include/llvm/IR/Type.h

public:
   static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getX86_AMXPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
   static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
+  static Type *getWasm_ExternrefTy(LLVMContext &C);
+  static Type *getWasm_FuncrefTy(LLVMContext &C);
 
   /// Return a pointer to the current type. This is equivalent to
   /// PointerType::get(Foo, AddrSpace).
   /// TODO: Remove this after opaque pointer transition is complete.
   PointerType *getPointerTo(unsigned AddrSpace = 0) const;
 
 private:
   /// Derived types like structures and arrays are sized iff all of the members

llvm/include/llvm/Transforms/Utils.h

 // this pass is:
 //
 //        FROM CODE                           TO CODE
 //   %X = alloca i32, i32 1                 ret i32 42
 //   store i32 42, i32 *%X
 //   %Y = load i32* %X
 //   ret i32 %Y
 //
-FunctionPass *createPromoteMemoryToRegisterPass();
+FunctionPass *createPromoteMemoryToRegisterPass(bool IsForced = false);
 
 //===----------------------------------------------------------------------===//
 //
 // LoopSimplify - Insert Pre-header blocks into the CFG for every function in
 // the module.  This pass updates dominator information, loop information, and
 // does not add critical edges to the CFG.
 //
 //   AU.addRequiredID(LoopSimplifyID);

llvm/lib/CodeGen/ValueTypes.cpp

Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::f32:     return Type::getFloatTy(Context);
   case MVT::f64:     return Type::getDoubleTy(Context);
   case MVT::f80:     return Type::getX86_FP80Ty(Context);
   case MVT::f128:    return Type::getFP128Ty(Context);
   case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
   case MVT::x86mmx:  return Type::getX86_MMXTy(Context);
   case MVT::x86amx:  return Type::getX86_AMXTy(Context);
   case MVT::i64x8:   return IntegerType::get(Context, 512);
-  case MVT::externref:
-    // pointer to opaque struct in addrspace(10)
-    return PointerType::get(StructType::create(Context), 10);
-  case MVT::funcref:
-    // pointer to i8 addrspace(20)
-    return PointerType::get(Type::getInt8Ty(Context), 20);
+  case MVT::externref: return Type::getWasm_ExternrefTy(Context);
+  case MVT::funcref: return Type::getWasm_FuncrefTy(Context);
   case MVT::v1i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 1);
   case MVT::v2i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 2);
   case MVT::v4i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 4);
   case MVT::v8i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 8);

llvm/lib/IR/Type.cpp

 PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
   return getInt32Ty(C)->getPointerTo(AS);
 }
 
 PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
   return getInt64Ty(C)->getPointerTo(AS);
 }
 
+Type *Type::getWasm_ExternrefTy(LLVMContext &C) {
+  // opaque pointer in addrspace(10)
+  static PointerType *Ty = PointerType::get(C, 10);
+  return Ty;
+}
+
+Type *Type::getWasm_FuncrefTy(LLVMContext &C) {
+  // opaque pointer in addrspace(20)
+  static PointerType *Ty = PointerType::get(C, 20);
+  return Ty;
+}
+
 //===----------------------------------------------------------------------===//
 //                       IntegerType Implementation
 //===----------------------------------------------------------------------===//
 
 IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) {
   assert(NumBits >= MIN_INT_BITS && "bitwidth too small");
   assert(NumBits <= MAX_INT_BITS && "bitwidth too large");
 

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyTargetMachine.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
 #include "Utils/WebAssemblyUtilities.h"
 #include "WebAssembly.h"
+#include "WebAssemblyISelLowering.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "WebAssemblyTargetObjectFile.h"
 #include "WebAssemblyTargetTransformInfo.h"
 #include "llvm/CodeGen/MIRParser/MIParser.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/RegAllocRegistry.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
void WebAssemblyPassConfig::addIRPasses() {
 
   // Expand indirectbr instructions to switches.
   addPass(createIndirectBrExpandPass());
 
   TargetPassConfig::addIRPasses();
 }
 
 void WebAssemblyPassConfig::addISelPrepare() {
+  WebAssemblyTargetMachine *WasmTM = static_cast<WebAssemblyTargetMachine*>(TM);
+  const WebAssemblySubtarget *Subtarget = WasmTM
+            ->getSubtargetImpl(std::string(WasmTM->getTargetCPU()),
+                               std::string(WasmTM->getTargetFeatureString()));
+  if(Subtarget->hasReferenceTypes()) {
+    // We need to remove allocas for reference types
+    addPass(createPromoteMemoryToRegisterPass(true));
+  }
   // Lower atomics and TLS if necessary
   addPass(new CoalesceFeaturesAndStripAtomics(&getWebAssemblyTargetMachine()));
 
   // This is a no-op if atomics are not used in the module
   addPass(createAtomicExpandPass());
 
   TargetPassConfig::addISelPrepare();
 }

llvm/lib/Transforms/Utils/Mem2Reg.cpp

PreservedAnalyses PromotePass::run(Function &F, FunctionAnalysisManager &AM) {
   return PA;
 }
 
 namespace {
 
 struct PromoteLegacyPass : public FunctionPass {
   // Pass identification, replacement for typeid
   static char ID;
+  bool ForcePass; /// If true, forces pass to execute, instead of skipping.
 
-  PromoteLegacyPass() : FunctionPass(ID) {
+  PromoteLegacyPass() : FunctionPass(ID), ForcePass(false) {
+    initializePromoteLegacyPassPass(*PassRegistry::getPassRegistry());
+  }
+  PromoteLegacyPass(bool IsForced) : FunctionPass(ID), ForcePass(IsForced) {
     initializePromoteLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   // runOnFunction - To run this pass, first we calculate the alloca
   // instructions that are safe for promotion, then we promote each one.
   bool runOnFunction(Function &F) override {
-    if (skipFunction(F))
+    if (!ForcePass && skipFunction(F))
       return false;
 
     DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     AssumptionCache &AC =
         getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
     return promoteMemoryToRegister(F, DT, AC);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.setPreservesCFG();
   }
+
 };
 
 } // end anonymous namespace
 
 char PromoteLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(PromoteLegacyPass, "mem2reg", "Promote Memory to "
                                                     "Register",
                       false, false)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_END(PromoteLegacyPass, "mem2reg", "Promote Memory to Register",
                     false, false)
 
 // createPromoteMemoryToRegister - Provide an entry point to create this pass.
-FunctionPass *llvm::createPromoteMemoryToRegisterPass() {
-  return new PromoteLegacyPass();
+FunctionPass *llvm::createPromoteMemoryToRegisterPass(bool IsForced) {
+  return new PromoteLegacyPass(IsForced);
 }