Formatting: force pointers to the left side.

2015-06-30 16:16:33 -07:00
parent 90e86d0172
commit d7a5c74bf3
12 changed files with 478 additions and 481 deletions
--- a/src/xenia/debug/proto/breakpoints_generated.h
+++ b/src/xenia/debug/proto/breakpoints_generated.h
@@ -43,20 +43,20 @@ STRUCT_END(Breakpoint, 4);

 struct ListBreakpointsRequest FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct ListBreakpointsRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  ListBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ListBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListBreakpointsRequestBuilder &operator=(
-      const ListBreakpointsRequestBuilder &);
+  ListBreakpointsRequestBuilder& operator=(
+      const ListBreakpointsRequestBuilder&);
  flatbuffers::Offset<ListBreakpointsRequest> Finish() {
    auto o =
        flatbuffers::Offset<ListBreakpointsRequest>(fbb_.EndTable(start_, 0));
@@ -65,17 +65,17 @@ struct ListBreakpointsRequestBuilder {
 };

 inline flatbuffers::Offset<ListBreakpointsRequest> CreateListBreakpointsRequest(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  ListBreakpointsRequestBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct ListBreakpointsResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
-    return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
+  const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
+    return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
           verifier.Verify(breakpoints()) && verifier.EndTable();
@@ -83,18 +83,18 @@ struct ListBreakpointsResponse FLATBUFFERS_FINAL_CLASS
 };

 struct ListBreakpointsResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  void add_breakpoints(flatbuffers::Offset<
-      flatbuffers::Vector<const Breakpoint *>> breakpoints) {
+  void add_breakpoints(
+      flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
    fbb_.AddOffset(4, breakpoints);
  }
-  ListBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ListBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListBreakpointsResponseBuilder &operator=(
-      const ListBreakpointsResponseBuilder &);
+  ListBreakpointsResponseBuilder& operator=(
+      const ListBreakpointsResponseBuilder&);
  flatbuffers::Offset<ListBreakpointsResponse> Finish() {
    auto o =
        flatbuffers::Offset<ListBreakpointsResponse>(fbb_.EndTable(start_, 1));
@@ -104,8 +104,8 @@ struct ListBreakpointsResponseBuilder {

 inline flatbuffers::Offset<ListBreakpointsResponse>
 CreateListBreakpointsResponse(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
+    flatbuffers::FlatBufferBuilder& _fbb,
+    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
        0) {
  ListBreakpointsResponseBuilder builder_(_fbb);
  builder_.add_breakpoints(breakpoints);
@@ -114,10 +114,10 @@ CreateListBreakpointsResponse(

 struct AddBreakpointsRequest FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
-    return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
+  const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
+    return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
           verifier.Verify(breakpoints()) && verifier.EndTable();
@@ -125,17 +125,17 @@ struct AddBreakpointsRequest FLATBUFFERS_FINAL_CLASS
 };

 struct AddBreakpointsRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  void add_breakpoints(flatbuffers::Offset<
-      flatbuffers::Vector<const Breakpoint *>> breakpoints) {
+  void add_breakpoints(
+      flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
    fbb_.AddOffset(4, breakpoints);
  }
-  AddBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  AddBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  AddBreakpointsRequestBuilder &operator=(const AddBreakpointsRequestBuilder &);
+  AddBreakpointsRequestBuilder& operator=(const AddBreakpointsRequestBuilder&);
  flatbuffers::Offset<AddBreakpointsRequest> Finish() {
    auto o =
        flatbuffers::Offset<AddBreakpointsRequest>(fbb_.EndTable(start_, 1));
@@ -144,8 +144,8 @@ struct AddBreakpointsRequestBuilder {
 };

 inline flatbuffers::Offset<AddBreakpointsRequest> CreateAddBreakpointsRequest(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
+    flatbuffers::FlatBufferBuilder& _fbb,
+    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
        0) {
  AddBreakpointsRequestBuilder builder_(_fbb);
  builder_.add_breakpoints(breakpoints);
@@ -154,20 +154,20 @@ inline flatbuffers::Offset<AddBreakpointsRequest> CreateAddBreakpointsRequest(

 struct AddBreakpointsResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct AddBreakpointsResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  AddBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  AddBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  AddBreakpointsResponseBuilder &operator=(
-      const AddBreakpointsResponseBuilder &);
+  AddBreakpointsResponseBuilder& operator=(
+      const AddBreakpointsResponseBuilder&);
  flatbuffers::Offset<AddBreakpointsResponse> Finish() {
    auto o =
        flatbuffers::Offset<AddBreakpointsResponse>(fbb_.EndTable(start_, 0));
@@ -176,17 +176,17 @@ struct AddBreakpointsResponseBuilder {
 };

 inline flatbuffers::Offset<AddBreakpointsResponse> CreateAddBreakpointsResponse(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  AddBreakpointsResponseBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct UpdateBreakpointsRequest FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
-    return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
+  const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
+    return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
           verifier.Verify(breakpoints()) && verifier.EndTable();
@@ -194,18 +194,18 @@ struct UpdateBreakpointsRequest FLATBUFFERS_FINAL_CLASS
 };

 struct UpdateBreakpointsRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  void add_breakpoints(flatbuffers::Offset<
-      flatbuffers::Vector<const Breakpoint *>> breakpoints) {
+  void add_breakpoints(
+      flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
    fbb_.AddOffset(4, breakpoints);
  }
-  UpdateBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  UpdateBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  UpdateBreakpointsRequestBuilder &operator=(
-      const UpdateBreakpointsRequestBuilder &);
+  UpdateBreakpointsRequestBuilder& operator=(
+      const UpdateBreakpointsRequestBuilder&);
  flatbuffers::Offset<UpdateBreakpointsRequest> Finish() {
    auto o =
        flatbuffers::Offset<UpdateBreakpointsRequest>(fbb_.EndTable(start_, 1));
@@ -215,8 +215,8 @@ struct UpdateBreakpointsRequestBuilder {

 inline flatbuffers::Offset<UpdateBreakpointsRequest>
 CreateUpdateBreakpointsRequest(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
+    flatbuffers::FlatBufferBuilder& _fbb,
+    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
        0) {
  UpdateBreakpointsRequestBuilder builder_(_fbb);
  builder_.add_breakpoints(breakpoints);
@@ -225,20 +225,20 @@ CreateUpdateBreakpointsRequest(

 struct UpdateBreakpointsResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct UpdateBreakpointsResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  UpdateBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  UpdateBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  UpdateBreakpointsResponseBuilder &operator=(
-      const UpdateBreakpointsResponseBuilder &);
+  UpdateBreakpointsResponseBuilder& operator=(
+      const UpdateBreakpointsResponseBuilder&);
  flatbuffers::Offset<UpdateBreakpointsResponse> Finish() {
    auto o = flatbuffers::Offset<UpdateBreakpointsResponse>(
        fbb_.EndTable(start_, 0));
@@ -247,17 +247,17 @@ struct UpdateBreakpointsResponseBuilder {
 };

 inline flatbuffers::Offset<UpdateBreakpointsResponse>
-CreateUpdateBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
+CreateUpdateBreakpointsResponse(flatbuffers::FlatBufferBuilder& _fbb) {
  UpdateBreakpointsResponseBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct RemoveBreakpointsRequest FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
-    return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
+  const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
+    return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
           verifier.Verify(breakpoints()) && verifier.EndTable();
@@ -265,18 +265,18 @@ struct RemoveBreakpointsRequest FLATBUFFERS_FINAL_CLASS
 };

 struct RemoveBreakpointsRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  void add_breakpoints(flatbuffers::Offset<
-      flatbuffers::Vector<const Breakpoint *>> breakpoints) {
+  void add_breakpoints(
+      flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
    fbb_.AddOffset(4, breakpoints);
  }
-  RemoveBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  RemoveBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  RemoveBreakpointsRequestBuilder &operator=(
-      const RemoveBreakpointsRequestBuilder &);
+  RemoveBreakpointsRequestBuilder& operator=(
+      const RemoveBreakpointsRequestBuilder&);
  flatbuffers::Offset<RemoveBreakpointsRequest> Finish() {
    auto o =
        flatbuffers::Offset<RemoveBreakpointsRequest>(fbb_.EndTable(start_, 1));
@@ -286,8 +286,8 @@ struct RemoveBreakpointsRequestBuilder {

 inline flatbuffers::Offset<RemoveBreakpointsRequest>
 CreateRemoveBreakpointsRequest(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
+    flatbuffers::FlatBufferBuilder& _fbb,
+    flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
        0) {
  RemoveBreakpointsRequestBuilder builder_(_fbb);
  builder_.add_breakpoints(breakpoints);
@@ -296,20 +296,20 @@ CreateRemoveBreakpointsRequest(

 struct RemoveBreakpointsResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct RemoveBreakpointsResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  RemoveBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  RemoveBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  RemoveBreakpointsResponseBuilder &operator=(
-      const RemoveBreakpointsResponseBuilder &);
+  RemoveBreakpointsResponseBuilder& operator=(
+      const RemoveBreakpointsResponseBuilder&);
  flatbuffers::Offset<RemoveBreakpointsResponse> Finish() {
    auto o = flatbuffers::Offset<RemoveBreakpointsResponse>(
        fbb_.EndTable(start_, 0));
@@ -318,7 +318,7 @@ struct RemoveBreakpointsResponseBuilder {
 };

 inline flatbuffers::Offset<RemoveBreakpointsResponse>
-CreateRemoveBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
+CreateRemoveBreakpointsResponse(flatbuffers::FlatBufferBuilder& _fbb) {
  RemoveBreakpointsResponseBuilder builder_(_fbb);
  return builder_.Finish();
 }
--- a/src/xenia/debug/proto/control_generated.h
+++ b/src/xenia/debug/proto/control_generated.h
@@ -33,12 +33,12 @@ enum ContinueAction {
  ContinueAction_ContinueTo = 1
 };

-inline const char **EnumNamesContinueAction() {
-  static const char *names[] = {"Continue", "ContinueTo", nullptr};
+inline const char** EnumNamesContinueAction() {
+  static const char* names[] = {"Continue", "ContinueTo", nullptr};
  return names;
 }

-inline const char *EnumNameContinueAction(ContinueAction e) {
+inline const char* EnumNameContinueAction(ContinueAction e) {
  return EnumNamesContinueAction()[e];
 }

@@ -48,28 +48,28 @@ enum StepAction {
  StepAction_StepOut = 2
 };

-inline const char **EnumNamesStepAction() {
-  static const char *names[] = {"StepIn", "StepOver", "StepOut", nullptr};
+inline const char** EnumNamesStepAction() {
+  static const char* names[] = {"StepIn", "StepOver", "StepOut", nullptr};
  return names;
 }

-inline const char *EnumNameStepAction(StepAction e) {
+inline const char* EnumNameStepAction(StepAction e) {
  return EnumNamesStepAction()[e];
 }

 struct StopRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct StopRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  StopRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  StopRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  StopRequestBuilder &operator=(const StopRequestBuilder &);
+  StopRequestBuilder& operator=(const StopRequestBuilder&);
  flatbuffers::Offset<StopRequest> Finish() {
    auto o = flatbuffers::Offset<StopRequest>(fbb_.EndTable(start_, 0));
    return o;
@@ -77,24 +77,24 @@ struct StopRequestBuilder {
 };

 inline flatbuffers::Offset<StopRequest> CreateStopRequest(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  StopRequestBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct StopResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct StopResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  StopResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  StopResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  StopResponseBuilder &operator=(const StopResponseBuilder &);
+  StopResponseBuilder& operator=(const StopResponseBuilder&);
  flatbuffers::Offset<StopResponse> Finish() {
    auto o = flatbuffers::Offset<StopResponse>(fbb_.EndTable(start_, 0));
    return o;
@@ -102,24 +102,24 @@ struct StopResponseBuilder {
 };

 inline flatbuffers::Offset<StopResponse> CreateStopResponse(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  StopResponseBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct BreakRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct BreakRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  BreakRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  BreakRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  BreakRequestBuilder &operator=(const BreakRequestBuilder &);
+  BreakRequestBuilder& operator=(const BreakRequestBuilder&);
  flatbuffers::Offset<BreakRequest> Finish() {
    auto o = flatbuffers::Offset<BreakRequest>(fbb_.EndTable(start_, 0));
    return o;
@@ -127,24 +127,24 @@ struct BreakRequestBuilder {
 };

 inline flatbuffers::Offset<BreakRequest> CreateBreakRequest(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  BreakRequestBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct BreakResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct BreakResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  BreakResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  BreakResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  BreakResponseBuilder &operator=(const BreakResponseBuilder &);
+  BreakResponseBuilder& operator=(const BreakResponseBuilder&);
  flatbuffers::Offset<BreakResponse> Finish() {
    auto o = flatbuffers::Offset<BreakResponse>(fbb_.EndTable(start_, 0));
    return o;
@@ -152,7 +152,7 @@ struct BreakResponseBuilder {
 };

 inline flatbuffers::Offset<BreakResponse> CreateBreakResponse(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  BreakResponseBuilder builder_(_fbb);
  return builder_.Finish();
 }
@@ -162,7 +162,7 @@ struct ContinueRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    return static_cast<ContinueAction>(GetField<int8_t>(4, 0));
  }
  uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, 4 /* action */) &&
           VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
@@ -171,7 +171,7 @@ struct ContinueRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct ContinueRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_action(ContinueAction action) {
    fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0);
@@ -179,10 +179,10 @@ struct ContinueRequestBuilder {
  void add_target_address(uint32_t target_address) {
    fbb_.AddElement<uint32_t>(6, target_address, 0);
  }
-  ContinueRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  ContinueRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ContinueRequestBuilder &operator=(const ContinueRequestBuilder &);
+  ContinueRequestBuilder& operator=(const ContinueRequestBuilder&);
  flatbuffers::Offset<ContinueRequest> Finish() {
    auto o = flatbuffers::Offset<ContinueRequest>(fbb_.EndTable(start_, 2));
    return o;
@@ -190,7 +190,7 @@ struct ContinueRequestBuilder {
 };

 inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(
-    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::FlatBufferBuilder& _fbb,
    ContinueAction action = ContinueAction_Continue,
    uint32_t target_address = 0) {
  ContinueRequestBuilder builder_(_fbb);
@@ -200,18 +200,18 @@ inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(
 }

 struct ContinueResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct ContinueResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  ContinueResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  ContinueResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ContinueResponseBuilder &operator=(const ContinueResponseBuilder &);
+  ContinueResponseBuilder& operator=(const ContinueResponseBuilder&);
  flatbuffers::Offset<ContinueResponse> Finish() {
    auto o = flatbuffers::Offset<ContinueResponse>(fbb_.EndTable(start_, 0));
    return o;
@@ -219,7 +219,7 @@ struct ContinueResponseBuilder {
 };

 inline flatbuffers::Offset<ContinueResponse> CreateContinueResponse(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  ContinueResponseBuilder builder_(_fbb);
  return builder_.Finish();
 }
@@ -229,7 +229,7 @@ struct StepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    return static_cast<StepAction>(GetField<int8_t>(4, 0));
  }
  uint32_t thread_id() const { return GetField<uint32_t>(6, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, 4 /* action */) &&
           VerifyField<uint32_t>(verifier, 6 /* thread_id */) &&
@@ -238,7 +238,7 @@ struct StepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct StepRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_action(StepAction action) {
    fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0);
@@ -246,10 +246,10 @@ struct StepRequestBuilder {
  void add_thread_id(uint32_t thread_id) {
    fbb_.AddElement<uint32_t>(6, thread_id, 0);
  }
-  StepRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  StepRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  StepRequestBuilder &operator=(const StepRequestBuilder &);
+  StepRequestBuilder& operator=(const StepRequestBuilder&);
  flatbuffers::Offset<StepRequest> Finish() {
    auto o = flatbuffers::Offset<StepRequest>(fbb_.EndTable(start_, 2));
    return o;
@@ -257,7 +257,7 @@ struct StepRequestBuilder {
 };

 inline flatbuffers::Offset<StepRequest> CreateStepRequest(
-    flatbuffers::FlatBufferBuilder &_fbb, StepAction action = StepAction_StepIn,
+    flatbuffers::FlatBufferBuilder& _fbb, StepAction action = StepAction_StepIn,
    uint32_t thread_id = 0) {
  StepRequestBuilder builder_(_fbb);
  builder_.add_thread_id(thread_id);
@@ -266,18 +266,18 @@ inline flatbuffers::Offset<StepRequest> CreateStepRequest(
 }

 struct StepResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct StepResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  StepResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  StepResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  StepResponseBuilder &operator=(const StepResponseBuilder &);
+  StepResponseBuilder& operator=(const StepResponseBuilder&);
  flatbuffers::Offset<StepResponse> Finish() {
    auto o = flatbuffers::Offset<StepResponse>(fbb_.EndTable(start_, 0));
    return o;
@@ -285,7 +285,7 @@ struct StepResponseBuilder {
 };

 inline flatbuffers::Offset<StepResponse> CreateStepResponse(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  StepResponseBuilder builder_(_fbb);
  return builder_.Finish();
 }
@@ -293,7 +293,7 @@ inline flatbuffers::Offset<StepResponse> CreateStepResponse(
 struct BreakpointEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
  uint32_t breakpoint_id() const { return GetField<uint32_t>(6, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
           VerifyField<uint32_t>(verifier, 6 /* breakpoint_id */) &&
@@ -302,7 +302,7 @@ struct BreakpointEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct BreakpointEventBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_thread_id(uint32_t thread_id) {
    fbb_.AddElement<uint32_t>(4, thread_id, 0);
@@ -310,10 +310,10 @@ struct BreakpointEventBuilder {
  void add_breakpoint_id(uint32_t breakpoint_id) {
    fbb_.AddElement<uint32_t>(6, breakpoint_id, 0);
  }
-  BreakpointEventBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  BreakpointEventBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  BreakpointEventBuilder &operator=(const BreakpointEventBuilder &);
+  BreakpointEventBuilder& operator=(const BreakpointEventBuilder&);
  flatbuffers::Offset<BreakpointEvent> Finish() {
    auto o = flatbuffers::Offset<BreakpointEvent>(fbb_.EndTable(start_, 2));
    return o;
@@ -321,7 +321,7 @@ struct BreakpointEventBuilder {
 };

 inline flatbuffers::Offset<BreakpointEvent> CreateBreakpointEvent(
-    flatbuffers::FlatBufferBuilder &_fbb, uint32_t thread_id = 0,
+    flatbuffers::FlatBufferBuilder& _fbb, uint32_t thread_id = 0,
    uint32_t breakpoint_id = 0) {
  BreakpointEventBuilder builder_(_fbb);
  builder_.add_breakpoint_id(breakpoint_id);
@@ -333,7 +333,7 @@ struct AccessViolationEvent FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
  uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
  uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
           VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
@@ -342,7 +342,7 @@ struct AccessViolationEvent FLATBUFFERS_FINAL_CLASS
 };

 struct AccessViolationEventBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_thread_id(uint32_t thread_id) {
    fbb_.AddElement<uint32_t>(4, thread_id, 0);
@@ -350,11 +350,11 @@ struct AccessViolationEventBuilder {
  void add_target_address(uint32_t target_address) {
    fbb_.AddElement<uint32_t>(6, target_address, 0);
  }
-  AccessViolationEventBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  AccessViolationEventBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  AccessViolationEventBuilder &operator=(const AccessViolationEventBuilder &);
+  AccessViolationEventBuilder& operator=(const AccessViolationEventBuilder&);
  flatbuffers::Offset<AccessViolationEvent> Finish() {
    auto o =
        flatbuffers::Offset<AccessViolationEvent>(fbb_.EndTable(start_, 2));
@@ -363,7 +363,7 @@ struct AccessViolationEventBuilder {
 };

 inline flatbuffers::Offset<AccessViolationEvent> CreateAccessViolationEvent(
-    flatbuffers::FlatBufferBuilder &_fbb, uint32_t thread_id = 0,
+    flatbuffers::FlatBufferBuilder& _fbb, uint32_t thread_id = 0,
    uint32_t target_address = 0) {
  AccessViolationEventBuilder builder_(_fbb);
  builder_.add_target_address(target_address);
--- a/src/xenia/debug/proto/messages_generated.h
+++ b/src/xenia/debug/proto/messages_generated.h
@@ -98,8 +98,8 @@ enum RequestData {
  RequestData_StepRequest = 14
 };

-inline const char **EnumNamesRequestData() {
-  static const char *names[] = {
+inline const char** EnumNamesRequestData() {
+  static const char* names[] = {
      "NONE", "AttachRequest", "ListBreakpointsRequest",
      "AddBreakpointsRequest", "UpdateBreakpointsRequest",
      "RemoveBreakpointsRequest", "ListModulesRequest", "GetModuleRequest",
@@ -108,12 +108,12 @@ inline const char **EnumNamesRequestData() {
  return names;
 }

-inline const char *EnumNameRequestData(RequestData e) {
+inline const char* EnumNameRequestData(RequestData e) {
  return EnumNamesRequestData()[e];
 }

-inline bool VerifyRequestData(flatbuffers::Verifier &verifier,
-                              const void *union_obj, RequestData type);
+inline bool VerifyRequestData(flatbuffers::Verifier& verifier,
+                              const void* union_obj, RequestData type);

 enum ResponseData {
  ResponseData_NONE = 0,
@@ -135,8 +135,8 @@ enum ResponseData {
  ResponseData_AccessViolationEvent = 16
 };

-inline const char **EnumNamesResponseData() {
-  static const char *names[] = {
+inline const char** EnumNamesResponseData() {
+  static const char* names[] = {
      "NONE", "AttachResponse", "ListBreakpointsResponse",
      "AddBreakpointsResponse", "UpdateBreakpointsResponse",
      "RemoveBreakpointsResponse", "ListModulesResponse", "GetModuleResponse",
@@ -146,26 +146,26 @@ inline const char **EnumNamesResponseData() {
  return names;
 }

-inline const char *EnumNameResponseData(ResponseData e) {
+inline const char* EnumNameResponseData(ResponseData e) {
  return EnumNamesResponseData()[e];
 }

-inline bool VerifyResponseData(flatbuffers::Verifier &verifier,
-                               const void *union_obj, ResponseData type);
+inline bool VerifyResponseData(flatbuffers::Verifier& verifier,
+                               const void* union_obj, ResponseData type);

 struct AttachRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct AttachRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  AttachRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  AttachRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  AttachRequestBuilder &operator=(const AttachRequestBuilder &);
+  AttachRequestBuilder& operator=(const AttachRequestBuilder&);
  flatbuffers::Offset<AttachRequest> Finish() {
    auto o = flatbuffers::Offset<AttachRequest>(fbb_.EndTable(start_, 0));
    return o;
@@ -173,27 +173,27 @@ struct AttachRequestBuilder {
 };

 inline flatbuffers::Offset<AttachRequest> CreateAttachRequest(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  AttachRequestBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct AttachResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  const flatbuffers::String *memory_file() const {
-    return GetPointer<const flatbuffers::String *>(4);
+  const flatbuffers::String* memory_file() const {
+    return GetPointer<const flatbuffers::String*>(4);
  }
-  const flatbuffers::String *code_cache_file() const {
-    return GetPointer<const flatbuffers::String *>(6);
+  const flatbuffers::String* code_cache_file() const {
+    return GetPointer<const flatbuffers::String*>(6);
  }
  uint32_t code_cache_base() const { return GetField<uint32_t>(8, 0); }
  uint32_t code_cache_size() const { return GetField<uint32_t>(10, 0); }
-  const flatbuffers::String *functions_file() const {
-    return GetPointer<const flatbuffers::String *>(12);
+  const flatbuffers::String* functions_file() const {
+    return GetPointer<const flatbuffers::String*>(12);
  }
-  const flatbuffers::String *functions_trace_file() const {
-    return GetPointer<const flatbuffers::String *>(14);
+  const flatbuffers::String* functions_trace_file() const {
+    return GetPointer<const flatbuffers::String*>(14);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* memory_file */) &&
           verifier.Verify(memory_file()) &&
@@ -212,7 +212,7 @@ struct AttachResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct AttachResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_memory_file(flatbuffers::Offset<flatbuffers::String> memory_file) {
    fbb_.AddOffset(4, memory_file);
@@ -235,10 +235,10 @@ struct AttachResponseBuilder {
      flatbuffers::Offset<flatbuffers::String> functions_trace_file) {
    fbb_.AddOffset(14, functions_trace_file);
  }
-  AttachResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  AttachResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  AttachResponseBuilder &operator=(const AttachResponseBuilder &);
+  AttachResponseBuilder& operator=(const AttachResponseBuilder&);
  flatbuffers::Offset<AttachResponse> Finish() {
    auto o = flatbuffers::Offset<AttachResponse>(fbb_.EndTable(start_, 6));
    return o;
@@ -246,7 +246,7 @@ struct AttachResponseBuilder {
 };

 inline flatbuffers::Offset<AttachResponse> CreateAttachResponse(
-    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<flatbuffers::String> memory_file = 0,
    flatbuffers::Offset<flatbuffers::String> code_cache_file = 0,
    uint32_t code_cache_base = 0, uint32_t code_cache_size = 0,
@@ -267,8 +267,8 @@ struct Request FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  RequestData request_data_type() const {
    return static_cast<RequestData>(GetField<uint8_t>(6, 0));
  }
-  const void *request_data() const { return GetPointer<const void *>(8); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  const void* request_data() const { return GetPointer<const void*>(8); }
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* id */) &&
           VerifyField<uint8_t>(verifier, 6 /* request_data_type */) &&
@@ -280,7 +280,7 @@ struct Request FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct RequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(4, id, 0); }
  void add_request_data_type(RequestData request_data_type) {
@@ -289,10 +289,10 @@ struct RequestBuilder {
  void add_request_data(flatbuffers::Offset<void> request_data) {
    fbb_.AddOffset(8, request_data);
  }
-  RequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  RequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  RequestBuilder &operator=(const RequestBuilder &);
+  RequestBuilder& operator=(const RequestBuilder&);
  flatbuffers::Offset<Request> Finish() {
    auto o = flatbuffers::Offset<Request>(fbb_.EndTable(start_, 3));
    return o;
@@ -300,7 +300,7 @@ struct RequestBuilder {
 };

 inline flatbuffers::Offset<Request> CreateRequest(
-    flatbuffers::FlatBufferBuilder &_fbb, uint32_t id = 0,
+    flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
    RequestData request_data_type = RequestData_NONE,
    flatbuffers::Offset<void> request_data = 0) {
  RequestBuilder builder_(_fbb);
@@ -315,8 +315,8 @@ struct Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  ResponseData response_data_type() const {
    return static_cast<ResponseData>(GetField<uint8_t>(6, 0));
  }
-  const void *response_data() const { return GetPointer<const void *>(8); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  const void* response_data() const { return GetPointer<const void*>(8); }
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* id */) &&
           VerifyField<uint8_t>(verifier, 6 /* response_data_type */) &&
@@ -329,7 +329,7 @@ struct Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct ResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(4, id, 0); }
  void add_response_data_type(ResponseData response_data_type) {
@@ -338,10 +338,10 @@ struct ResponseBuilder {
  void add_response_data(flatbuffers::Offset<void> response_data) {
    fbb_.AddOffset(8, response_data);
  }
-  ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  ResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ResponseBuilder &operator=(const ResponseBuilder &);
+  ResponseBuilder& operator=(const ResponseBuilder&);
  flatbuffers::Offset<Response> Finish() {
    auto o = flatbuffers::Offset<Response>(fbb_.EndTable(start_, 3));
    return o;
@@ -349,7 +349,7 @@ struct ResponseBuilder {
 };

 inline flatbuffers::Offset<Response> CreateResponse(
-    flatbuffers::FlatBufferBuilder &_fbb, uint32_t id = 0,
+    flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
    ResponseData response_data_type = ResponseData_NONE,
    flatbuffers::Offset<void> response_data = 0) {
  ResponseBuilder builder_(_fbb);
@@ -359,132 +359,132 @@ inline flatbuffers::Offset<Response> CreateResponse(
  return builder_.Finish();
 }

-inline bool VerifyRequestData(flatbuffers::Verifier &verifier,
-                              const void *union_obj, RequestData type) {
+inline bool VerifyRequestData(flatbuffers::Verifier& verifier,
+                              const void* union_obj, RequestData type) {
  switch (type) {
    case RequestData_NONE:
      return true;
    case RequestData_AttachRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const AttachRequest *>(union_obj));
+          reinterpret_cast<const AttachRequest*>(union_obj));
    case RequestData_ListBreakpointsRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListBreakpointsRequest *>(
+          reinterpret_cast<const xe::debug::proto::ListBreakpointsRequest*>(
              union_obj));
    case RequestData_AddBreakpointsRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::AddBreakpointsRequest *>(
+          reinterpret_cast<const xe::debug::proto::AddBreakpointsRequest*>(
              union_obj));
    case RequestData_UpdateBreakpointsRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::UpdateBreakpointsRequest *>(
+          reinterpret_cast<const xe::debug::proto::UpdateBreakpointsRequest*>(
              union_obj));
    case RequestData_RemoveBreakpointsRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::RemoveBreakpointsRequest *>(
+          reinterpret_cast<const xe::debug::proto::RemoveBreakpointsRequest*>(
              union_obj));
    case RequestData_ListModulesRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListModulesRequest *>(
+          reinterpret_cast<const xe::debug::proto::ListModulesRequest*>(
              union_obj));
    case RequestData_GetModuleRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::GetModuleRequest *>(
+          reinterpret_cast<const xe::debug::proto::GetModuleRequest*>(
              union_obj));
    case RequestData_ListFunctionsRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListFunctionsRequest *>(
+          reinterpret_cast<const xe::debug::proto::ListFunctionsRequest*>(
              union_obj));
    case RequestData_GetFunctionRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::GetFunctionRequest *>(
+          reinterpret_cast<const xe::debug::proto::GetFunctionRequest*>(
              union_obj));
    case RequestData_ListThreadsRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListThreadsRequest *>(
+          reinterpret_cast<const xe::debug::proto::ListThreadsRequest*>(
              union_obj));
    case RequestData_StopRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::StopRequest *>(union_obj));
+          reinterpret_cast<const xe::debug::proto::StopRequest*>(union_obj));
    case RequestData_BreakRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::BreakRequest *>(union_obj));
+          reinterpret_cast<const xe::debug::proto::BreakRequest*>(union_obj));
    case RequestData_ContinueRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ContinueRequest *>(
+          reinterpret_cast<const xe::debug::proto::ContinueRequest*>(
              union_obj));
    case RequestData_StepRequest:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::StepRequest *>(union_obj));
+          reinterpret_cast<const xe::debug::proto::StepRequest*>(union_obj));
    default:
      return false;
  }
 }

-inline bool VerifyResponseData(flatbuffers::Verifier &verifier,
-                               const void *union_obj, ResponseData type) {
+inline bool VerifyResponseData(flatbuffers::Verifier& verifier,
+                               const void* union_obj, ResponseData type) {
  switch (type) {
    case ResponseData_NONE:
      return true;
    case ResponseData_AttachResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const AttachResponse *>(union_obj));
+          reinterpret_cast<const AttachResponse*>(union_obj));
    case ResponseData_ListBreakpointsResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListBreakpointsResponse *>(
+          reinterpret_cast<const xe::debug::proto::ListBreakpointsResponse*>(
              union_obj));
    case ResponseData_AddBreakpointsResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::AddBreakpointsResponse *>(
+          reinterpret_cast<const xe::debug::proto::AddBreakpointsResponse*>(
              union_obj));
    case ResponseData_UpdateBreakpointsResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::UpdateBreakpointsResponse *>(
+          reinterpret_cast<const xe::debug::proto::UpdateBreakpointsResponse*>(
              union_obj));
    case ResponseData_RemoveBreakpointsResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::RemoveBreakpointsResponse *>(
+          reinterpret_cast<const xe::debug::proto::RemoveBreakpointsResponse*>(
              union_obj));
    case ResponseData_ListModulesResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListModulesResponse *>(
+          reinterpret_cast<const xe::debug::proto::ListModulesResponse*>(
              union_obj));
    case ResponseData_GetModuleResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::GetModuleResponse *>(
+          reinterpret_cast<const xe::debug::proto::GetModuleResponse*>(
              union_obj));
    case ResponseData_ListFunctionsResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListFunctionsResponse *>(
+          reinterpret_cast<const xe::debug::proto::ListFunctionsResponse*>(
              union_obj));
    case ResponseData_GetFunctionResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::GetFunctionResponse *>(
+          reinterpret_cast<const xe::debug::proto::GetFunctionResponse*>(
              union_obj));
    case ResponseData_ListThreadsResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ListThreadsResponse *>(
+          reinterpret_cast<const xe::debug::proto::ListThreadsResponse*>(
              union_obj));
    case ResponseData_StopResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::StopResponse *>(union_obj));
+          reinterpret_cast<const xe::debug::proto::StopResponse*>(union_obj));
    case ResponseData_BreakResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::BreakResponse *>(union_obj));
+          reinterpret_cast<const xe::debug::proto::BreakResponse*>(union_obj));
    case ResponseData_ContinueResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::ContinueResponse *>(
+          reinterpret_cast<const xe::debug::proto::ContinueResponse*>(
              union_obj));
    case ResponseData_StepResponse:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::StepResponse *>(union_obj));
+          reinterpret_cast<const xe::debug::proto::StepResponse*>(union_obj));
    case ResponseData_BreakpointEvent:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::BreakpointEvent *>(
+          reinterpret_cast<const xe::debug::proto::BreakpointEvent*>(
              union_obj));
    case ResponseData_AccessViolationEvent:
      return verifier.VerifyTable(
-          reinterpret_cast<const xe::debug::proto::AccessViolationEvent *>(
+          reinterpret_cast<const xe::debug::proto::AccessViolationEvent*>(
              union_obj));
    default:
      return false;
--- a/src/xenia/debug/proto/modules_generated.h
+++ b/src/xenia/debug/proto/modules_generated.h
@@ -32,12 +32,12 @@ struct GetFunctionResponse;

 enum ModuleType { ModuleType_Kernel = 0, ModuleType_User = 1 };

-inline const char **EnumNamesModuleType() {
-  static const char *names[] = {"Kernel", "User", nullptr};
+inline const char** EnumNamesModuleType() {
+  static const char* names[] = {"Kernel", "User", nullptr};
  return names;
 }

-inline const char *EnumNameModuleType(ModuleType e) {
+inline const char* EnumNameModuleType(ModuleType e) {
  return EnumNamesModuleType()[e];
 }

@@ -59,19 +59,19 @@ MANUALLY_ALIGNED_STRUCT(4) ListModuleEntry FLATBUFFERS_FINAL_CLASS {
 STRUCT_END(ListModuleEntry, 8);

 struct Module FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  const xe::debug::proto::XObject *object() const {
-    return GetStruct<const xe::debug::proto::XObject *>(4);
+  const xe::debug::proto::XObject* object() const {
+    return GetStruct<const xe::debug::proto::XObject*>(4);
  }
  ModuleType type() const {
    return static_cast<ModuleType>(GetField<int8_t>(6, 0));
  }
-  const flatbuffers::String *name() const {
-    return GetPointer<const flatbuffers::String *>(8);
+  const flatbuffers::String* name() const {
+    return GetPointer<const flatbuffers::String*>(8);
  }
-  const flatbuffers::String *path() const {
-    return GetPointer<const flatbuffers::String *>(10);
+  const flatbuffers::String* path() const {
+    return GetPointer<const flatbuffers::String*>(10);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<xe::debug::proto::XObject>(verifier, 4 /* object */) &&
           VerifyField<int8_t>(verifier, 6 /* type */) &&
@@ -83,9 +83,9 @@ struct Module FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct ModuleBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  void add_object(const xe::debug::proto::XObject *object) {
+  void add_object(const xe::debug::proto::XObject* object) {
    fbb_.AddStruct(4, object);
  }
  void add_type(ModuleType type) {
@@ -97,10 +97,10 @@ struct ModuleBuilder {
  void add_path(flatbuffers::Offset<flatbuffers::String> path) {
    fbb_.AddOffset(10, path);
  }
-  ModuleBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  ModuleBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ModuleBuilder &operator=(const ModuleBuilder &);
+  ModuleBuilder& operator=(const ModuleBuilder&);
  flatbuffers::Offset<Module> Finish() {
    auto o = flatbuffers::Offset<Module>(fbb_.EndTable(start_, 4));
    return o;
@@ -108,8 +108,8 @@ struct ModuleBuilder {
 };

 inline flatbuffers::Offset<Module> CreateModule(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    const xe::debug::proto::XObject *object = 0,
+    flatbuffers::FlatBufferBuilder& _fbb,
+    const xe::debug::proto::XObject* object = 0,
    ModuleType type = ModuleType_Kernel,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    flatbuffers::Offset<flatbuffers::String> path = 0) {
@@ -122,18 +122,18 @@ inline flatbuffers::Offset<Module> CreateModule(
 }

 struct ListModulesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct ListModulesRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  ListModulesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  ListModulesRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListModulesRequestBuilder &operator=(const ListModulesRequestBuilder &);
+  ListModulesRequestBuilder& operator=(const ListModulesRequestBuilder&);
  flatbuffers::Offset<ListModulesRequest> Finish() {
    auto o = flatbuffers::Offset<ListModulesRequest>(fbb_.EndTable(start_, 0));
    return o;
@@ -141,17 +141,17 @@ struct ListModulesRequestBuilder {
 };

 inline flatbuffers::Offset<ListModulesRequest> CreateListModulesRequest(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  ListModulesRequestBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct ListModulesResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const flatbuffers::Vector<const ListModuleEntry *> *entry() const {
-    return GetPointer<const flatbuffers::Vector<const ListModuleEntry *> *>(4);
+  const flatbuffers::Vector<const ListModuleEntry*>* entry() const {
+    return GetPointer<const flatbuffers::Vector<const ListModuleEntry*>*>(4);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
           verifier.Verify(entry()) && verifier.EndTable();
@@ -159,17 +159,17 @@ struct ListModulesResponse FLATBUFFERS_FINAL_CLASS
 };

 struct ListModulesResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_entry(
-      flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry) {
+      flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry*>> entry) {
    fbb_.AddOffset(4, entry);
  }
-  ListModulesResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ListModulesResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListModulesResponseBuilder &operator=(const ListModulesResponseBuilder &);
+  ListModulesResponseBuilder& operator=(const ListModulesResponseBuilder&);
  flatbuffers::Offset<ListModulesResponse> Finish() {
    auto o = flatbuffers::Offset<ListModulesResponse>(fbb_.EndTable(start_, 1));
    return o;
@@ -177,8 +177,8 @@ struct ListModulesResponseBuilder {
 };

 inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry =
+    flatbuffers::FlatBufferBuilder& _fbb,
+    flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry*>> entry =
        0) {
  ListModulesResponseBuilder builder_(_fbb);
  builder_.add_entry(entry);
@@ -187,7 +187,7 @@ inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(

 struct GetModuleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  uint32_t module_id() const { return GetField<uint32_t>(4, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* module_id */) &&
           verifier.EndTable();
@@ -195,15 +195,15 @@ struct GetModuleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct GetModuleRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_module_id(uint32_t module_id) {
    fbb_.AddElement<uint32_t>(4, module_id, 0);
  }
-  GetModuleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  GetModuleRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  GetModuleRequestBuilder &operator=(const GetModuleRequestBuilder &);
+  GetModuleRequestBuilder& operator=(const GetModuleRequestBuilder&);
  flatbuffers::Offset<GetModuleRequest> Finish() {
    auto o = flatbuffers::Offset<GetModuleRequest>(fbb_.EndTable(start_, 1));
    return o;
@@ -211,15 +211,15 @@ struct GetModuleRequestBuilder {
 };

 inline flatbuffers::Offset<GetModuleRequest> CreateGetModuleRequest(
-    flatbuffers::FlatBufferBuilder &_fbb, uint32_t module_id = 0) {
+    flatbuffers::FlatBufferBuilder& _fbb, uint32_t module_id = 0) {
  GetModuleRequestBuilder builder_(_fbb);
  builder_.add_module_id(module_id);
  return builder_.Finish();
 }

 struct GetModuleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  const Module *module() const { return GetPointer<const Module *>(4); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  const Module* module() const { return GetPointer<const Module*>(4); }
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* module */) &&
           verifier.VerifyTable(module()) && verifier.EndTable();
@@ -227,15 +227,15 @@ struct GetModuleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct GetModuleResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_module(flatbuffers::Offset<Module> module) {
    fbb_.AddOffset(4, module);
  }
-  GetModuleResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  GetModuleResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  GetModuleResponseBuilder &operator=(const GetModuleResponseBuilder &);
+  GetModuleResponseBuilder& operator=(const GetModuleResponseBuilder&);
  flatbuffers::Offset<GetModuleResponse> Finish() {
    auto o = flatbuffers::Offset<GetModuleResponse>(fbb_.EndTable(start_, 1));
    return o;
@@ -243,7 +243,7 @@ struct GetModuleResponseBuilder {
 };

 inline flatbuffers::Offset<GetModuleResponse> CreateGetModuleResponse(
-    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<Module> module = 0) {
  GetModuleResponseBuilder builder_(_fbb);
  builder_.add_module(module);
@@ -254,10 +254,10 @@ struct FunctionEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
  uint32_t address_start() const { return GetField<uint32_t>(6, 0); }
  uint32_t address_end() const { return GetField<uint32_t>(8, 0); }
-  const flatbuffers::String *name() const {
-    return GetPointer<const flatbuffers::String *>(10);
+  const flatbuffers::String* name() const {
+    return GetPointer<const flatbuffers::String*>(10);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
           VerifyField<uint32_t>(verifier, 6 /* address_start */) &&
@@ -268,7 +268,7 @@ struct FunctionEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct FunctionEntryBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_identifier(uint64_t identifier) {
    fbb_.AddElement<uint64_t>(4, identifier, 0);
@@ -282,10 +282,10 @@ struct FunctionEntryBuilder {
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(10, name);
  }
-  FunctionEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  FunctionEntryBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  FunctionEntryBuilder &operator=(const FunctionEntryBuilder &);
+  FunctionEntryBuilder& operator=(const FunctionEntryBuilder&);
  flatbuffers::Offset<FunctionEntry> Finish() {
    auto o = flatbuffers::Offset<FunctionEntry>(fbb_.EndTable(start_, 4));
    return o;
@@ -293,7 +293,7 @@ struct FunctionEntryBuilder {
 };

 inline flatbuffers::Offset<FunctionEntry> CreateFunctionEntry(
-    flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0,
+    flatbuffers::FlatBufferBuilder& _fbb, uint64_t identifier = 0,
    uint32_t address_start = 0, uint32_t address_end = 0,
    flatbuffers::Offset<flatbuffers::String> name = 0) {
  FunctionEntryBuilder builder_(_fbb);
@@ -308,18 +308,18 @@ struct Function FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
  uint32_t address_start() const { return GetField<uint32_t>(6, 0); }
  uint32_t address_end() const { return GetField<uint32_t>(8, 0); }
-  const flatbuffers::String *name() const {
-    return GetPointer<const flatbuffers::String *>(10);
+  const flatbuffers::String* name() const {
+    return GetPointer<const flatbuffers::String*>(10);
  }
  uint32_t machine_code_start() const { return GetField<uint32_t>(12, 0); }
  uint32_t machine_code_end() const { return GetField<uint32_t>(14, 0); }
-  const flatbuffers::String *disasm_hir_raw() const {
-    return GetPointer<const flatbuffers::String *>(16);
+  const flatbuffers::String* disasm_hir_raw() const {
+    return GetPointer<const flatbuffers::String*>(16);
  }
-  const flatbuffers::String *disasm_hir_opt() const {
-    return GetPointer<const flatbuffers::String *>(18);
+  const flatbuffers::String* disasm_hir_opt() const {
+    return GetPointer<const flatbuffers::String*>(18);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
           VerifyField<uint32_t>(verifier, 6 /* address_start */) &&
@@ -338,7 +338,7 @@ struct Function FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct FunctionBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_identifier(uint64_t identifier) {
    fbb_.AddElement<uint64_t>(4, identifier, 0);
@@ -366,10 +366,10 @@ struct FunctionBuilder {
      flatbuffers::Offset<flatbuffers::String> disasm_hir_opt) {
    fbb_.AddOffset(18, disasm_hir_opt);
  }
-  FunctionBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  FunctionBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  FunctionBuilder &operator=(const FunctionBuilder &);
+  FunctionBuilder& operator=(const FunctionBuilder&);
  flatbuffers::Offset<Function> Finish() {
    auto o = flatbuffers::Offset<Function>(fbb_.EndTable(start_, 8));
    return o;
@@ -377,7 +377,7 @@ struct FunctionBuilder {
 };

 inline flatbuffers::Offset<Function> CreateFunction(
-    flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0,
+    flatbuffers::FlatBufferBuilder& _fbb, uint64_t identifier = 0,
    uint32_t address_start = 0, uint32_t address_end = 0,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    uint32_t machine_code_start = 0, uint32_t machine_code_end = 0,
@@ -400,7 +400,7 @@ struct ListFunctionsRequest FLATBUFFERS_FINAL_CLASS
  uint32_t module_id() const { return GetField<uint32_t>(4, 0); }
  uint32_t function_index_start() const { return GetField<uint32_t>(6, 0); }
  uint32_t function_index_end() const { return GetField<uint32_t>(8, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* module_id */) &&
           VerifyField<uint32_t>(verifier, 6 /* function_index_start */) &&
@@ -410,7 +410,7 @@ struct ListFunctionsRequest FLATBUFFERS_FINAL_CLASS
 };

 struct ListFunctionsRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_module_id(uint32_t module_id) {
    fbb_.AddElement<uint32_t>(4, module_id, 0);
@@ -421,11 +421,11 @@ struct ListFunctionsRequestBuilder {
  void add_function_index_end(uint32_t function_index_end) {
    fbb_.AddElement<uint32_t>(8, function_index_end, 0);
  }
-  ListFunctionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ListFunctionsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListFunctionsRequestBuilder &operator=(const ListFunctionsRequestBuilder &);
+  ListFunctionsRequestBuilder& operator=(const ListFunctionsRequestBuilder&);
  flatbuffers::Offset<ListFunctionsRequest> Finish() {
    auto o =
        flatbuffers::Offset<ListFunctionsRequest>(fbb_.EndTable(start_, 3));
@@ -434,7 +434,7 @@ struct ListFunctionsRequestBuilder {
 };

 inline flatbuffers::Offset<ListFunctionsRequest> CreateListFunctionsRequest(
-    flatbuffers::FlatBufferBuilder &_fbb, uint32_t module_id = 0,
+    flatbuffers::FlatBufferBuilder& _fbb, uint32_t module_id = 0,
    uint32_t function_index_start = 0, uint32_t function_index_end = 0) {
  ListFunctionsRequestBuilder builder_(_fbb);
  builder_.add_function_index_end(function_index_end);
@@ -445,11 +445,11 @@ inline flatbuffers::Offset<ListFunctionsRequest> CreateListFunctionsRequest(

 struct ListFunctionsResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *entry() const {
+  const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>* entry() const {
    return GetPointer<
-        const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *>(4);
+        const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>*>(4);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
           verifier.Verify(entry()) && verifier.VerifyVectorOfTables(entry()) &&
@@ -458,17 +458,17 @@ struct ListFunctionsResponse FLATBUFFERS_FINAL_CLASS
 };

 struct ListFunctionsResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_entry(flatbuffers::Offset<
      flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>> entry) {
    fbb_.AddOffset(4, entry);
  }
-  ListFunctionsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ListFunctionsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListFunctionsResponseBuilder &operator=(const ListFunctionsResponseBuilder &);
+  ListFunctionsResponseBuilder& operator=(const ListFunctionsResponseBuilder&);
  flatbuffers::Offset<ListFunctionsResponse> Finish() {
    auto o =
        flatbuffers::Offset<ListFunctionsResponse>(fbb_.EndTable(start_, 1));
@@ -477,7 +477,7 @@ struct ListFunctionsResponseBuilder {
 };

 inline flatbuffers::Offset<ListFunctionsResponse> CreateListFunctionsResponse(
-    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>>
        entry = 0) {
  ListFunctionsResponseBuilder builder_(_fbb);
@@ -487,7 +487,7 @@ inline flatbuffers::Offset<ListFunctionsResponse> CreateListFunctionsResponse(

 struct GetFunctionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
           verifier.EndTable();
@@ -495,15 +495,15 @@ struct GetFunctionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct GetFunctionRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_identifier(uint64_t identifier) {
    fbb_.AddElement<uint64_t>(4, identifier, 0);
  }
-  GetFunctionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  GetFunctionRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  GetFunctionRequestBuilder &operator=(const GetFunctionRequestBuilder &);
+  GetFunctionRequestBuilder& operator=(const GetFunctionRequestBuilder&);
  flatbuffers::Offset<GetFunctionRequest> Finish() {
    auto o = flatbuffers::Offset<GetFunctionRequest>(fbb_.EndTable(start_, 1));
    return o;
@@ -511,7 +511,7 @@ struct GetFunctionRequestBuilder {
 };

 inline flatbuffers::Offset<GetFunctionRequest> CreateGetFunctionRequest(
-    flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0) {
+    flatbuffers::FlatBufferBuilder& _fbb, uint64_t identifier = 0) {
  GetFunctionRequestBuilder builder_(_fbb);
  builder_.add_identifier(identifier);
  return builder_.Finish();
@@ -519,8 +519,8 @@ inline flatbuffers::Offset<GetFunctionRequest> CreateGetFunctionRequest(

 struct GetFunctionResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const Function *function() const { return GetPointer<const Function *>(4); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  const Function* function() const { return GetPointer<const Function*>(4); }
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* function */) &&
           verifier.VerifyTable(function()) && verifier.EndTable();
@@ -528,16 +528,16 @@ struct GetFunctionResponse FLATBUFFERS_FINAL_CLASS
 };

 struct GetFunctionResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_function(flatbuffers::Offset<Function> function) {
    fbb_.AddOffset(4, function);
  }
-  GetFunctionResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  GetFunctionResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  GetFunctionResponseBuilder &operator=(const GetFunctionResponseBuilder &);
+  GetFunctionResponseBuilder& operator=(const GetFunctionResponseBuilder&);
  flatbuffers::Offset<GetFunctionResponse> Finish() {
    auto o = flatbuffers::Offset<GetFunctionResponse>(fbb_.EndTable(start_, 1));
    return o;
@@ -545,7 +545,7 @@ struct GetFunctionResponseBuilder {
 };

 inline flatbuffers::Offset<GetFunctionResponse> CreateGetFunctionResponse(
-    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<Function> function = 0) {
  GetFunctionResponseBuilder builder_(_fbb);
  builder_.add_function(function);
--- a/src/xenia/debug/proto/threads_generated.h
+++ b/src/xenia/debug/proto/threads_generated.h
@@ -23,18 +23,18 @@ struct ListThreadsResponse;

 enum ThreadType { ThreadType_Kernel = 0, ThreadType_User = 1 };

-inline const char **EnumNamesThreadType() {
-  static const char *names[] = {"Kernel", "User", nullptr};
+inline const char** EnumNamesThreadType() {
+  static const char* names[] = {"Kernel", "User", nullptr};
  return names;
 }

-inline const char *EnumNameThreadType(ThreadType e) {
+inline const char* EnumNameThreadType(ThreadType e) {
  return EnumNamesThreadType()[e];
 }

 struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  const xe::debug::proto::XObject *object() const {
-    return GetStruct<const xe::debug::proto::XObject *>(4);
+  const xe::debug::proto::XObject* object() const {
+    return GetStruct<const xe::debug::proto::XObject*>(4);
  }
  ThreadType type() const {
    return static_cast<ThreadType>(GetField<int8_t>(6, 0));
@@ -48,13 +48,13 @@ struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  uint32_t pcr_address() const { return GetField<uint32_t>(20, 0); }
  uint32_t thread_state_address() const { return GetField<uint32_t>(22, 0); }
  uint32_t thread_id() const { return GetField<uint32_t>(24, 0); }
-  const flatbuffers::String *name() const {
-    return GetPointer<const flatbuffers::String *>(26);
+  const flatbuffers::String* name() const {
+    return GetPointer<const flatbuffers::String*>(26);
  }
  uint32_t priority() const { return GetField<uint32_t>(28, 0); }
  uint32_t affinity() const { return GetField<uint32_t>(30, 0); }
  uint32_t state() const { return GetField<uint32_t>(32, 0); }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<xe::debug::proto::XObject>(verifier, 4 /* object */) &&
           VerifyField<int8_t>(verifier, 6 /* type */) &&
@@ -77,9 +77,9 @@ struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };

 struct ThreadBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  void add_object(const xe::debug::proto::XObject *object) {
+  void add_object(const xe::debug::proto::XObject* object) {
    fbb_.AddStruct(4, object);
  }
  void add_type(ThreadType type) {
@@ -122,10 +122,10 @@ struct ThreadBuilder {
    fbb_.AddElement<uint32_t>(30, affinity, 0);
  }
  void add_state(uint32_t state) { fbb_.AddElement<uint32_t>(32, state, 0); }
-  ThreadBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  ThreadBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ThreadBuilder &operator=(const ThreadBuilder &);
+  ThreadBuilder& operator=(const ThreadBuilder&);
  flatbuffers::Offset<Thread> Finish() {
    auto o = flatbuffers::Offset<Thread>(fbb_.EndTable(start_, 15));
    return o;
@@ -133,8 +133,8 @@ struct ThreadBuilder {
 };

 inline flatbuffers::Offset<Thread> CreateThread(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    const xe::debug::proto::XObject *object = 0,
+    flatbuffers::FlatBufferBuilder& _fbb,
+    const xe::debug::proto::XObject* object = 0,
    ThreadType type = ThreadType_Kernel, uint32_t stack_size = 0,
    uint32_t xapi_thread_startup = 0, uint32_t start_address = 0,
    uint32_t start_context = 0, uint32_t creation_flags = 0,
@@ -162,18 +162,18 @@ inline flatbuffers::Offset<Thread> CreateThread(
 }

 struct ListThreadsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
 };

 struct ListThreadsRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
-  ListThreadsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+  ListThreadsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListThreadsRequestBuilder &operator=(const ListThreadsRequestBuilder &);
+  ListThreadsRequestBuilder& operator=(const ListThreadsRequestBuilder&);
  flatbuffers::Offset<ListThreadsRequest> Finish() {
    auto o = flatbuffers::Offset<ListThreadsRequest>(fbb_.EndTable(start_, 0));
    return o;
@@ -181,18 +181,18 @@ struct ListThreadsRequestBuilder {
 };

 inline flatbuffers::Offset<ListThreadsRequest> CreateListThreadsRequest(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+    flatbuffers::FlatBufferBuilder& _fbb) {
  ListThreadsRequestBuilder builder_(_fbb);
  return builder_.Finish();
 }

 struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
-  const flatbuffers::Vector<flatbuffers::Offset<Thread>> *thread() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Thread>> *>(
+  const flatbuffers::Vector<flatbuffers::Offset<Thread>>* thread() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Thread>>*>(
        4);
  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(flatbuffers::Verifier& verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* thread */) &&
           verifier.Verify(thread()) &&
@@ -201,17 +201,17 @@ struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS
 };

 struct ListThreadsResponseBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::FlatBufferBuilder& fbb_;
  flatbuffers::uoffset_t start_;
  void add_thread(flatbuffers::Offset<
      flatbuffers::Vector<flatbuffers::Offset<Thread>>> thread) {
    fbb_.AddOffset(4, thread);
  }
-  ListThreadsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ListThreadsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
-  ListThreadsResponseBuilder &operator=(const ListThreadsResponseBuilder &);
+  ListThreadsResponseBuilder& operator=(const ListThreadsResponseBuilder&);
  flatbuffers::Offset<ListThreadsResponse> Finish() {
    auto o = flatbuffers::Offset<ListThreadsResponse>(fbb_.EndTable(start_, 1));
    return o;
@@ -219,7 +219,7 @@ struct ListThreadsResponseBuilder {
 };

 inline flatbuffers::Offset<ListThreadsResponse> CreateListThreadsResponse(
-    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Thread>>>
        thread = 0) {
  ListThreadsResponseBuilder builder_(_fbb);