Fix uninitialized pointer members in MC

[LuoYuanke]

LGTM

[akshaykhadse]

In D148421#4272573, @LuoYuanke wrote:

LGTM

I was not able to reproduce the failure from the Buildable 225819 locally. Is this an issue?

llvm/include/llvm/CodeGen/MachineSSAContext.h

 }
 inline unsigned pred_size(const MachineBasicBlock *BB) {
   return BB->pred_size();
 }
 inline auto instrs(const MachineBasicBlock &BB) { return BB.instrs(); }
 
 template <> class GenericSSAContext<MachineFunction> {
   const MachineRegisterInfo *RegInfo = nullptr;
-  MachineFunction *MF;
+  MachineFunction *MF = nullptr;
 
 public:
   using BlockT = MachineBasicBlock;
   using FunctionT = MachineFunction;
   using InstructionT = MachineInstr;
   using ValueRefT = Register;
   using ConstValueRefT = Register;
   static const Register ValueRefNull;

llvm/include/llvm/MC/MCContext.h

private:
   /// The name of the Segment where Swift5 Reflection Section data will be
   /// outputted
   StringRef Swift5ReflectionSegmentName;
 
   /// The triple for this object.
   Triple TT;
 
   /// The SourceMgr for this object, if any.
-  const SourceMgr *SrcMgr;
+  const SourceMgr *SrcMgr = nullptr;
 
   /// The SourceMgr for inline assembly, if any.
   std::unique_ptr<SourceMgr> InlineSrcMgr;
   std::vector<const MDNode *> LocInfos;
 
   DiagHandlerTy DiagHandler;
 
   /// The MCAsmInfo for this target.
-  const MCAsmInfo *MAI;
+  const MCAsmInfo *MAI = nullptr;
 
   /// The MCRegisterInfo for this target.
-  const MCRegisterInfo *MRI;
+  const MCRegisterInfo *MRI = nullptr;
 
   /// The MCObjectFileInfo for this target.
-  const MCObjectFileInfo *MOFI;
+  const MCObjectFileInfo *MOFI = nullptr;
 
   /// The MCSubtargetInfo for this target.
-  const MCSubtargetInfo *MSTI;
+  const MCSubtargetInfo *MSTI = nullptr;
 
   std::unique_ptr<CodeViewContext> CVContext;
 
   /// Allocator object used for creating machine code objects.
   ///
   /// We use a bump pointer allocator to avoid the need to track all allocated
   /// objects.
   BumpPtrAllocator Allocator;

llvm/include/llvm/MC/MCFragment.h

class MCAlignFragment : public MCFragment {
   /// The size of the integer (in bytes) of \p Value.
   unsigned ValueSize;
 
   /// The maximum number of bytes to emit; if the alignment
   /// cannot be satisfied in this width then this fragment is ignored.
   unsigned MaxBytesToEmit;
 
   /// When emitting Nops some subtargets have specific nop encodings.
-  const MCSubtargetInfo *STI;
+  const MCSubtargetInfo *STI = nullptr;
 
 public:
   MCAlignFragment(Align Alignment, int64_t Value, unsigned ValueSize,
                   unsigned MaxBytesToEmit, MCSection *Sec = nullptr)
       : MCFragment(FT_Align, false, Sec), Alignment(Alignment), EmitNops(false),
         Value(Value), ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
 
   Align getAlignment() const { return Alignment; }

llvm/include/llvm/MC/MCParser/MCAsmParserExtension.h

 namespace llvm {
 
 class Twine;
 
 /// Generic interface for extending the MCAsmParser,
 /// which is implemented by target and object file assembly parser
 /// implementations.
 class MCAsmParserExtension {
-  MCAsmParser *Parser;
+  MCAsmParser *Parser = nullptr;
 
 protected:
   MCAsmParserExtension();
 
   // Helper template for implementing static dispatch functions.
   template<typename T, bool (T::*Handler)(StringRef, SMLoc)>
   static bool HandleDirective(MCAsmParserExtension *Target,
                               StringRef Directive,

llvm/include/llvm/MC/MCPseudoProbe.h

public:
 
   // Root node has a GUID 0.
   bool isRoot() const { return Guid == 0; }
   InlinedProbeTreeMap &getChildren() { return Children; }
   const InlinedProbeTreeMap &getChildren() const { return Children; }
   std::vector<ProbeType> &getProbes() { return Probes; }
   void addProbes(ProbeType Probe) { Probes.push_back(Probe); }
   // Caller node of the inline site
-  MCPseudoProbeInlineTreeBase<ProbeType, DerivedProbeInlineTreeType> *Parent;
+  MCPseudoProbeInlineTreeBase<ProbeType, DerivedProbeInlineTreeType> *Parent =
+      nullptr;
   DerivedProbeInlineTreeType *getOrAddNode(const InlineSite &Site) {
     auto Ret = Children.emplace(
         Site, std::make_unique<DerivedProbeInlineTreeType>(Site));
     Ret.first->second->Parent = this;
     return Ret.first->second.get();
   };
 };
 

llvm/include/llvm/MC/MCWinEH.h

struct FrameInfo {
   };
   MapVector<MCSymbol *, Epilog> EpilogMap;
 
   // For splitting unwind info of large functions
   struct Segment {
     int64_t Offset;
     int64_t Length;
     bool HasProlog;
-    MCSymbol *Symbol;
+    MCSymbol *Symbol = nullptr;
     // Map an Epilog's symbol to its offset within the function.
     MapVector<MCSymbol *, int64_t> Epilogs;
 
     Segment(int64_t Offset, int64_t Length, bool HasProlog = false)
         : Offset(Offset), Length(Length), HasProlog(HasProlog) {}
   };
 
   std::vector<Segment> Segments;

llvm/include/llvm/Object/COFF.h

public:
   getTableEntry(const coff_resource_dir_table &Table, uint32_t Index);
 
   Expected<StringRef> getContents(const coff_resource_data_entry &Entry);
 
 private:
   BinaryByteStream BBS;
 
   SectionRef Section;
-  const COFFObjectFile *Obj;
+  const COFFObjectFile *Obj = nullptr;
 
   std::vector<const coff_relocation *> Relocs;
 
   Expected<const coff_resource_dir_table &> getTableAtOffset(uint32_t Offset);
   Expected<const coff_resource_dir_entry &>
   getTableEntryAtOffset(uint32_t Offset);
   Expected<const coff_resource_data_entry &>
   getDataEntryAtOffset(uint32_t Offset);

llvm/lib/MC/WasmObjectWriter.cpp

static void patchI64(raw_pwrite_stream &Stream, uint64_t Value,
   Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
 }
 
 bool isDwoSection(const MCSection &Sec) {
   return Sec.getName().endswith(".dwo");
 }
 
 class WasmObjectWriter : public MCObjectWriter {
-  support::endian::Writer *W;
+  support::endian::Writer *W = nullptr;
 
   /// The target specific Wasm writer instance.
   std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
 
   // Relocations for fixing up references in the code section.
   std::vector<WasmRelocationEntry> CodeRelocations;
   // Relocations for fixing up references in the data section.
   std::vector<WasmRelocationEntry> DataRelocations;

llvm/lib/MC/WinCOFFObjectWriter.cpp

public:
   section_map SectionMap;
   symbol_map SymbolMap;
 
   symbol_list WeakDefaults;
 
   bool UseBigObj;
   bool UseOffsetLabels = false;
 
-  MCSectionCOFF *AddrsigSection;
+  MCSectionCOFF *AddrsigSection = nullptr;
 
   MCSectionCOFF *CGProfileSection = nullptr;
 
   WinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,
                       raw_pwrite_stream &OS);
 
   void reset() override {
     memset(&Header, 0, sizeof(Header));