Rebased PNaCl localmods in LLVM to 223109

include/llvm/Bitcode/NaCl/NaClBitcodeValueDist.h

+//===-- NaClBitcodeValueDist.h ---------------------------------------------===//
+//      Defines distribution maps to separate out values at each index
+//      in a bitcode record.
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BITCODE_NACL_NACLBITCODEVALUEDIST_H
+#define LLVM_BITCODE_NACL_NACLBITCODEVALUEDIST_H
+
+#include "llvm/Bitcode/NaCl/NaClBitcodeDist.h"
+
+namespace llvm {
+
+/// Defines the value index cutoff where we no longer track values associated
+/// with specific value indices of bitcode records.
+static const unsigned NaClValueIndexCutoff = 6;
+
+/// Defines an (inclusive) range of values in a bitcode record,
+/// defined by the given pair of values. Note that values are stored
+/// as ranges. For small values, each value is in a separate range, so
+/// that potential constants for abbreviations can be found. For
+/// larger values, values are coalesced together into multiple element
+/// ranges, since we don't look for constants and are only interested
+/// in the overall distribution of values.
+typedef std::pair<NaClBitcodeDistValue,
+                  NaClBitcodeDistValue> NaClValueRangeType;
+
+/// Models a range index. Ranges are encoded as a consecutive sequence
+/// of indices, starting at zero. The actual ranges chosen to
+/// represent bitcode records are internal, and is defined by function
+/// GetValueRange index below.
+typedef NaClBitcodeDistValue NaClValueRangeIndexType;
+
+/// Converts a bitcode record value to the corresponding range index that
+/// contains the value.
+NaClValueRangeIndexType GetNaClValueRangeIndex(NaClBitcodeDistValue Value);
+
+/// Converts a range index into the corresponding range of values.
+NaClValueRangeType GetNaClValueRange(NaClValueRangeIndexType RangeIndex);
+
+/// Defines the distribution of range indices.
+class NaClBitcodeValueDistElement : public NaClBitcodeDistElement {
+  NaClBitcodeValueDistElement(const NaClBitcodeValueDistElement&)
+  LLVM_DELETED_FUNCTION;
+  void operator=(const NaClBitcodeValueDistElement&) LLVM_DELETED_FUNCTION;
+
+public:
+  static bool classof(const NaClBitcodeDistElement *Element) {
+    return Element->getKind() >= RDE_ValueDist &&
+        Element->getKind() < RDE_ValueDistLast;
+  }
+
+  NaClBitcodeValueDistElement()
+      : NaClBitcodeDistElement(RDE_ValueDist)
+  {}
+
+  static NaClBitcodeValueDistElement Sentinel;
+
+  virtual ~NaClBitcodeValueDistElement();
+
+  virtual NaClBitcodeDistElement *CreateElement(
+      NaClBitcodeDistValue Value) const;
+
+  /// Returns the number of instances, normalized over the
+  /// range of values, using a uniform distribution.
+  virtual double GetImportance(NaClBitcodeDistValue Value) const;
+
+  virtual const char *GetTitle() const;
+
+  virtual const char *GetValueHeader() const;
+
+  virtual void PrintRowValue(raw_ostream &Stream,
+                             NaClBitcodeDistValue Value,
+                             const NaClBitcodeDist *Distribution) const;
+};
+
+/// Defines the distribution of values for a set of value indices for
+/// bitcode records.
+class NaClBitcodeValueDist : public NaClBitcodeDist {
+  NaClBitcodeValueDist(const NaClBitcodeValueDist&) LLVM_DELETED_FUNCTION;
+  void operator=(const NaClBitcodeValueDist&) LLVM_DELETED_FUNCTION;
+
+public:
+  static bool classof(const NaClBitcodeDist *Dist) {
+    return Dist->getKind() >= RD_ValueDist &&
+        Dist->getKind() < RD_ValueDistLast;
+  }
+
+  /// Builds a value distribution for the given set of value indices.
+  /// If AllRemainingIndices is false, only value Index is considered.
+  /// Otherwise, builds a value distribution for all values stored in
+  /// record value indices >= Index.
+  explicit NaClBitcodeValueDist(unsigned Index,
+                                bool AllRemainingIndices=false);
+
+  virtual ~NaClBitcodeValueDist();
+
+  unsigned GetIndex() const {
+    return Index;
+  }
+
+  bool HoldsAllRemainingIndices() const {
+    return AllRemainingIndices;
+  }
+
+  virtual void GetValueList(const NaClBitcodeRecord &Record,
+                            ValueListType &ValueList) const;
+
+private:
+  // The range index being tracked.
+  unsigned Index;
+
+  // If true, then tracks all indices >= Index. Otherwise only Index.
+  bool AllRemainingIndices;
+};
+
+/// Defines the value distribution for each value index in corresponding
+/// bitcode records. This is a helper class used to separate each element
+/// in the bitcode record, so that we can determine the proper abbreviation
+/// for each element.
+class NaClBitcodeValueIndexDistElement : public NaClBitcodeDistElement {
+  NaClBitcodeValueIndexDistElement(
+      const NaClBitcodeValueIndexDistElement&) LLVM_DELETED_FUNCTION;
+  void operator=(
+      const NaClBitcodeValueIndexDistElement&) LLVM_DELETED_FUNCTION;
+
+public:
+  static bool classof(const NaClBitcodeDistElement *Element) {
+    return Element->getKind() <= RDE_ValueIndexDist &&
+        Element->getKind() < RDE_ValueIndexDistLast;
+  }
+
+  explicit NaClBitcodeValueIndexDistElement(unsigned Index=0)
+      : NaClBitcodeDistElement(RDE_ValueIndexDist),
+        ValueDist(Index) {
+    NestedDists.push_back(&ValueDist);
+  }
+
+  static NaClBitcodeValueIndexDistElement Sentinel;
+
+  virtual ~NaClBitcodeValueIndexDistElement();
+
+  virtual NaClBitcodeDistElement *CreateElement(
+      NaClBitcodeDistValue Value) const;
+
+  virtual void GetValueList(const NaClBitcodeRecord &Record,
+                            ValueListType &ValueList) const;
+
+  virtual double GetImportance(NaClBitcodeDistValue Value) const;
+
+  virtual void AddRecord(const NaClBitcodeRecord &Record);
+
+  virtual const char *GetTitle() const;
+
+  virtual const char *GetValueHeader() const;
+
+  virtual void PrintRowValue(raw_ostream &Stream,
+                             NaClBitcodeDistValue Value,
+                             const NaClBitcodeDist *Distribution) const;
+
+  virtual const SmallVectorImpl<NaClBitcodeDist*> *
+  GetNestedDistributions() const;
+
+  NaClBitcodeValueDist &GetValueDist() {
+    return ValueDist;
+  }
+
+private:
+  // Nested blocks used by GetNestedDistributions.
+  SmallVector<NaClBitcodeDist*, 1> NestedDists;
+
+  // The value distribution associated with the given index.
+  NaClBitcodeValueDist ValueDist;
+};
+
+}
+
+#endif