Add fieldnull tool

The fieldnull tool uses jvmti to allow one to examine which portion of
a fields values are null on a running process. This can be used to
determine if changing the layout or implementation of a class would be
appropriate when the data is optional.

Bug: 32635074
Test: ./test/run-test --debuggable \
                      --host \
                      --dev \
                      --with-agent 'libfieldnull.so=Ljava/lang/Class;.name:Ljava/lang/String;' \
                      001-HelloWorld
Test: am start-activity \
         -S \
         --attach-agent '/data/local/tmp/libfieldnull.so=Ljava/lang/Class;.name:Ljava/lang/String;' \
         com.antonioleiva.bandhookkotlin/.ui.screens.main.mainactivity;
      kill -3 $(pidof com.antonioleiva.bandhookkotlin)

Change-Id: If64a9720d97625761556d78e881662f84953115f
diff --git a/tools/field-null-percent/Android.bp b/tools/field-null-percent/Android.bp
new file mode 100644
index 0000000..26bb1dc
--- /dev/null
+++ b/tools/field-null-percent/Android.bp
@@ -0,0 +1,56 @@
+//
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Build variants {target,host} x {debug,ndebug} x {32,64}
+cc_defaults {
+    name: "fieldnull-defaults",
+    host_supported: true,
+    srcs: ["fieldnull.cc"],
+    defaults: ["art_defaults"],
+
+    // Note that this tool needs to be built for both 32-bit and 64-bit since it requires
+    // to be same ISA as what it is attached to.
+    compile_multilib: "both",
+
+    shared_libs: [
+        "libbase",
+    ],
+    header_libs: [
+        "libopenjdkjvmti_headers",
+    ],
+    multilib: {
+        lib32: {
+            suffix: "32",
+        },
+        lib64: {
+            suffix: "64",
+        },
+    },
+    symlink_preferred_arch: true,
+}
+
+art_cc_library {
+    name: "libfieldnull",
+    defaults: ["fieldnull-defaults"],
+}
+
+art_cc_library {
+    name: "libfieldnulld",
+    defaults: [
+        "art_debug_defaults",
+        "fieldnull-defaults",
+    ],
+}
diff --git a/tools/field-null-percent/README.md b/tools/field-null-percent/README.md
new file mode 100644
index 0000000..d8bc65d
--- /dev/null
+++ b/tools/field-null-percent/README.md
@@ -0,0 +1,51 @@
+# fieldnull
+
+fieldnull is a JVMTI agent designed for testing for a given field the number of
+instances with that field set to null. This can be useful for determining what
+fields should be moved into side structures in cases where memory use is
+important.
+
+# Usage
+### Build
+>    `make libfieldnull`
+
+The libraries will be built for 32-bit, 64-bit, host and target. Below examples
+assume you want to use the 64-bit version.
+
+### Command Line
+
+The agent is loaded using -agentpath like normal. It takes arguments in the
+following format:
+>     `Lname/of/class;.nameOfField:Ltype/of/field;[,...]`
+
+#### ART
+>    `art -Xplugin:$ANDROID_HOST_OUT/lib64/libopenjdkjvmti.so '-agentpath:libfieldnull.so=Lname/of/class;.nameOfField:Ltype/of/field;' -cp tmp/java/helloworld.dex -Xint helloworld`
+
+* `-Xplugin` and `-agentpath` need to be used, otherwise the agent will fail during init.
+* If using `libartd.so`, make sure to use the debug version of jvmti.
+
+>    `adb shell setenforce 0`
+>
+>    `adb push $ANDROID_PRODUCT_OUT/system/lib64/libfieldnull.so /data/local/tmp/`
+>
+>    `adb shell am start-activity --attach-agent '/data/local/tmp/libfieldnull.so=Ljava/lang/Class;.name:Ljava/lang/String;' some.debuggable.apps/.the.app.MainActivity`
+
+#### RI
+>    `java '-agentpath:libfieldnull.so=Lname/of/class;.nameOfField:Ltype/of/field;' -cp tmp/helloworld/classes helloworld`
+
+### Printing the Results
+All statistics gathered during the trace are printed automatically when the
+program normally exits. In the case of Android applications, they are always
+killed, so we need to manually print the results.
+
+>    `kill -SIGQUIT $(pid com.littleinc.orm_benchmark)`
+
+Will initiate a dump of the counts (to logcat).
+
+The dump will look something like this.
+
+> `dalvikvm32 I 08-30 14:51:20 84818 84818 fieldnull.cc:96] Dumping counts of null fields.`
+>
+> `dalvikvm32 I 08-30 14:51:20 84818 84818 fieldnull.cc:97] 	Field name	null count	total count`
+>
+> `dalvikvm32 I 08-30 14:51:20 84818 84818 fieldnull.cc:135] 	Ljava/lang/Class;.name:Ljava/lang/String;	5	2936`
diff --git a/tools/field-null-percent/fieldnull.cc b/tools/field-null-percent/fieldnull.cc
new file mode 100644
index 0000000..86459d2
--- /dev/null
+++ b/tools/field-null-percent/fieldnull.cc
@@ -0,0 +1,218 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <android-base/logging.h>
+
+#include <atomic>
+#include <iomanip>
+#include <iostream>
+#include <istream>
+#include <jni.h>
+#include <jvmti.h>
+#include <memory>
+#include <sstream>
+#include <string.h>
+#include <string>
+#include <vector>
+
+namespace fieldnull {
+
+#define CHECK_JVMTI(x) CHECK_EQ((x), JVMTI_ERROR_NONE)
+
+// Special art ti-version number. We will use this as a fallback if we cannot get a regular JVMTI
+// env.
+static constexpr jint kArtTiVersion = JVMTI_VERSION_1_2 | 0x40000000;
+
+static JavaVM* java_vm = nullptr;
+
+// Field is "Lclass/name/here;.field_name:Lfield/type/here;"
+static std::pair<jclass, jfieldID> SplitField(JNIEnv* env, const std::string& field_id) {
+  CHECK_EQ(field_id[0], 'L');
+  env->PushLocalFrame(1);
+  std::istringstream is(field_id);
+  std::string class_name;
+  std::string field_name;
+  std::string field_type;
+
+  std::getline(is, class_name, '.');
+  std::getline(is, field_name, ':');
+  std::getline(is, field_type, '\0');
+
+  jclass klass = reinterpret_cast<jclass>(
+      env->NewGlobalRef(env->FindClass(class_name.substr(1, class_name.size() - 2).c_str())));
+  jfieldID field = env->GetFieldID(klass, field_name.c_str(), field_type.c_str());
+  CHECK(klass != nullptr);
+  CHECK(field != nullptr);
+  LOG(INFO) << "listing field " << field_id;
+  env->PopLocalFrame(nullptr);
+  return std::make_pair(klass, field);
+}
+
+static std::vector<std::pair<jclass, jfieldID>> GetRequestedFields(JNIEnv* env,
+                                                                   const std::string& args) {
+  std::vector<std::pair<jclass, jfieldID>> res;
+  std::stringstream args_stream(args);
+  std::string item;
+  while (std::getline(args_stream, item, ',')) {
+    if (item == "") {
+      continue;
+    }
+    res.push_back(SplitField(env, item));
+  }
+  return res;
+}
+
+static jint SetupJvmtiEnv(JavaVM* vm, jvmtiEnv** jvmti) {
+  jint res = 0;
+  res = vm->GetEnv(reinterpret_cast<void**>(jvmti), JVMTI_VERSION_1_1);
+
+  if (res != JNI_OK || *jvmti == nullptr) {
+    LOG(ERROR) << "Unable to access JVMTI, error code " << res;
+    return vm->GetEnv(reinterpret_cast<void**>(jvmti), kArtTiVersion);
+  }
+  return res;
+}
+
+struct RequestList {
+  std::vector<std::pair<jclass, jfieldID>> fields_;
+};
+
+static void DataDumpRequestCb(jvmtiEnv* jvmti) {
+  JNIEnv* env = nullptr;
+  CHECK_EQ(java_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6), JNI_OK);
+  LOG(INFO) << "Dumping counts of null fields.";
+  LOG(INFO) << "\t" << "Field name"
+            << "\t" << "null count"
+            << "\t" << "total count";
+  RequestList* list;
+  CHECK_JVMTI(jvmti->GetEnvironmentLocalStorage(reinterpret_cast<void**>(&list)));
+  for (std::pair<jclass, jfieldID>& p : list->fields_) {
+    jclass klass = p.first;
+    jfieldID field = p.second;
+    // Make sure all instances of the class are tagged with the klass ptr value. Since this is a
+    // global ref it's guaranteed to be unique.
+    CHECK_JVMTI(jvmti->IterateOverInstancesOfClass(
+        p.first,
+        // We need to do this to all objects every time since we might be looking for multiple
+        // fields in classes that are subtypes of each other.
+        JVMTI_HEAP_OBJECT_EITHER,
+        /* class_tag, size, tag_ptr, user_data*/
+        [](jlong, jlong, jlong* tag_ptr, void* klass) -> jvmtiIterationControl {
+          *tag_ptr = static_cast<jlong>(reinterpret_cast<intptr_t>(klass));
+          return JVMTI_ITERATION_CONTINUE;
+        },
+        klass));
+    jobject* obj_list;
+    jint obj_len;
+    jlong tag = static_cast<jlong>(reinterpret_cast<intptr_t>(klass));
+    CHECK_JVMTI(jvmti->GetObjectsWithTags(1, &tag, &obj_len, &obj_list, nullptr));
+
+    uint64_t null_cnt = 0;
+    for (jint i = 0; i < obj_len; i++) {
+      if (env->GetObjectField(obj_list[i], field) == nullptr) {
+        null_cnt++;
+      }
+    }
+
+    char* field_name;
+    char* field_sig;
+    char* class_name;
+    CHECK_JVMTI(jvmti->GetFieldName(klass, field, &field_name, &field_sig, nullptr));
+    CHECK_JVMTI(jvmti->GetClassSignature(klass, &class_name, nullptr));
+    LOG(INFO) << "\t" << class_name << "." << field_name << ":" << field_sig
+              << "\t" << null_cnt
+              << "\t" << obj_len;
+    CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(field_name)));
+    CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(field_sig)));
+    CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(class_name)));
+  }
+}
+
+static void VMDeathCb(jvmtiEnv* jvmti, JNIEnv* env ATTRIBUTE_UNUSED) {
+  DataDumpRequestCb(jvmti);
+  RequestList* list = nullptr;
+  CHECK_JVMTI(jvmti->GetEnvironmentLocalStorage(reinterpret_cast<void**>(&list)));
+  delete list;
+}
+
+static void CreateFieldList(jvmtiEnv* jvmti, JNIEnv* env, std::string args) {
+  RequestList* list = nullptr;
+  CHECK_JVMTI(jvmti->Allocate(sizeof(*list), reinterpret_cast<unsigned char**>(&list)));
+  new (list) RequestList { .fields_ = GetRequestedFields(env, args), };
+  CHECK_JVMTI(jvmti->SetEnvironmentLocalStorage(list));
+}
+
+static void VMInitCb(jvmtiEnv* jvmti, JNIEnv* env, jobject thr ATTRIBUTE_UNUSED) {
+  char* args = nullptr;
+  CHECK_JVMTI(jvmti->GetEnvironmentLocalStorage(reinterpret_cast<void**>(&args)));
+  CHECK_JVMTI(jvmti->SetEnvironmentLocalStorage(nullptr));
+  CreateFieldList(jvmti, env, args);
+  CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, nullptr));
+  CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE,
+                                              JVMTI_EVENT_DATA_DUMP_REQUEST,
+                                              nullptr));
+  CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(args)));
+}
+
+static jint AgentStart(JavaVM* vm, char* options, bool is_onload) {
+  android::base::InitLogging(/* argv */nullptr);
+  java_vm = vm;
+  jvmtiEnv* jvmti = nullptr;
+  if (SetupJvmtiEnv(vm, &jvmti) != JNI_OK) {
+    LOG(ERROR) << "Could not get JVMTI env or ArtTiEnv!";
+    return JNI_ERR;
+  }
+  jvmtiCapabilities caps { .can_tag_objects = 1, };
+  CHECK_JVMTI(jvmti->AddCapabilities(&caps));
+  jvmtiEventCallbacks cb {
+    .VMInit = VMInitCb,
+    .DataDumpRequest = DataDumpRequestCb,
+    .VMDeath = VMDeathCb,
+  };
+  CHECK_JVMTI(jvmti->SetEventCallbacks(&cb, sizeof(cb)));
+  if (is_onload) {
+    unsigned char* ptr = nullptr;
+    CHECK_JVMTI(jvmti->Allocate(strlen(options) + 1, &ptr));
+    strcpy(reinterpret_cast<char*>(ptr), options);
+    CHECK_JVMTI(jvmti->SetEnvironmentLocalStorage(ptr));
+    CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, nullptr));
+  } else {
+    JNIEnv* env = nullptr;
+    CHECK_EQ(vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6), JNI_OK);
+    CreateFieldList(jvmti, env, options);
+    CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, nullptr));
+    CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE,
+                                                JVMTI_EVENT_DATA_DUMP_REQUEST,
+                                                nullptr));
+  }
+  return JNI_OK;
+}
+
+// Late attachment (e.g. 'am attach-agent').
+extern "C" JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM *vm,
+                                                 char* options,
+                                                 void* reserved ATTRIBUTE_UNUSED) {
+  return AgentStart(vm, options, /*is_onload*/false);
+}
+
+// Early attachment
+extern "C" JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM* jvm,
+                                               char* options,
+                                               void* reserved ATTRIBUTE_UNUSED) {
+  return AgentStart(jvm, options, /*is_onload*/true);
+}
+
+}  // namespace fieldnull
+