[IR] Add MDBuilder helpers for the new TBAA metadata format

[kosarev]

Summary

The new helpers are supposed to be used in clang to generate TBAA information in the new format proposed in this thread:

http://lists.llvm.org/pipermail/llvm-dev/2017-November/118748.html

[kosarev]

Changed the order of metadata nodes describing structure fields so that the type node comes first. This agrees with the order of nodes in access tags and type nodes in the old format where offsets come after type nodes. Also simplifies adopting the existing code to the new format a bit.

[kosarev]

include/llvm/IR/MDBuilder.h

153–155

We refer to this field in clang's CodeGenTBAA::getBaseTypeInfoHelper(), so I should either fix that function just after committing this patch (and then the first commit won't be buildable) or commit a series of changes so that every revision is buildable. Say, I could temporarily add a getType() method, then switch getBaseTypeInfoHelper() to use it, then rename the field, then fix getBaseTypeInfoHelper() to refer to the new name and then remove getType(). Can you please advice on what way is preferred and whether it would be okay to do that without pre-review?

[kosarev]

Ping.

[hfinkel]

LGTM

include/llvm/IR/MDBuilder.h

153–155

You can commit this patch immediately followed by an update to Clang. You'll still trip some of the buildbots, but in the present configuration, that's acceptable.

[kosarev]

Clang is updated in rL320994.

include/llvm/IR/MDBuilder.h

 
 class APInt;
 template <typename T> class ArrayRef;
 class LLVMContext;
 class Constant;
 class ConstantAsMetadata;
 class MDNode;
 class MDString;
+class Metadata;
 
 class MDBuilder {
   LLVMContext &Context;
 
 public:
   MDBuilder(LLVMContext &context) : Context(context) {}
 
   /// \brief Return the given string as metadata.
public:
   /// \brief Return metadata for a non-root TBAA node with the given name,
   /// parent in the TBAA tree, and value for 'pointsToConstantMemory'.
   MDNode *createTBAANode(StringRef Name, MDNode *Parent,
                          bool isConstant = false);
 
   struct TBAAStructField {
     uint64_t Offset;
     uint64_t Size;
-    MDNode *TBAA;
-    TBAAStructField(uint64_t Offset, uint64_t Size, MDNode *TBAA) :
-      Offset(Offset), Size(Size), TBAA(TBAA) {}
+    MDNode *Type;
+    TBAAStructField(uint64_t Offset, uint64_t Size, MDNode *Type) :
+      Offset(Offset), Size(Size), Type(Type) {}
   };
 
   /// \brief Return metadata for a tbaa.struct node with the given
   /// struct field descriptions.
   MDNode *createTBAAStructNode(ArrayRef<TBAAStructField> Fields);
 
   /// \brief Return metadata for a TBAA struct node in the type DAG
   /// with the given name, a list of pairs (offset, field type in the type DAG).
   MDNode *
   createTBAAStructTypeNode(StringRef Name,
                            ArrayRef<std::pair<MDNode *, uint64_t>> Fields);
 
   /// \brief Return metadata for a TBAA scalar type node with the
   /// given name, an offset and a parent in the TBAA type DAG.
   MDNode *createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
                                    uint64_t Offset = 0);
 
   /// \brief Return metadata for a TBAA tag node with the given
   /// base type, access type and offset relative to the base type.
   MDNode *createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
                                   uint64_t Offset, bool IsConstant = false);
 
+  /// \brief Return metadata for a TBAA type node in the TBAA type DAG with the
+  /// given parent type, size in bytes, type identifier and a list of fields.
+  MDNode *createTBAATypeNode(MDNode *Parent, uint64_t Size, Metadata *Id,
+                             ArrayRef<TBAAStructField> Fields =
+                                 ArrayRef<TBAAStructField>());
+
+  /// \brief Return metadata for a TBAA access tag with the given base type,
+  /// final access type, offset of the access relative to the base type, size of
+  /// the access and flag indicating whether the accessed object can be
+  /// considered immutable for the purposes of the TBAA analysis.
+  MDNode *createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
+                              uint64_t Offset, uint64_t Size,
+                              bool IsImmutable = false);
+
   /// \brief Return metadata containing an irreducible loop header weight.
   MDNode *createIrrLoopHeaderWeight(uint64_t Weight);
 };
 
 } // end namespace llvm
 
 #endif

lib/IR/MDBuilder.cpp

 /// \brief Return metadata for a tbaa.struct node with the given
 /// struct field descriptions.
 MDNode *MDBuilder::createTBAAStructNode(ArrayRef<TBAAStructField> Fields) {
   SmallVector<Metadata *, 4> Vals(Fields.size() * 3);
   Type *Int64 = Type::getInt64Ty(Context);
   for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
     Vals[i * 3 + 0] = createConstant(ConstantInt::get(Int64, Fields[i].Offset));
     Vals[i * 3 + 1] = createConstant(ConstantInt::get(Int64, Fields[i].Size));
-    Vals[i * 3 + 2] = Fields[i].TBAA;
+    Vals[i * 3 + 2] = Fields[i].Type;
   }
   return MDNode::get(Context, Vals);
 }
 
 /// \brief Return metadata for a TBAA struct node in the type DAG
 /// with the given name, a list of pairs (offset, field type in the type DAG).
 MDNode *MDBuilder::createTBAAStructTypeNode(
     StringRef Name, ArrayRef<std::pair<MDNode *, uint64_t>> Fields) {
MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
   ConstantInt *Off = ConstantInt::get(Int64, Offset);
   if (IsConstant) {
     return MDNode::get(Context, {BaseType, AccessType, createConstant(Off),
                                  createConstant(ConstantInt::get(Int64, 1))});
   }
   return MDNode::get(Context, {BaseType, AccessType, createConstant(Off)});
 }
 
+MDNode *MDBuilder::createTBAATypeNode(MDNode *Parent, uint64_t Size,
+                                      Metadata *Id,
+                                      ArrayRef<TBAAStructField> Fields) {
+  SmallVector<Metadata *, 4> Ops(3 + Fields.size() * 3);
+  Type *Int64 = Type::getInt64Ty(Context);
+  Ops[0] = Parent;
+  Ops[1] = createConstant(ConstantInt::get(Int64, Size));
+  Ops[2] = Id;
+  for (unsigned I = 0, E = Fields.size(); I != E; ++I) {
+    Ops[I * 3 + 3] = createConstant(ConstantInt::get(Int64, Fields[I].Offset));
+    Ops[I * 3 + 4] = createConstant(ConstantInt::get(Int64, Fields[I].Size));
+    Ops[I * 3 + 5] = Fields[I].Type;
+  }
+  return MDNode::get(Context, Ops);
+}
+
+MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
+                                       uint64_t Offset, uint64_t Size,
+                                       bool IsImmutable) {
+  IntegerType *Int64 = Type::getInt64Ty(Context);
+  auto *OffsetNode = createConstant(ConstantInt::get(Int64, Offset));
+  auto *SizeNode = createConstant(ConstantInt::get(Int64, Size));
+  if (IsImmutable) {
+    auto *ImmutabilityFlagNode = createConstant(ConstantInt::get(Int64, 1));
+    return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode,
+                                 ImmutabilityFlagNode});
+  }
+  return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode});
+}
+
 MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) {
   SmallVector<Metadata *, 2> Vals(2);
   Vals[0] = createString("loop_header_weight");
   Vals[1] = createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight));
   return MDNode::get(Context, Vals);
 }