[Clang][NFC] Add default `getBFloat16Mangling` impl

[Pierre-vh]

Summary

All targets that currently implement __bf16 use the exact same mangled name.
Reduce code duplication by adding that name to the default implementation, like it's done in e.g. getLongDoubleMangling and getFloat128Mangling

Depends on D139398

[jcranmer-intel]

I don't normally handle name mangling, so I can't comment too much here, but I will note that Itanium ABI is planning on using DF16b for std::bfloat16_t: https://github.com/itanium-cxx-abi/cxx-abi/pull/147

[Pierre-vh]

In D139608#3982494, @jcranmer-intel wrote:

I don't normally handle name mangling, so I can't comment too much here, but I will note that Itanium ABI is planning on using DF16b for std::bfloat16_t: https://github.com/itanium-cxx-abi/cxx-abi/pull/147

This is just a NFC so if we're sure targets will soon start to use different mangled names then I can just abandon the commit
I just proposed this change because currently there's no reason not to have a default value for this function

[Pierre-vh]

Ping? it's a small NFC and if it's not desired I don't mind abandoning it; I'd just like to remove this diff from the queue.

[stuij]

I went back and forth on this for a bit. There's a review outstanding to change the mangling name for X86: https://reviews.llvm.org/D136919 to align with the C++23 std::bfloat16_t issue from above. I settled on preferring to be conservative, and not risk at some point accidentally opting an arch into a name that doesn't conform with their ABI.

[Pierre-vh]

Makes sense to abandon this given that D136919 exists

clang/include/clang/Basic/TargetInfo.h

public:
   virtual const char *getFloat128Mangling() const { return "g"; }
 
   /// Return the mangled code of __ibm128.
   virtual const char *getIbm128Mangling() const {
     llvm_unreachable("ibm128 not implemented on this target");
   }
 
   /// Return the mangled code of bfloat.
-  virtual const char *getBFloat16Mangling() const {
-    llvm_unreachable("bfloat not implemented on this target");
-  }
+  virtual const char *getBFloat16Mangling() const { return "u6__bf16"; }
 
   /// Return the value for the C99 FLT_EVAL_METHOD macro.
   virtual LangOptions::FPEvalMethodKind getFPEvalMethod() const {
     return LangOptions::FPEvalMethodKind::FEM_Source;
   }
 
   virtual bool supportSourceEvalMethod() const { return true; }
 

clang/lib/Basic/Targets/AArch64.h

public:
 
   StringRef getConstraintRegister(StringRef Constraint,
                                   StringRef Expression) const override {
     return Expression;
   }
 
   int getEHDataRegisterNumber(unsigned RegNo) const override;
 
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
   bool hasInt128Type() const override;
 
   bool hasBitIntType() const override { return true; }
 };
 
 class LLVM_LIBRARY_VISIBILITY AArch64leTargetInfo : public AArch64TargetInfo {
 public:
   AArch64leTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);

clang/lib/Basic/Targets/AMDGPU.h

uint64_t getPointerAlignV(LangAS AddrSpace) const override {
     return getPointerWidthV(AddrSpace);
   }
 
   uint64_t getMaxPointerWidth() const override {
     return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
   }
 
   bool hasBFloat16Type() const override { return isAMDGCN(getTriple()); }
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
 
   const char *getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
     return std::nullopt;
   }

clang/lib/Basic/Targets/ARM.h

public:
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override;
 
   int getEHDataRegisterNumber(unsigned RegNo) const override;
 
   bool hasSjLjLowering() const override;
 
   bool hasBitIntType() const override { return true; }
-
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
 };
 
 class LLVM_LIBRARY_VISIBILITY ARMleTargetInfo : public ARMTargetInfo {
 public:
   ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 };

clang/lib/Basic/Targets/NVPTX.h

CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     // a host function.
     if (HostTarget)
       return HostTarget->checkCallingConvention(CC);
     return CCCR_Warning;
   }
 
   bool hasBitIntType() const override { return true; }
   bool hasBFloat16Type() const override { return true; }
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
 };
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_NVPTX_H

clang/lib/Basic/Targets/X86.h

uint64_t getPointerWidthV(LangAS AS) const override {
     if (TargetAddrSpace == ptr64)
       return 64;
     return PointerWidth;
   }
 
   uint64_t getPointerAlignV(LangAS AddrSpace) const override {
     return getPointerWidthV(AddrSpace);
   }
-
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
 };
 
 // X86-32 generic target
 class LLVM_LIBRARY_VISIBILITY X86_32TargetInfo : public X86TargetInfo {
 public:
   X86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : X86TargetInfo(Triple, Opts) {
     DoubleAlign = LongLongAlign = 32;