[COFF] Add MC support for emitting IMAGE_WEAK_EXTERN_ANTI_DEPENDENCY symbols

[efriedma]

Summary

This is mostly useful for ARM64EC, which uses such symbols extensively.

One interesting quirk of ARM64EC is that we need to be able to emit weak symbols that point at each other (so if either symbol is defined elsewhere, both symbols point at the definition). This required a few changes to the way we handle weak symbols on Windows to avoid recursively visiting weak symbols.

[bcl5980]

llvm/lib/MC/MCExpr.cpp

764

Do we need to limit it to AntiDep only? This code looks means any weak symbol can form a cycle.

[efriedma]

llvm/lib/MC/MCExpr.cpp

764

isWeakExternal should be true for any symbol where we call setIsWeakExternal, which should be all weak symbols on Windows.

The whole recursion this is just much less likely to be relevant for non-AntiDep weak symbols; I've never seen this sort of usage of aliases elsewhere.

[mstorsjo]

Looks reasonable to me, but I don't feel entirely confident about what this does in the common MC layer changes.

llvm/test/MC/COFF/alias.s

27

This looks curious - why does this change here?

llvm/test/MC/COFF/weak-anti-dep.s

24

I guess it'd be good to teach llvm-readobj about this new mode too.

[efriedma]

llvm/test/MC/COFF/alias.s

27

We were resolving ".long weak_aliased_to_external" to external2; the new isWeakExternal() checks prevent us from resolving that, I think. I wasn't really trying for that, specifically... but I think it's the behavior we want? (If a function refers to weak_aliased_to_external, we should allow it to be overridden whether or not the reference is in the same object file.)

llvm/test/MC/COFF/weak-anti-dep.s

24

You mean you want a readable name for the "0x4"? Not sure where that comes from, but I can look.

[mstorsjo]

llvm/test/MC/COFF/alias.s

27

Ah, I see - yeah, that makes sense and sounds like a desireable result indeed.

llvm/test/MC/COFF/weak-anti-dep.s

24

Yeah, llvm-readobj has got a list of its own.

[efriedma]

Rebased on updated llvm-readobj dumping

[epastor]

Looks good to me at a glance. Is this something we should support in MASM as well?

[efriedma]

Is this something we should support in MASM as well?

I don't think Microsoft currently exposes any masm syntax for this, so you'd need to invent your own.

[efriedma]

Ping

[mstorsjo]

In D145208#4192722, @mstorsjo wrote:

Looks reasonable to me, but I don't feel entirely confident about what this does in the common MC layer changes.

Ok, if there's nobody else who wants to chime in here, then I guess this is fine, and I trust your judgement on it. Sorry for not following up earlier.

[aeubanks]

this causes the following to crash

$ cat /tmp/a.ll
target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.16.0"

@"__profc_?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ" = external global [1 x i64]
@"__profd_?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ" = weak global { i64, i64, i64, ptr, ptr, i32, [2 x i16] } { i64 -1867311221809715712, i64 742261418966908927, i64 sub (i64 ptrtoint (ptr @"__profc_?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ" to i64), i64 ptrtoint (ptr @"__profd_?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ" to i64)), ptr @"?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ.local", ptr null, i32 1, [2 x i16] zeroinitializer }

@"?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ.local" = private alias void (ptr, ...), ptr @"?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ"

