Use Value::misc to store strings

This allows strings < 23 characters (up from 16) to be stored directly
in Value. On a NixOS 19.03 system configuration evaluation, this
allows 1060588 out of 1189295 (89%) strings to be stored in Value.

src/libexpr/attr-set.cc

@@ -12,7 +12,7 @@ namespace nix {
    Bindings structure. */
 Ptr<Bindings> Bindings::allocBindings(size_t capacity)
 {
-    if (capacity >= 1UL << Object::miscBits)
+    if (capacity >= 1UL << Object::miscBytes * 8)
         throw Error("attribute set of size %d is too big", capacity);
     return gc.alloc<Bindings>(Bindings::wordsFor(capacity), capacity);
 }

src/libexpr/eval.cc

@@ -497,10 +497,9 @@ LocalNoInline(void addErrorPrefix(Error & e, const char * s, const string & s2,
 void mkString(Value & v, const char * s)
 {
     auto len = strlen(s); // FIXME: only need to know if > short
-    if (len < WORD_SIZE * 2) {
+    if (len < WORD_SIZE * 2 + Object::miscBytes)
-        strcpy((char *) &v.string, s);
+        v.setShortString(s);
-        v.type = tShortString;
+    else
-    } else
         mkStringNoCopy(v, dupString(s));
 }
 

src/libexpr/gc.hh

@@ -51,17 +51,16 @@ struct Object
     friend class GC;
 
 public:
-    constexpr static unsigned int miscBits = 58;
+    constexpr static size_t miscBytes = 7;
-
-private:
-    unsigned long misc:58;
 
 public: // FIXME
-    Tag type:5;
+    Tag type:7;
 
 private:
     bool marked:1;
 
+    unsigned long misc:56;
+
     void unmark()
     {
         marked = false;
@@ -69,7 +68,7 @@ private:
 
 protected:
 
-    Object(Tag type, unsigned long misc) : misc(misc), type(type), marked(false) { }
+    Object(Tag type, unsigned long misc) : type(type), marked(false), misc(misc) { }
 
     bool isMarked()
     {
@@ -90,6 +89,11 @@ protected:
     {
         return misc;
     }
+
+    char * getMiscData() const
+    {
+        return ((char *) this) + 1;
+    }
 };
 
 template<class T>

src/libexpr/value.hh

@@ -3,6 +3,8 @@
 #include "symbol-table.hh"
 #include "gc.hh"
 
+#include <cstring>
+
 namespace nix {
 
 class Bindings;
@@ -203,10 +205,18 @@ public:
         return type == tShortString || type == tLongString;
     }
 
+    void setShortString(const char * s)
+    {
+        // FIXME: can't use strcpy here because gcc flags it as a
+        // buffer overflow on 'misc'.
+        memcpy(getMiscData(), s, strlen(s) + 1);
+        type = tShortString;
+    }
+
     const char * getString() const
     {
         if (type == tShortString)
-            return (const char *) &string;
+            return getMiscData();
         else
             return string._s;
     }