define weak void @"?__libcpp_verbose_abort@Cr@std@@YAXPEBDZZ"(...) {
entry:
  unreachable
}
$ clang-cl -cc1 -triple x86_64-pc-windows-msvc19.16.0        -faddrsig -o /dev/null /tmp/a.ll -emit-obj
clang-cl: ../../llvm/include/llvm/MC/MCSymbol.h:271: MCSection &llvm::MCSymbol::getSection() const: Assertion `isInSection() && "Invalid accessor!"' failed.                                       

[efriedma]

Update to fix the addrsig crash.

If an alias points to a weak symbol (which is not itself an alias), the alias is referring to the address of the definition, not the symbol itself. Make sure MCExpr::findAssociatedFragment continues to handle that case correctly.

[MaskRay]

llvm/include/llvm/MC/MCDirectives.h

51

Group this with other .weak* directives.

[MaskRay]

llvm/lib/MC/MCExpr.cpp

1003

Add a comment

[efriedma]

Address review comments.

After looking at MCSymbol::getFragment() a bit more, I decided it makes more sense to check isWeakExternal() there, instead of in MCExpr::findAssociatedFragment(). End result is sort of similar because getFragment() is the only caller of findAssociatedFragment(), but the semantics make more sense if the recursion stops earlier.

[hans]

Heads up that this broke linking of Chromium: http://crbug.com/1435480 We don't have any analysis of what's happening yet, though.

[aeubanks]

llvm/lib/MC/MCExpr.cpp

764

in https://crbug.com/1435480 we're getting undefined symbol errors with symbols introduced via whole program devirtualization. removing this change resolves the issue. any thoughts?

the undefined symbol is a hidden alias to a weak_odr alias to a private ptr array constant

[efriedma]

llvm/lib/MC/MCExpr.cpp

764

So you're talking about something like the following, I guess?

baz:
        .word   1
        .weak   bar
.set bar, baz
        .globl  foo
.set foo, bar

Without the patch, we resolve "foo" to point directly at "baz". That seems dubious; we're basically ignoring the linkage of the alias "bar".

With the patch, "foo" is undefined, which is pretty clearly wrong. I'll need to take another look; I guess the code that handles aliases isn't expecting a non-weak alias to point at a weak alias? You can revert in the meantime if you need to...

What I'd expect is that we actually just emit the alias into the object file.

Do you know what code is emitting this construct? It seems like whatever the original IR was trying to do, it wasn't actually getting the effect it wanted.

[efriedma]

llvm/lib/MC/MCExpr.cpp

764

Actually, thinking about it a bit more, I'm tempted to just declare that combining .set with .weak is defined to do whatever horribly broken thing we do right now, and introduce new syntax to represent the actual raw semantics of COFF weak externals. Because I can't find any documentation or tests, and apparently whatever I do is going to break something...

[efriedma]

llvm/lib/MC/MCExpr.cpp

764

For reference, the rules without this patch are roughly:

If a name A is .set to another name B, all reference to A instead refer to B. If B is itself .set, this happens recursively.
If a name A is .set to another name B, and the name B is defined, define A to refer to the same address as B.
If a name A is .set to another name B, the name B is undefined, and A is marked .weak, emit a weak external for A referring to B.

With this patch, the rules for .weak symbols .set to another symbol change:
If a name A is .set to another name B, and A is marked .weak, do not resolve references to the symbol A; just emit a weak external for A referring to B. If another alias refers to A, treat A as if it's undefined.

---

Given that, the possible things we can do here:

• Revert the rules for ".weak" to the original rules; introduce a new ".weak_search_alias" or something like that to get the new semantics.
• Come up with some sort of compromise rule, so a non-weak alias referring to a weak alias produces some sort of definition.
• Declare that the current behavior is correct, and fix whole program devirtualization so it doesn't produce the construct in question. (Which is maybe worth doing anyway, so the resulting IR doesn't depend on confusing edge cases of alias semantics.)

[zequanwu]

Hi, I got a repro of the undefined symbol error.

Commands:

$ clang-cl /c -flto=thin -fsplit-lto-unit -fwhole-program-vtables /GR- /O1 /w main.cpp impl_lite.cc impl.cc coded_stream.cc
$ lld-link /lib /out:full.lib  /WX coded_stream.obj impl.obj impl_lite.obj
$ lld-link main.obj full.lib /out:main.exe /WX

main.cpp213 BDownload

zero_copy_stream.h195 BDownload

impl.h197 BDownload

impl_lite.cc75 BDownload

coded_stream.h222 BDownload

impl_lite.h500 BDownload

coded_stream.cc169 BDownload

impl.cc71 BDownload

[aeubanks]

llvm/lib/MC/MCExpr.cpp

764

I'll take a look at fixing WPD

[aeubanks]

llvm/lib/MC/MCExpr.cpp

764

filed https://github.com/llvm/llvm-project/issues/62439

[efriedma]

Drop change to .weak semantics pending resolution of https://github.com/llvm/llvm-project/issues/62439

llvm/include/llvm/MC/MCDirectives.h

enum MCSymbolAttr {
   MCSA_AltEntry,                ///< .alt_entry (MachO)
   MCSA_PrivateExtern,           ///< .private_extern (MachO)
   MCSA_Protected,               ///< .protected (ELF)
   MCSA_Reference,               ///< .reference (MachO)
   MCSA_Weak,                    ///< .weak
   MCSA_WeakDefinition,          ///< .weak_definition (MachO)
   MCSA_WeakReference,           ///< .weak_reference (MachO)
   MCSA_WeakDefAutoPrivate,      ///< .weak_def_can_be_hidden (MachO)
+  MCSA_WeakAntiDep,             ///< .weak_anti_dep (COFF)
   MCSA_Memtag,                  ///< .memtag (ELF)
 };
 
 enum MCAssemblerFlag {
   MCAF_SyntaxUnified,         ///< .syntax (ARM/ELF)
   MCAF_SubsectionsViaSymbols, ///< .subsections_via_symbols (MachO)
   MCAF_Code16,                ///< .code16 (X86) / .code 16 (ARM)
   MCAF_Code32,                ///< .code32 (X86) / .code 32 (ARM)
   MCAF_Code64                 ///< .code64 (X86)
 };

llvm/include/llvm/MC/MCSymbol.h

protected:
 
   /// True if this symbol is visible outside this translation unit. Note: ELF
   /// uses binding instead of this bit.
   mutable unsigned IsExternal : 1;
 
   /// This symbol is private extern.
   mutable unsigned IsPrivateExtern : 1;
 
+  /// This symbol is weak external.
+  mutable unsigned IsWeakExternal : 1;
+
   /// LLVM RTTI discriminator. This is actually a SymbolKind enumerator, but is
   /// unsigned to avoid sign extension and achieve better bitpacking with MSVC.
   unsigned Kind : 3;
 
   /// True if we have created a relocation that uses this symbol.
   mutable unsigned IsUsedInReloc : 1;
 
   /// This is actually a Contents enumerator, but is unsigned to avoid sign
protected:
   using NameEntryStorageTy = union {
     const StringMapEntry<bool> *NameEntry;
     uint64_t AlignmentPadding;
   };
 
   MCSymbol(SymbolKind Kind, const StringMapEntry<bool> *Name, bool isTemporary)
       : IsTemporary(isTemporary), IsRedefinable(false), IsUsed(false),
         IsRegistered(false), IsExternal(false), IsPrivateExtern(false),
-        Kind(Kind), IsUsedInReloc(false), SymbolContents(SymContentsUnset),
-        CommonAlignLog2(0), Flags(0) {
+        IsWeakExternal(false), Kind(Kind), IsUsedInReloc(false),
+        SymbolContents(SymContentsUnset), CommonAlignLog2(0), Flags(0) {
     Offset = 0;
     FragmentAndHasName.setInt(!!Name);
     if (Name)
       getNameEntryPtr() = Name;
   }
 
   // Provide custom new/delete as we will only allocate space for a name
   // if we need one.
public:
 
   /// Is this a target-specific common-like symbol.
   bool isTargetCommon() const {
     return SymbolContents == SymContentsTargetCommon;
   }
 
   MCFragment *getFragment(bool SetUsed = true) const {
     MCFragment *Fragment = FragmentAndHasName.getPointer();
-    if (Fragment || !isVariable())
+    if (Fragment || !isVariable() || isWeakExternal())
       return Fragment;
+    // If the symbol is a non-weak alias, get information about
+    // the aliasee. (Don't try to resolve weak aliases.)
     Fragment = getVariableValue(SetUsed)->findAssociatedFragment();
     FragmentAndHasName.setPointer(Fragment);
     return Fragment;
   }
 
   bool isExternal() const { return IsExternal; }
   void setExternal(bool Value) const { IsExternal = Value; }
 
   bool isPrivateExtern() const { return IsPrivateExtern; }
   void setPrivateExtern(bool Value) { IsPrivateExtern = Value; }
 
+  bool isWeakExternal() const { return IsWeakExternal; }
+
   /// print - Print the value to the stream \p OS.
   void print(raw_ostream &OS, const MCAsmInfo *MAI) const;
 
   /// dump - Print the value to stderr.
   void dump() const;
 
 protected:
   /// Get the (implementation defined) symbol flags.

llvm/include/llvm/MC/MCSymbolCOFF.h

 class MCSymbolCOFF : public MCSymbol {
   /// This corresponds to the e_type field of the COFF symbol.
   mutable uint16_t Type = 0;
 
   enum SymbolFlags : uint16_t {
     SF_ClassMask = 0x00FF,
     SF_ClassShift = 0,
 
-    SF_WeakExternal = 0x0100,
-    SF_SafeSEH = 0x0200,
+    SF_SafeSEH = 0x0100,
+    SF_WeakExternalCharacteristicsMask = 0x0E00,
+    SF_WeakExternalCharacteristicsShift = 9,
   };
 
 public:
   MCSymbolCOFF(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindCOFF, Name, isTemporary) {}
 
   uint16_t getType() const {
     return Type;
   }
   void setType(uint16_t Ty) const {
     Type = Ty;
   }
 
   uint16_t getClass() const {
     return (getFlags() & SF_ClassMask) >> SF_ClassShift;
   }
   void setClass(uint16_t StorageClass) const {
     modifyFlags(StorageClass << SF_ClassShift, SF_ClassMask);
   }
 
-  bool isWeakExternal() const {
-    return getFlags() & SF_WeakExternal;
-  }
-  void setIsWeakExternal() const {
-    modifyFlags(SF_WeakExternal, SF_WeakExternal);
+  COFF::WeakExternalCharacteristics getWeakExternalCharacteristics() const {
+    return static_cast<COFF::WeakExternalCharacteristics>((getFlags() & SF_WeakExternalCharacteristicsMask) >>
+           SF_WeakExternalCharacteristicsShift);
+  }
+  void setIsWeakExternal(COFF::WeakExternalCharacteristics Characteristics) const {
+    IsWeakExternal = true;
+    modifyFlags(Characteristics << SF_WeakExternalCharacteristicsShift,
+                SF_WeakExternalCharacteristicsMask);
   }
 
   bool isSafeSEH() const {
     return getFlags() & SF_SafeSEH;
   }
   void setIsSafeSEH() const {
     modifyFlags(SF_SafeSEH, SF_SafeSEH);
   }
 
   static bool classof(const MCSymbol *S) { return S->isCOFF(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLCOFF_H

llvm/lib/MC/MCAsmStreamer.cpp

bool MCAsmStreamer::emitSymbolAttribute(MCSymbol *Symbol,
   case MCSA_Cold:
     // Assemblers currently do not support a .cold directive.
   case MCSA_Exported:
     // Non-AIX assemblers currently do not support exported visibility.
     return false;
   case MCSA_Memtag:
     OS << "\t.memtag\t";
     break;
+  case MCSA_WeakAntiDep:
+    OS << "\t.weak_anti_dep\t";
+    break;
   }
 
   Symbol->print(OS, MAI);
   EmitEOL();
 
   return true;
 }
 

llvm/lib/MC/MCELFStreamer.cpp

bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_Reference:
   case MCSA_SymbolResolver:
   case MCSA_PrivateExtern:
   case MCSA_WeakDefinition:
   case MCSA_WeakDefAutoPrivate:
   case MCSA_Invalid:
   case MCSA_IndirectSymbol:
   case MCSA_Exported:
+  case MCSA_WeakAntiDep:
     return false;
 
   case MCSA_NoDeadStrip:
     // Ignore for now.
     break;
 
   case MCSA_ELF_TypeGnuUniqueObject:
     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));

llvm/lib/MC/MCExpr.cpp

 
 bool MCExpr::evaluateAsValue(MCValue &Res, const MCAsmLayout &Layout) const {
   MCAssembler *Assembler = &Layout.getAssembler();
   return evaluateAsRelocatableImpl(Res, Assembler, &Layout, nullptr, nullptr,
                                    true);
 }
 
 static bool canExpand(const MCSymbol &Sym, bool InSet) {
+  if (Sym.isWeakExternal())
+    return false;
+
   const MCExpr *Expr = Sym.getVariableValue();
   const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr);
   if (Inner) {
     if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF)
       return false;
   }
 
   if (InSet)
case Target:
     return cast<MCTargetExpr>(this)->findAssociatedFragment();
 
   case Constant:
     return MCSymbol::AbsolutePseudoFragment;
 
   case SymbolRef: {
     const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(this);
     const MCSymbol &Sym = SRE->getSymbol();
     return Sym.getFragment();
   }
 
   case Unary:
     return cast<MCUnaryExpr>(this)->getSubExpr()->findAssociatedFragment();
 
   case Binary: {
     const MCBinaryExpr *BE = cast<MCBinaryExpr>(this);
     MCFragment *LHS_F = BE->getLHS()->findAssociatedFragment();

llvm/lib/MC/MCMachOStreamer.cpp

bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
   case MCSA_IndirectSymbol:
   case MCSA_Internal:
   case MCSA_Protected:
   case MCSA_Weak:
   case MCSA_Local:
   case MCSA_LGlobal:
   case MCSA_Exported:
   case MCSA_Memtag:
+  case MCSA_WeakAntiDep:
     return false;
 
   case MCSA_Global:
     Symbol->setExternal(true);
     // This effectively clears the undefined lazy bit, in Darwin 'as', although
     // it isn't very consistent because it implements this as part of symbol
     // lookup.
     //

llvm/lib/MC/MCParser/AsmParser.cpp

return isSymbolUsedInExpression(Sym, BE->getLHS()) ||
            isSymbolUsedInExpression(Sym, BE->getRHS());
   }
   case MCExpr::Target:
   case MCExpr::Constant:
     return false;
   case MCExpr::SymbolRef: {
     const MCSymbol &S =
         static_cast<const MCSymbolRefExpr *>(Value)->getSymbol();
-    if (S.isVariable())
+    if (S.isVariable() && !S.isWeakExternal())
       return isSymbolUsedInExpression(Sym, S.getVariableValue());
     return &S == Sym;
   }
   case MCExpr::Unary:
     return isSymbolUsedInExpression(
         Sym, static_cast<const MCUnaryExpr *>(Value)->getSubExpr());
   }
 

llvm/lib/MC/MCParser/COFFAsmParser.cpp

void Initialize(MCAsmParser &Parser) override {
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveEndef>(".endef");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSecRel32>(".secrel32");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSymIdx>(".symidx");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSafeSEH>(".safeseh");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSecIdx>(".secidx");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveLinkOnce>(".linkonce");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveRVA>(".rva");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSymbolAttribute>(".weak");
+    addDirectiveHandler<&COFFAsmParser::ParseDirectiveSymbolAttribute>(".weak_anti_dep");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveCGProfile>(".cg_profile");
 
     // Win64 EH directives.
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartProc>(
                                                                    ".seh_proc");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProc>(
                                                                 ".seh_endproc");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc>(
bool COFFAsmParser::ParseSectionFlags(StringRef SectionName,
   return false;
 }
 
 /// ParseDirectiveSymbolAttribute
 ///  ::= { ".weak", ... } [ identifier ( , identifier )* ]
 bool COFFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
   MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
     .Case(".weak", MCSA_Weak)
+    .Case(".weak_anti_dep", MCSA_WeakAntiDep)
     .Default(MCSA_Invalid);
   assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     while (true) {
       StringRef Name;
 
       if (getParser().parseIdentifier(Name))
         return TokError("expected identifier in directive");

llvm/lib/MC/MCWinCOFFStreamer.cpp

bool MCWinCOFFStreamer::emitSymbolAttribute(MCSymbol *S,
                                             MCSymbolAttr Attribute) {
   auto *Symbol = cast<MCSymbolCOFF>(S);
   getAssembler().registerSymbol(*Symbol);
 
   switch (Attribute) {
   default: return false;
   case MCSA_WeakReference:
   case MCSA_Weak:
-    Symbol->setIsWeakExternal();
+    Symbol->setIsWeakExternal(COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS);
+    Symbol->setExternal(true);
+    break;
+  case MCSA_WeakAntiDep:
+    Symbol->setIsWeakExternal(COFF::IMAGE_WEAK_EXTERN_ANTI_DEPENDENCY);
     Symbol->setExternal(true);
     break;
   case MCSA_Global:
     Symbol->setExternal(true);
     break;
   case MCSA_AltEntry:
     llvm_unreachable("COFF doesn't support the .alt_entry attribute");
   }

llvm/lib/MC/WinCOFFObjectWriter.cpp

if (cast<MCSymbolCOFF>(MCSym).isWeakExternal()) {
     }
 
     Sym->Other = WeakDefault;
 
     // Setup the Weak External auxiliary symbol.
     Sym->Aux.resize(1);
     memset(&Sym->Aux[0], 0, sizeof(Sym->Aux[0]));
     Sym->Aux[0].AuxType = ATWeakExternal;
-    Sym->Aux[0].Aux.WeakExternal.TagIndex = 0;
+    Sym->Aux[0].Aux.WeakExternal.TagIndex = 0; // Filled in later
     Sym->Aux[0].Aux.WeakExternal.Characteristics =
-        COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS;
+        cast<MCSymbolCOFF>(MCSym).getWeakExternalCharacteristics();
   } else {
     if (!Base)
       Sym->Data.SectionNumber = COFF::IMAGE_SYM_ABSOLUTE;
     else
       Sym->Section = Sec;
     Local = Sym;
   }
 

llvm/test/MC/COFF/addrsig.s

 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-win32 %s -o - | llvm-readobj -S --symbols --sd --addrsig - | FileCheck %s
 
 // CHECK:      Name: .llvm_addrsig
 // CHECK-NEXT: VirtualSize: 0x0
 // CHECK-NEXT: VirtualAddress: 0x0
-// CHECK-NEXT: RawDataSize: 4
+// CHECK-NEXT: RawDataSize: 6
 // CHECK-NEXT: PointerToRawData:
 // CHECK-NEXT: PointerToRelocations: 0x0
 // CHECK-NEXT: PointerToLineNumbers: 0x0
 // CHECK-NEXT: RelocationCount: 0
 // CHECK-NEXT: LineNumberCount: 0
 // CHECK-NEXT: Characteristics [ (0x100800)
 // CHECK-NEXT:   IMAGE_SCN_ALIGN_1BYTES (0x100000)
 // CHECK-NEXT:   IMAGE_SCN_LNK_REMOVE (0x800)

 // CHECK-NOT:  Name:
 // CHECK: }
 
 // CHECK:      Addrsig [
 // CHECK-NEXT:   Sym: g1 (8)
 // CHECK-NEXT:   Sym: g3 (11)
 // CHECK-NEXT:   Sym: local (10)
 // CHECK-NEXT:   Sym: .data (2)
+// CHECK-NEXT:   Sym: weak_sym (12)
+// CHECK-NEXT:   Sym: .data (2)
 // CHECK-NEXT: ]
 
 .globl g1
 
 .addrsig
 .addrsig_sym g1
 .globl g2
 .addrsig_sym g3
 .addrsig_sym local
 .addrsig_sym .Llocal
 .addrsig_sym .Lunseen
 .addrsig_sym unseen
 
 local:
 .globl g3
 
 .data
 .Llocal:
+
+.weak weak_sym
+weak_sym:
+.addrsig_sym weak_sym
+
+.set .Lalias_weak_sym, weak_sym
+.addrsig_sym .Lalias_weak_sym

llvm/test/MC/COFF/alias.s

// Generate relocs against the above aliases.
         .long global_aliased_to_external
         .long global_aliased_to_local
         .long weak_aliased_to_external
 
 // CHECK:      Relocations [
 // CHECK:        0x0 IMAGE_REL_I386_DIR32 external_aliased_to_local
 // CHECK:        0x4 IMAGE_REL_I386_DIR32 external1
 // CHECK:        0x8 IMAGE_REL_I386_DIR32 global_aliased_to_local
-// CHECK:        0xC IMAGE_REL_I386_DIR32 external2
+// CHECK:        0xC IMAGE_REL_I386_DIR32 weak_aliased_to_external
 // CHECK:      ]
 // CHECK:      Symbols [
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: .text
 // CHECK-NEXT:     Value: 0
 // CHECK-NEXT:     Section: .text (1)
 // CHECK-NEXT:     BaseType: Null (0x0)
 // CHECK-NEXT:     ComplexType: Null (0x0)

llvm/test/MC/COFF/weak-anti-dep.s

+// RUN: llvm-mc -filetype=obj -triple x86_64-pc-win32 %s | llvm-readobj --symbols - | FileCheck %s
+
+// CHECK:       Symbol {
+// CHECK-NEXT:    Name: .text
+// CHECK:       Symbol {
+// CHECK-NEXT:    Name: .data
+// CHECK:       Symbol {
+// CHECK-NEXT:    Name: .bss
+
+.weak_anti_dep a
+a = b
+
+// CHECK:       Symbol {
+// CHECK-NEXT:    Name: a
+// CHECK-NEXT:    Value: 0
+// CHECK-NEXT:    Section: IMAGE_SYM_UNDEFINED (0)
+// CHECK-NEXT:    BaseType: Null (0x0)
+// CHECK-NEXT:    ComplexType: Null (0x0)
+// CHECK-NEXT:    StorageClass: WeakExternal (0x69)
+// CHECK-NEXT:    AuxSymbolCount: 1
+// CHECK-NEXT:    AuxWeakExternal {
+// CHECK-NEXT:      Linked: b (8)
+// CHECK-NEXT:      Search: AntiDependency (0x4)
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: b
+// CHECK-NEXT:    Value: 0
+// CHECK-NEXT:    Section: IMAGE_SYM_UNDEFINED (0)
+// CHECK-NEXT:    BaseType: Null (0x0)
+// CHECK-NEXT:    ComplexType: Null (0x0)
+// CHECK-NEXT:    StorageClass: External (0x2)
+// CHECK-NEXT:    AuxSymbolCount: 0
+// CHECK-NEXT:  }
+
+
+.weak_anti_dep r1
+.weak_anti_dep r2
+r1 = r2
+r2 = r1
+
+
+// CHECK:       Symbol {
+// CHECK-NEXT:    Name: r1
+// CHECK-NEXT:    Value: 0
+// CHECK-NEXT:    Section: IMAGE_SYM_UNDEFINED (0)
+// CHECK-NEXT:    BaseType: Null (0x0)
+// CHECK-NEXT:    ComplexType: Null (0x0)
+// CHECK-NEXT:    StorageClass: WeakExternal (0x69)
+// CHECK-NEXT:    AuxSymbolCount: 1
+// CHECK-NEXT:    AuxWeakExternal {
+// CHECK-NEXT:      Linked: r2 (11)
+// CHECK-NEXT:      Search: AntiDependency (0x4)
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: r2
+// CHECK-NEXT:    Value: 0
+// CHECK-NEXT:    Section: IMAGE_SYM_UNDEFINED (0)
+// CHECK-NEXT:    BaseType: Null (0x0)
+// CHECK-NEXT:    ComplexType: Null (0x0)
+// CHECK-NEXT:    StorageClass: WeakExternal (0x69)
+// CHECK-NEXT:    AuxSymbolCount: 1
+// CHECK-NEXT:    AuxWeakExternal {
+// CHECK-NEXT:      Linked: r1 (9)
+// CHECK-NEXT:      Search: AntiDependency (0x4)
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }