Move RegisterValue,Scalar,State from Core to Utility

[labath]

Summary

These three classes have no external dependencies, but they are used
from various low-level APIs. Moving them down to Utility improves
overall code layering (although it still does not break any particular
dependency completely).

[teemperor]

Did you test that with lldb's C++ modules? If not I can test it locally.

[labath]

In D49740#1173655, @teemperor wrote:

Did you test that with lldb's C++ modules? If not I can test it locally.

I didn't, but I don't expect there to be any issues, as I've made sure that the moved files don't include anything outside of lldb/Utility. You're welcome to try it out, of course.

[teemperor]

Sounds reasonable. It seems both arcanist and patch can't handle the patch file, so let's just see how it goes post-commit.

[labath]

Does anyone have thoughts on this? (I have one more move like this lined up (for the Listener/Broadcaster classes), and then I should be done with these kinds of changes for a while.)

[zturner]

No objections here

[jingham]

I worry a little bit about Utility getting kind of incoherent. Some of it is clearly utility, some is more there because that's where we are putting the code we're trying to reduce dependencies on so we can share then with lldb-server. RegisterValue doesn't for instance seem like a "Utility" class to me. But maybe this is something to revisit once you've gotten at least what you need for lldb-server done?

[labath]

In D49740#1187799, @jingham wrote:

I worry a little bit about Utility getting kind of incoherent. Some of it is clearly utility, some is more there because that's where we are putting the code we're trying to reduce dependencies on so we can share then with lldb-server. RegisterValue doesn't for instance seem like a "Utility" class to me. But maybe this is something to revisit once you've gotten at least what you need for lldb-server done?

I think being a mixed bag is kind of an inherent property of the lowest layers. LLVM's Support library is also a collection of utilities, which have very little in common, but can be combined in various interesting ways to do cool stuff.

I am not opposed to opening the discussion of splitting and/or putting these three classes into a difference place right now. If you have an idea on how to organize it, I'd like to hear it.

However, I have to say, that RegisterValue actually *does* seem like a good fit for Utility to me -- it's the kind of a thing (representing a "value" of a "register") that every conceivable debugger will need. So it seems good to have it in a place where everybody can use (Utilize :)) it. It's also not host-dependent, as we want to represent registers on remote machines too, so it does not seem like it belongs to Host (although putting it there would have been enough for my present needs).

The question that I am not too clear on is what then becomes of "Core", which I think had a similar design goal in mind. Once I am finished here, it will become kind of empty. I guess my best current definition for it would be that it is the "core" of this single specific debugger called "liblldb", which ties all of the interesting components from other modules together, and which probably don't make sense to reuse in a different debugger (e.g. for Zachary's tracing debugger, he could conceivably find a use for RegisterValue or other stuff in Utility, but it's unlikely he would ever want to use the Debugger class). However, I am not really clear on which of our current classes would fit this description.

Looking over the current contents of the Utility module, I see only a couple of things that I would not choose to put there:

• CompletionRequest - this sounds like it could go next to the command interpreter
• SafeMachO - ObjectFileMachO ?
• SelectHelper - Host (probably somehow merged with the MainLoop class)

However, I'm not too bothered by them being there either, and I doubt this would help with the issues that are troubling you.

[zturner]

Several months ago when this came up, i hypothesized that Utility would
eventually contain a mix of random stuff some of which may not make sense
in the long term. But that in the meantime, it’s useful to have some sort
of layering abstraction for “has no other dependencies”. Eventually when
this reaches critical mass, a natural separation should present itself,
because all the stuff that conceptually belongs together will be in
Utility. So then we can break Utility up into a more logical separation

[jingham]

First off, I'm fine with Zachary's suggestion that we let the dust settle a bit before we try to organize things better. We'll probably do a better job then.

But just to use these cases, for instance, Scalar is the base of how we realize values in the debugger (ValueObject lives on top of this). It would be good if its landing place was such that if I was looking at how we represent values it was logically placed for that. State is part of how we present the Process current state, so it seems like it should be grouped with other process related entities. And RegisterValue belongs with the other parts of lldb that take apart the machine level state of a process.

It will probably go away, but FastDemangle really belongs around the language handling code. I agree that Utility is an odd place for CompletionRequest...

SafeMachO is weird. It gets used in Host - both common & macosx, and we're trying not to include out of Plugins so the MachO object file plugin directory doesn't seem right. Maybe Host is a better place, it's reason for being is so you can include both llvm/Support/MachO.h and mach/machine.h, so even though it's not directly a host functionality it look a bit like that. Not sure.

There's also tension between "things that belong together functionally" and "things that need to be separated because we want to layer one strictly on top of the other, since we seem to be treating directories as a representation of dependencies. Do we want to have a Values directory with ValueObject at the top level, and Scalar in a no-dependency subdirectory?

TTTT, if I need to find a file these days, I either Cmd-Click on a type to go to its definition, or type Cmd-Shift-O and start typing some bits of the file name and Xcode finds it for me. I'm pretty familiar with the code, so I don't need a higher level skeleton to help me figure out what all is in this project. I think at this point many of us are in this state...

But once you get past the build issues, the real audience for this level of organization is folks coming new to the project. It would be good to hear from some of the newer folks what they found confusing or what would have helped them navigate around the project as they are starting out.

[zturner]

For the Register stuff, for example, I think it could make sense for it to be in a project such as HAL (Hardware Abstraction Layer) or something similarly named. Everything that describes properties of specific CPUs could go there, perhaps even including ArchSpec. For the Scalar stuff, perhaps a target called Visualization (or even just Value). Once more and more stuff starts ending up in Utility, I think it makes sense to try something like this.

[teemperor]

CompletionRequest - this sounds like it could go next to the command interpreter

Yeah, makes sense. Even though Utility classes then can either not offer completion methods (currently only ArchSpec is doing that) or work around that with a forward decl. But I think that's not a big issue.

[labath]

In D49740#1188055, @jingham wrote:

First off, I'm fine with Zachary's suggestion that we let the dust settle a bit before we try to organize things better. We'll probably do a better job then.

Thanks. I agree this can wait, but I also do have some ideas below on what could done differently right now for the Scalar and State classes. Let me know if you think I should try that instead. (Otherwise, I'll just go ahead with this.)

But just to use these cases, for instance, Scalar is the base of how we realize values in the debugger (ValueObject lives on top of this). It would be good if its landing place was such that if I was looking at how we represent values it was logically placed for that.

I think putting Scalar next to the ValueObject stuff would make sense, if the ValueObjects were the only user of this class. However, that isn't the case right now. The reason I am touching this class in the first place is that it is being used from within the RegisterValue class. This means it is more than just a ValueObject helper, but more like a self-contained "utility" which can be reused in different contexts.

Now, I am not actually sure whether using Scalar within RegisterValue is a good idea (seems a bit overkill for that), but it seemed to work, so I didn't want to disturb that (and I do believe that Scalar could be useful outside of the ValueObject hierarchy). However, I can take another look at what it would take to stop using Scalar in the context of RegisterValues, which would free us up to move RegisterValue without touching the Scalar class.

State is part of how we present the Process current state, so it seems like it should be grouped with other process related entities.

State is a bit funny. It is currently used from both liblldb and lldb-server, but these use different hierarchies for "process-related entities", so that's why I'm moving it to a common place. However, I can certainly see a case for LLGS and liblldb having different State enums. Sharing it doesn't buy us much (ATM it's just the StateAsCString function), and using a different enum in LLGS would have another benefit. Right now it only uses a subset of all State values, so using an different enum would allow us to capture the possible states more precisely. Doing that instead of moving State.h around should be easy enough.

And RegisterValue belongs with the other parts of lldb that take apart the machine level state of a process.

I am not sure which parts are *you* thinking about here, but I think it would be nice to have this class together with all the definitions of RegisterInfo structs and associated constants. These are now mostly in Plugin/Process/Utility, but so is a lot of other stuff. At one point I will get around to worrying about those too, so maybe then we could move all of these things to a separate module.

It will probably go away, but FastDemangle really belongs around the language handling code. I agree that Utility is an odd place for CompletionRequest...

SafeMachO is weird. It gets used in Host - both common & macosx, and we're trying not to include out of Plugins so the MachO object file plugin directory doesn't seem right. Maybe Host is a better place, it's reason for being is so you can include both llvm/Support/MachO.h and mach/machine.h, so even though it's not directly a host functionality it look a bit like that. Not sure.

I think Host makes sense. None of the other code (except the NativeProcessXXX classes, I guess) should really be including OS-specific stuff, so there shouldn't be a need (in an ideal world, I don't know how far we are from it right now) for this header anywhere except Host code.

There's also tension between "things that belong together functionally" and "things that need to be separated because we want to layer one strictly on top of the other, since we seem to be treating directories as a representation of dependencies. Do we want to have a Values directory with ValueObject at the top level, and Scalar in a no-dependency subdirectory?

TTTT, if I need to find a file these days, I either Cmd-Click on a type to go to its definition, or type Cmd-Shift-O and start typing some bits of the file name and Xcode finds it for me. I'm pretty familiar with the code, so I don't need a higher level skeleton to help me figure out what all is in this project. I think at this point many of us are in this state...

But once you get past the build issues, the real audience for this level of organization is folks coming new to the project. It would be good to hear from some of the newer folks what they found confusing or what would have helped them navigate around the project as they are starting out.

Yes, that's certainly a good point. I'd like to hear that too.

[labath]

In D49740#1188079, @teemperor wrote:

CompletionRequest - this sounds like it could go next to the command interpreter

Yeah, makes sense. Even though Utility classes then can either not offer completion methods (currently only ArchSpec is doing that) or work around that with a forward decl. But I think that's not a big issue.

I am not too bothered by that either, but I think that for the thing that the ArchSpec function is doing, passing it the entire CompletionRequest is overkill. Ideally, I'd set things up such that ArchSpec and friends don't have any knowledge of "completion" -- they would just offer an interface for accessing all possible values(*), and then completion could be built on top of that. This way the data source can be independent of the actual algorithm computing the completions.

(*) The interface could be as simple as an iterator over all ArchSpec string values. However, this may not be good enough in terms of performance (it wouldn't matter for ArchSpec, but it might for some other classes), in which case we might want to do something slightly more fancy (GiveMeAllValuesStartingWith("foo")).

[jingham]

In D49740#1188587, @labath wrote:

In D49740#1188055, @jingham wrote:

First off, I'm fine with Zachary's suggestion that we let the dust settle a bit before we try to organize things better. We'll probably do a better job then.

Thanks. I agree this can wait, but I also do have some ideas below on what could done differently right now for the Scalar and State classes. Let me know if you think I should try that instead. (Otherwise, I'll just go ahead with this.)

It doesn't seem like you're doing anything that is going to be hard to undo, so I'm fine with just doing this as you have it for now. Maybe see if SafeMachO can go in Host, but that's the only one that seems easy and not requiring deeper thought.

But just to use these cases, for instance, Scalar is the base of how we realize values in the debugger (ValueObject lives on top of this). It would be good if its landing place was such that if I was looking at how we represent values it was logically placed for that.

I think putting Scalar next to the ValueObject stuff would make sense, if the ValueObjects were the only user of this class. However, that isn't the case right now. The reason I am touching this class in the first place is that it is being used from within the RegisterValue class. This means it is more than just a ValueObject helper, but more like a self-contained "utility" which can be reused in different contexts.

Now, I am not actually sure whether using Scalar within RegisterValue is a good idea (seems a bit overkill for that), but it seemed to work, so I didn't want to disturb that (and I do believe that Scalar could be useful outside of the ValueObject hierarchy). However, I can take another look at what it would take to stop using Scalar in the context of RegisterValues, which would free us up to move RegisterValue without touching the Scalar class.

I'm not sure how much of Scalar RegisterValue needs when it isn't being used to back a ValueObjectRegister. Scalar is a pretty ambitious class, since it supports everything you would need to back DWARF expression manipulations. RegisterValue does get used in a bunch of places stand alone, though a lot of that just seems to be setting or dumping.

But I guess I'm looking for an organization based on "groups by functionality" rather than "who uses what". So even though other actors might use Scalar, it's reason for being is to present values. For the purposes of understanding the code, grouping all the files that work together for a task seems to me like it would help. But again, this is more in the service of people newer to the code.

State is part of how we present the Process current state, so it seems like it should be grouped with other process related entities.

State is a bit funny. It is currently used from both liblldb and lldb-server, but these use different hierarchies for "process-related entities", so that's why I'm moving it to a common place. However, I can certainly see a case for LLGS and liblldb having different State enums. Sharing it doesn't buy us much (ATM it's just the StateAsCString function), and using a different enum in LLGS would have another benefit. Right now it only uses a subset of all State values, so using an different enum would allow us to capture the possible states more precisely. Doing that instead of moving State.h around should be easy enough.

And RegisterValue belongs with the other parts of lldb that take apart the machine level state of a process.

I am not sure which parts are *you* thinking about here, but I think it would be nice to have this class together with all the definitions of RegisterInfo structs and associated constants. These are now mostly in Plugin/Process/Utility, but so is a lot of other stuff. At one point I will get around to worrying about those too, so maybe then we could move all of these things to a separate module.

It will probably go away, but FastDemangle really belongs around the language handling code. I agree that Utility is an odd place for CompletionRequest...

SafeMachO is weird. It gets used in Host - both common & macosx, and we're trying not to include out of Plugins so the MachO object file plugin directory doesn't seem right. Maybe Host is a better place, it's reason for being is so you can include both llvm/Support/MachO.h and mach/machine.h, so even though it's not directly a host functionality it look a bit like that. Not sure.

I think Host makes sense. None of the other code (except the NativeProcessXXX classes, I guess) should really be including OS-specific stuff, so there shouldn't be a need (in an ideal world, I don't know how far we are from it right now) for this header anywhere except Host code.

Yes, that makes sense to me.

There's also tension between "things that belong together functionally" and "things that need to be separated because we want to layer one strictly on top of the other, since we seem to be treating directories as a representation of dependencies. Do we want to have a Values directory with ValueObject at the top level, and Scalar in a no-dependency subdirectory?

TTTT, if I need to find a file these days, I either Cmd-Click on a type to go to its definition, or type Cmd-Shift-O and start typing some bits of the file name and Xcode finds it for me. I'm pretty familiar with the code, so I don't need a higher level skeleton to help me figure out what all is in this project. I think at this point many of us are in this state...

But once you get past the build issues, the real audience for this level of organization is folks coming new to the project. It would be good to hear from some of the newer folks what they found confusing or what would have helped them navigate around the project as they are starting out.

Yes, that's certainly a good point. I'd like to hear that too.

[labath]

Thanks. I'll commit this and look at moving SafeMachO next.

But I guess I'm looking for an organization based on "groups by functionality" rather than "who uses what". So even though other actors might use Scalar, it's reason for being is to present values. For the purposes of understanding the code, grouping all the files that work together for a task seems to me like it would help.

I don't this these are that much different objectives. If Scalar is used by RegisterValue then, whether we like it or not, it's functionality is also to provide services to that class. That certainly wasn't what the class was written for originally, but it is what we have now.

When working on ValueObjects, it would be logical to have Scalar next to them. However, I don't think having Scalar somewhere else would be too surprising either. After all, displaying debugger values is a complex functionality, so it's not surprising it uses some generic number manipulation class (which is what Scalar would be in this world view). On the other hand, I would be *very* surprised if I was working on code reading a register from process memory and found out it references a class which purports to do dwarf expression evaluation.

lldb/trunk/include/lldb/Core/RegisterValue.h

-//===-- RegisterValue.h -----------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef lldb_RegisterValue_h
-#define lldb_RegisterValue_h
-
-#include "lldb/Core/Scalar.h"
-#include "lldb/Utility/Endian.h"
-#include "lldb/Utility/Status.h"    // for Status
-#include "lldb/lldb-enumerations.h" // for ByteOrder, Format
-#include "lldb/lldb-types.h"        // for offset_t
-
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/StringRef.h" // for StringRef
-
-#include <stdint.h> // for uint32_t, uint8_t, uint64_t, uin...
-#include <string.h>
-
-namespace lldb_private {
-class DataExtractor;
-}
-namespace lldb_private {
-class Stream;
-}
-namespace lldb_private {
-struct RegisterInfo;
-}
-namespace lldb_private {
-
-class RegisterValue {
-public:
-  enum { kMaxRegisterByteSize = 64u };
-
-  enum Type {
-    eTypeInvalid,
-    eTypeUInt8,
-    eTypeUInt16,
-    eTypeUInt32,
-    eTypeUInt64,
-    eTypeUInt128,
-    eTypeFloat,
-    eTypeDouble,
-    eTypeLongDouble,
-    eTypeBytes
-  };
-
-  RegisterValue() : m_type(eTypeInvalid), m_scalar((unsigned long)0) {}
-
-  explicit RegisterValue(uint8_t inst) : m_type(eTypeUInt8) { m_scalar = inst; }
-
-  explicit RegisterValue(uint16_t inst) : m_type(eTypeUInt16) {
-    m_scalar = inst;
-  }
-
-  explicit RegisterValue(uint32_t inst) : m_type(eTypeUInt32) {
-    m_scalar = inst;
-  }
-
-  explicit RegisterValue(uint64_t inst) : m_type(eTypeUInt64) {
-    m_scalar = inst;
-  }
-
-  explicit RegisterValue(llvm::APInt inst) : m_type(eTypeUInt128) {
-    m_scalar = llvm::APInt(inst);
-  }
-
-  explicit RegisterValue(float value) : m_type(eTypeFloat) { m_scalar = value; }
-
-  explicit RegisterValue(double value) : m_type(eTypeDouble) {
-    m_scalar = value;
-  }
-
-  explicit RegisterValue(long double value) : m_type(eTypeLongDouble) {
-    m_scalar = value;
-  }
-
-  explicit RegisterValue(uint8_t *bytes, size_t length,
-                         lldb::ByteOrder byte_order) {
-    SetBytes(bytes, length, byte_order);
-  }
-
-  RegisterValue::Type GetType() const { return m_type; }
-
-  bool CopyValue(const RegisterValue &rhs);
-
-  void SetType(RegisterValue::Type type) { m_type = type; }
-
-  RegisterValue::Type SetType(const RegisterInfo *reg_info);
-
-  bool GetData(DataExtractor &data) const;
-
-  // Copy the register value from this object into a buffer in "dst" and obey
-  // the "dst_byte_order" when copying the data. Also watch out in case
-  // "dst_len" is longer or shorter than the register value described by
-  // "reg_info" and only copy the least significant bytes of the register
-  // value, or pad the destination with zeroes if the register byte size is
-  // shorter that "dst_len" (all while correctly abiding the "dst_byte_order").
-  // Returns the number of bytes copied into "dst".
-  uint32_t GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
-                           uint32_t dst_len, lldb::ByteOrder dst_byte_order,
-                           Status &error) const;
-
-  uint32_t SetFromMemoryData(const RegisterInfo *reg_info, const void *src,
-                             uint32_t src_len, lldb::ByteOrder src_byte_order,
-                             Status &error);
-
-  bool GetScalarValue(Scalar &scalar) const;
-
-  uint8_t GetAsUInt8(uint8_t fail_value = UINT8_MAX,
-                     bool *success_ptr = nullptr) const {
-    if (m_type == eTypeUInt8) {
-      if (success_ptr)
-        *success_ptr = true;
-      return m_scalar.UChar(fail_value);
-    }
-    if (success_ptr)
-      *success_ptr = true;
-    return fail_value;
-  }
-
-  uint16_t GetAsUInt16(uint16_t fail_value = UINT16_MAX,
-                       bool *success_ptr = nullptr) const;
-
-  uint32_t GetAsUInt32(uint32_t fail_value = UINT32_MAX,
-                       bool *success_ptr = nullptr) const;
-
-  uint64_t GetAsUInt64(uint64_t fail_value = UINT64_MAX,
-                       bool *success_ptr = nullptr) const;
-
-  llvm::APInt GetAsUInt128(const llvm::APInt &fail_value,
-                           bool *success_ptr = nullptr) const;
-
-  float GetAsFloat(float fail_value = 0.0f, bool *success_ptr = nullptr) const;
-
-  double GetAsDouble(double fail_value = 0.0,
-                     bool *success_ptr = nullptr) const;
-
-  long double GetAsLongDouble(long double fail_value = 0.0,
-                              bool *success_ptr = nullptr) const;
-
-  void SetValueToInvalid() { m_type = eTypeInvalid; }
-
-  bool ClearBit(uint32_t bit);
-
-  bool SetBit(uint32_t bit);
-
-  bool operator==(const RegisterValue &rhs) const;
-
-  bool operator!=(const RegisterValue &rhs) const;
-
-  void operator=(uint8_t uint) {
-    m_type = eTypeUInt8;
-    m_scalar = uint;
-  }
-
-  void operator=(uint16_t uint) {
-    m_type = eTypeUInt16;
-    m_scalar = uint;
-  }
-
-  void operator=(uint32_t uint) {
-    m_type = eTypeUInt32;
-    m_scalar = uint;
-  }
-
-  void operator=(uint64_t uint) {
-    m_type = eTypeUInt64;
-    m_scalar = uint;
-  }
-
-  void operator=(llvm::APInt uint) {
-    m_type = eTypeUInt128;
-    m_scalar = llvm::APInt(uint);
-  }
-
-  void operator=(float f) {
-    m_type = eTypeFloat;
-    m_scalar = f;
-  }
-
-  void operator=(double f) {
-    m_type = eTypeDouble;
-    m_scalar = f;
-  }
-
-  void operator=(long double f) {
-    m_type = eTypeLongDouble;
-    m_scalar = f;
-  }
-
-  void SetUInt8(uint8_t uint) {
-    m_type = eTypeUInt8;
-    m_scalar = uint;
-  }
-
-  void SetUInt16(uint16_t uint) {
-    m_type = eTypeUInt16;
-    m_scalar = uint;
-  }
-
-  void SetUInt32(uint32_t uint, Type t = eTypeUInt32) {
-    m_type = t;
-    m_scalar = uint;
-  }
-
-  void SetUInt64(uint64_t uint, Type t = eTypeUInt64) {
-    m_type = t;
-    m_scalar = uint;
-  }
-
-  void SetUInt128(llvm::APInt uint) {
-    m_type = eTypeUInt128;
-    m_scalar = uint;
-  }
-
-  bool SetUInt(uint64_t uint, uint32_t byte_size);
-
-  void SetFloat(float f) {
-    m_type = eTypeFloat;
-    m_scalar = f;
-  }
-
-  void SetDouble(double f) {
-    m_type = eTypeDouble;
-    m_scalar = f;
-  }
-
-  void SetLongDouble(long double f) {
-    m_type = eTypeLongDouble;
-    m_scalar = f;
-  }
-
-  void SetBytes(const void *bytes, size_t length, lldb::ByteOrder byte_order);
-
-  bool SignExtend(uint32_t sign_bitpos);
-
-  Status SetValueFromString(const RegisterInfo *reg_info,
-                            llvm::StringRef value_str);
-  Status SetValueFromString(const RegisterInfo *reg_info,
-                            const char *value_str) = delete;
-
-  Status SetValueFromData(const RegisterInfo *reg_info, DataExtractor &data,
-                          lldb::offset_t offset, bool partial_data_ok);
-
-  const void *GetBytes() const;
-
-  lldb::ByteOrder GetByteOrder() const {
-    if (m_type == eTypeBytes)
-      return buffer.byte_order;
-    return endian::InlHostByteOrder();
-  }
-
-  uint32_t GetByteSize() const;
-
-  static uint32_t GetMaxByteSize() { return kMaxRegisterByteSize; }
-
-  void Clear();
-
-protected:
-  RegisterValue::Type m_type;
-  Scalar m_scalar;
-
-  struct {
-    uint8_t bytes[kMaxRegisterByteSize]; // This must be big enough to hold any
-                                         // register for any supported target.
-    uint8_t length;
-    lldb::ByteOrder byte_order;
-  } buffer;
-};
-
-} // namespace lldb_private
-
-#endif // lldb_RegisterValue_h

lldb/trunk/include/lldb/Core/Scalar.h

-//===-- Scalar.h ------------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_Scalar_h_
-#define liblldb_Scalar_h_
-
-#include "lldb/Utility/Status.h"     // for Status
-#include "lldb/lldb-enumerations.h"  // for Encoding, ByteOrder
-#include "lldb/lldb-private-types.h" // for type128
-
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/APInt.h"
-
-#include <stddef.h> // for size_t
-#include <stdint.h> // for uint32_t, uint64_t, int64_t
-
-namespace lldb_private {
-class DataExtractor;
-}
-namespace lldb_private {
-class Stream;
-}
-
-#define NUM_OF_WORDS_INT128 2
-#define BITWIDTH_INT128 128
-#define NUM_OF_WORDS_INT256 4
-#define BITWIDTH_INT256 256
-
-namespace lldb_private {
-
-//----------------------------------------------------------------------
-// A class designed to hold onto values and their corresponding types.
-// Operators are defined and Scalar objects will correctly promote their types
-// and values before performing these operations. Type promotion currently
-// follows the ANSI C type promotion rules.
-//----------------------------------------------------------------------
-class Scalar {
-public:
-  enum Type {
-    e_void = 0,
-    e_sint,
-    e_uint,
-    e_slong,
-    e_ulong,
-    e_slonglong,
-    e_ulonglong,
-    e_sint128,
-    e_uint128,
-    e_sint256,
-    e_uint256,
-    e_float,
-    e_double,
-    e_long_double
-  };
-
-  //------------------------------------------------------------------
-  // Constructors and Destructors
-  //------------------------------------------------------------------
-  Scalar();
-  Scalar(int v) : m_type(e_sint), m_float((float)0) {
-    m_integer = llvm::APInt(sizeof(int) * 8, v, true);
-  }
-  Scalar(unsigned int v) : m_type(e_uint), m_float((float)0) {
-    m_integer = llvm::APInt(sizeof(int) * 8, v);
-  }
-  Scalar(long v) : m_type(e_slong), m_float((float)0) {
-    m_integer = llvm::APInt(sizeof(long) * 8, v, true);
-  }
-  Scalar(unsigned long v) : m_type(e_ulong), m_float((float)0) {
-    m_integer = llvm::APInt(sizeof(long) * 8, v);
-  }
-  Scalar(long long v) : m_type(e_slonglong), m_float((float)0) {
-    m_integer = llvm::APInt(sizeof(long long) * 8, v, true);
-  }
-  Scalar(unsigned long long v) : m_type(e_ulonglong), m_float((float)0) {
-    m_integer = llvm::APInt(sizeof(long long) * 8, v);
-  }
-  Scalar(float v) : m_type(e_float), m_float(v) { m_float = llvm::APFloat(v); }
-  Scalar(double v) : m_type(e_double), m_float(v) {
-    m_float = llvm::APFloat(v);
-  }
-  Scalar(long double v, bool ieee_quad)
-      : m_type(e_long_double), m_float((float)0), m_ieee_quad(ieee_quad) {
-    if (ieee_quad)
-      m_float = llvm::APFloat(llvm::APFloat::IEEEquad(),
-                              llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
-                                          ((type128 *)&v)->x));
-    else
-      m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
-                              llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
-                                          ((type128 *)&v)->x));
-  }
-  Scalar(llvm::APInt v) : m_type(), m_float((float)0) {
-    m_integer = llvm::APInt(v);
-    switch (m_integer.getBitWidth()) {
-    case 8:
-    case 16:
-    case 32:
-      if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
-        m_type = e_sint;
-      else
-        m_type = e_uint;
-      break;
-    case 64:
-      if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
-        m_type = e_slonglong;
-      else
-        m_type = e_ulonglong;
-      break;
-    case 128:
-      if (m_integer.isSignedIntN(BITWIDTH_INT128))
-        m_type = e_sint128;
-      else
-        m_type = e_uint128;
-      break;
-    case 256:
-      if (m_integer.isSignedIntN(BITWIDTH_INT256))
-        m_type = e_sint256;
-      else
-        m_type = e_uint256;
-      break;
-    }
-  }
-  Scalar(const Scalar &rhs);
-  // Scalar(const RegisterValue& reg_value);
-  virtual ~Scalar();
-
-  bool SignExtend(uint32_t bit_pos);
-
-  bool ExtractBitfield(uint32_t bit_size, uint32_t bit_offset);
-
-  bool SetBit(uint32_t bit);
-
-  bool ClearBit(uint32_t bit);
-
-  const void *GetBytes() const;
-
-  size_t GetByteSize() const;
-
-  bool GetData(DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const;
-
-  size_t GetAsMemoryData(void *dst, size_t dst_len,
-                         lldb::ByteOrder dst_byte_order, Status &error) const;
-
-  bool IsZero() const;
-
-  void Clear() {
-    m_type = e_void;
-    m_integer.clearAllBits();
-  }
-
-  const char *GetTypeAsCString() const;
-
-  void GetValue(Stream *s, bool show_type) const;
-
-  bool IsValid() const {
-    return (m_type >= e_sint) && (m_type <= e_long_double);
-  }
-
-  bool Promote(Scalar::Type type);
-
-  bool MakeSigned();
-
-  bool MakeUnsigned();
-
-  static const char *GetValueTypeAsCString(Scalar::Type value_type);
-
-  static Scalar::Type
-  GetValueTypeForSignedIntegerWithByteSize(size_t byte_size);
-
-  static Scalar::Type
-  GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size);
-
-  static Scalar::Type GetValueTypeForFloatWithByteSize(size_t byte_size);
-
-  //----------------------------------------------------------------------
-  // All operators can benefits from the implicit conversions that will happen
-  // automagically by the compiler, so no temporary objects will need to be
-  // created. As a result, we currently don't need a variety of overloaded set
-  // value accessors.
-  //----------------------------------------------------------------------
-  Scalar &operator=(const int i);
-  Scalar &operator=(unsigned int v);
-  Scalar &operator=(long v);
-  Scalar &operator=(unsigned long v);
-  Scalar &operator=(long long v);
-  Scalar &operator=(unsigned long long v);
-  Scalar &operator=(float v);
-  Scalar &operator=(double v);
-  Scalar &operator=(long double v);
-  Scalar &operator=(llvm::APInt v);
-  Scalar &operator=(const Scalar &rhs); // Assignment operator
-  Scalar &operator+=(const Scalar &rhs);
-  Scalar &operator<<=(const Scalar &rhs); // Shift left
-  Scalar &operator>>=(const Scalar &rhs); // Shift right (arithmetic)
-  Scalar &operator&=(const Scalar &rhs);
-
-  //----------------------------------------------------------------------
-  // Shifts the current value to the right without maintaining the current sign
-  // of the value (if it is signed).
-  //----------------------------------------------------------------------
-  bool ShiftRightLogical(const Scalar &rhs); // Returns true on success
-
-  //----------------------------------------------------------------------
-  // Takes the absolute value of the current value if it is signed, else the
-  // value remains unchanged. Returns false if the contained value has a void
-  // type.
-  //----------------------------------------------------------------------
-  bool AbsoluteValue(); // Returns true on success
-  //----------------------------------------------------------------------
-  // Negates the current value (even for unsigned values). Returns false if the
-  // contained value has a void type.
-  //----------------------------------------------------------------------
-  bool UnaryNegate(); // Returns true on success
-  //----------------------------------------------------------------------
-  // Inverts all bits in the current value as long as it isn't void or a
-  // float/double/long double type. Returns false if the contained value has a
-  // void/float/double/long double type, else the value is inverted and true is
-  // returned.
-  //----------------------------------------------------------------------
-  bool OnesComplement(); // Returns true on success
-
-  //----------------------------------------------------------------------
-  // Access the type of the current value.
-  //----------------------------------------------------------------------
-  Scalar::Type GetType() const { return m_type; }
-
-  //----------------------------------------------------------------------
-  // Returns a casted value of the current contained data without modifying the
-  // current value. FAIL_VALUE will be returned if the type of the value is
-  // void or invalid.
-  //----------------------------------------------------------------------
-  int SInt(int fail_value = 0) const;
-
-  unsigned char UChar(unsigned char fail_value = 0) const;
-
-  signed char SChar(char fail_value = 0) const;
-
-  unsigned short UShort(unsigned short fail_value = 0) const;
-
-  short SShort(short fail_value = 0) const;
-
-  unsigned int UInt(unsigned int fail_value = 0) const;
-
-  long SLong(long fail_value = 0) const;
-
-  unsigned long ULong(unsigned long fail_value = 0) const;
-
-  long long SLongLong(long long fail_value = 0) const;
-
-  unsigned long long ULongLong(unsigned long long fail_value = 0) const;
-
-  llvm::APInt SInt128(llvm::APInt &fail_value) const;
-
-  llvm::APInt UInt128(const llvm::APInt &fail_value) const;
-
-  llvm::APInt SInt256(llvm::APInt &fail_value) const;
-
-  llvm::APInt UInt256(const llvm::APInt &fail_value) const;
-
-  float Float(float fail_value = 0.0f) const;
-
-  double Double(double fail_value = 0.0) const;
-
-  long double LongDouble(long double fail_value = 0.0) const;
-
-  Status SetValueFromCString(const char *s, lldb::Encoding encoding,
-                             size_t byte_size);
-
-  Status SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
-                          size_t byte_size);
-
-  static bool UIntValueIsValidForSize(uint64_t uval64, size_t total_byte_size) {
-    if (total_byte_size > 8)
-      return false;
-
-    if (total_byte_size == 8)
-      return true;
-
-    const uint64_t max = ((uint64_t)1 << (uint64_t)(total_byte_size * 8)) - 1;
-    return uval64 <= max;
-  }
-
-  static bool SIntValueIsValidForSize(int64_t sval64, size_t total_byte_size) {
-    if (total_byte_size > 8)
-      return false;
-
-    if (total_byte_size == 8)
-      return true;
-
-    const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
-    const int64_t min = ~(max);
-    return min <= sval64 && sval64 <= max;
-  }
-
-protected:
-  typedef char schar_t;
-  typedef unsigned char uchar_t;
-  typedef short sshort_t;
-  typedef unsigned short ushort_t;
-  typedef int sint_t;
-  typedef unsigned int uint_t;
-  typedef long slong_t;
-  typedef unsigned long ulong_t;
-  typedef long long slonglong_t;
-  typedef unsigned long long ulonglong_t;
-  typedef float float_t;
-  typedef double double_t;
-  typedef long double long_double_t;
-
-  //------------------------------------------------------------------
-  // Classes that inherit from Scalar can see and modify these
-  //------------------------------------------------------------------
-  Scalar::Type m_type;
-  llvm::APInt m_integer;
-  llvm::APFloat m_float;
-  bool m_ieee_quad = false;
-
-private:
-  friend const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator-(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator/(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator*(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator&(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator|(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator%(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator^(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator<<(const Scalar &lhs, const Scalar &rhs);
-  friend const Scalar operator>>(const Scalar &lhs, const Scalar &rhs);
-  friend bool operator==(const Scalar &lhs, const Scalar &rhs);
-  friend bool operator!=(const Scalar &lhs, const Scalar &rhs);
-  friend bool operator<(const Scalar &lhs, const Scalar &rhs);
-  friend bool operator<=(const Scalar &lhs, const Scalar &rhs);
-  friend bool operator>(const Scalar &lhs, const Scalar &rhs);
-  friend bool operator>=(const Scalar &lhs, const Scalar &rhs);
-};
-
-//----------------------------------------------------------------------
-// Split out the operators into a format where the compiler will be able to
-// implicitly convert numbers into Scalar objects.
-//
-// This allows code like:
-//      Scalar two(2);
-//      Scalar four = two * 2;
-//      Scalar eight = 2 * four;    // This would cause an error if the
-//                                  // operator* was implemented as a
-//                                  // member function.
-// SEE:
-//  Item 19 of "Effective C++ Second Edition" by Scott Meyers
-//  Differentiate among members functions, non-member functions, and
-//  friend functions
-//----------------------------------------------------------------------
-const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator-(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator/(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator*(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator&(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator|(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator%(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator^(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator<<(const Scalar &lhs, const Scalar &rhs);
-const Scalar operator>>(const Scalar &lhs, const Scalar &rhs);
-bool operator==(const Scalar &lhs, const Scalar &rhs);
-bool operator!=(const Scalar &lhs, const Scalar &rhs);
-bool operator<(const Scalar &lhs, const Scalar &rhs);
-bool operator<=(const Scalar &lhs, const Scalar &rhs);
-bool operator>(const Scalar &lhs, const Scalar &rhs);
-bool operator>=(const Scalar &lhs, const Scalar &rhs);
-
-} // namespace lldb_private
-
-#endif // liblldb_Scalar_h_

lldb/trunk/include/lldb/Core/State.h

-//===-- State.h -------------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_State_h_
-#define liblldb_State_h_
-
-#include "llvm/Support/FormatProviders.h"
-
-#include "lldb/lldb-enumerations.h"   // for StateType
-#include "llvm/ADT/StringRef.h"       // for StringRef
-#include "llvm/Support/raw_ostream.h" // for raw_ostream
-
-#include <stdint.h> // for uint32_t
-
-namespace lldb_private {
-
-//------------------------------------------------------------------
-/// Converts a StateType to a C string.
-///
-/// @param[in] state
-///     The StateType object to convert.
-///
-/// @return
-///     A NULL terminated C string that describes \a state. The
-///     returned string comes from constant string buffers and does
-///     not need to be freed.
-//------------------------------------------------------------------
-const char *StateAsCString(lldb::StateType state);
-
-//------------------------------------------------------------------
-/// Check if a state represents a state where the process or thread
-/// is running.
-///
-/// @param[in] state
-///     The StateType enumeration value
-///
-/// @return
-///     \b true if the state represents a process or thread state
-///     where the process or thread is running, \b false otherwise.
-//------------------------------------------------------------------
-bool StateIsRunningState(lldb::StateType state);
-
-//------------------------------------------------------------------
-/// Check if a state represents a state where the process or thread
-/// is stopped. Stopped can mean stopped when the process is still
-/// around, or stopped when the process has exited or doesn't exist
-/// yet. The \a must_exist argument tells us which of these cases is
-/// desired.
-///
-/// @param[in] state
-///     The StateType enumeration value
-///
-/// @param[in] must_exist
-///     A boolean that indicates the thread must also be alive
-///     so states like unloaded or exited won't return true.
-///
-/// @return
-///     \b true if the state represents a process or thread state
-///     where the process or thread is stopped. If \a must_exist is
-///     \b true, then the process can't be exited or unloaded,
-///     otherwise exited and unloaded or other states where the
-///     process no longer exists are considered to be stopped.
-//------------------------------------------------------------------
-bool StateIsStoppedState(lldb::StateType state, bool must_exist);
-
-const char *GetPermissionsAsCString(uint32_t permissions);
-
-} // namespace lldb_private
-
-namespace llvm {
-template <> struct format_provider<lldb::StateType> {
-  static void format(const lldb::StateType &state, raw_ostream &Stream,
-                     StringRef Style) {
-    Stream << lldb_private::StateAsCString(state);
-  }
-};
-}
-
-#endif // liblldb_State_h_

lldb/trunk/include/lldb/Core/Value.h

 //===-- Value.h -------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Value_h_
 #define liblldb_Value_h_
 
-#include "lldb/Core/Scalar.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"         // for ByteOrder, ByteOrder::eB...
 #include "lldb/lldb-private-enumerations.h" // for AddressType
 #include "lldb/lldb-private-types.h"        // for type128, RegisterInfo
 
 #include "llvm/ADT/APInt.h" // for APInt
 
 #include <vector>

lldb/trunk/include/lldb/Core/ValueObjectRegister.h

 //===-- ValueObjectRegister.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ValueObjectRegister_h_
 #define liblldb_ValueObjectRegister_h_
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/CompilerType.h" // for CompilerType
 #include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/lldb-defines.h"        // for DISALLOW_COPY_AND_ASSIGN
-#include "lldb/lldb-enumerations.h"   // for ValueType, ValueType::eValueTy...
-#include "lldb/lldb-forward.h"        // for RegisterContextSP, ValueObjectSP
-#include "lldb/lldb-private-types.h"  // for RegisterInfo, RegisterSet (ptr...
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/lldb-defines.h"       // for DISALLOW_COPY_AND_ASSIGN
+#include "lldb/lldb-enumerations.h"  // for ValueType, ValueType::eValueTy...
+#include "lldb/lldb-forward.h"       // for RegisterContextSP, ValueObjectSP
+#include "lldb/lldb-private-types.h" // for RegisterInfo, RegisterSet (ptr...
 
 #include <stddef.h> // for size_t
 #include <stdint.h> // for uint32_t, uint64_t, int32_t
 
 namespace lldb_private {
 class DataExtractor;
 }
 namespace lldb_private {

lldb/trunk/include/lldb/Expression/DWARFExpression.h

 //===-- DWARFExpression.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_DWARFExpression_h_
 #define liblldb_DWARFExpression_h_
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include <functional>
 
 class DWARFUnit;
 
 namespace lldb_private {
 

lldb/trunk/include/lldb/Target/StackFrame.h

 // C++ Includes
 #include <memory>
 #include <mutex>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Utility/Flags.h"
 
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/StackID.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UserID.h"
 
 namespace lldb_private {
 
 /// @class StackFrame StackFrame.h "lldb/Target/StackFrame.h"
 ///

lldb/trunk/include/lldb/Target/ThreadPlanTracer.h

 
 #ifndef liblldb_ThreadPlanTracer_h_
 #define liblldb_ThreadPlanTracer_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class ThreadPlanTracer {
   friend class ThreadPlan;
 
 public:

lldb/trunk/include/lldb/Utility/RegisterValue.h

+//===-- RegisterValue.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_REGISTERVALUE_H
+#define LLDB_UTILITY_REGISTERVALUE_H
+
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"    // for Status
+#include "lldb/lldb-enumerations.h" // for ByteOrder, Format
+#include "lldb/lldb-types.h"        // for offset_t
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/StringRef.h" // for StringRef
+#include <cstdint>              // for uint32_t, uint8_t, uint64_t, uin...
+#include <cstring>
+
+namespace lldb_private {
+class DataExtractor;
+class Stream;
+struct RegisterInfo;
+
+class RegisterValue {
+public:
+  enum { kMaxRegisterByteSize = 64u };
+
+  enum Type {
+    eTypeInvalid,
+    eTypeUInt8,
+    eTypeUInt16,
+    eTypeUInt32,
+    eTypeUInt64,
+    eTypeUInt128,
+    eTypeFloat,
+    eTypeDouble,
+    eTypeLongDouble,
+    eTypeBytes
+  };
+
+  RegisterValue() : m_type(eTypeInvalid), m_scalar((unsigned long)0) {}
+
+  explicit RegisterValue(uint8_t inst) : m_type(eTypeUInt8) { m_scalar = inst; }
+
+  explicit RegisterValue(uint16_t inst) : m_type(eTypeUInt16) {
+    m_scalar = inst;
+  }
+
+  explicit RegisterValue(uint32_t inst) : m_type(eTypeUInt32) {
+    m_scalar = inst;
+  }
+
+  explicit RegisterValue(uint64_t inst) : m_type(eTypeUInt64) {
+    m_scalar = inst;
+  }
+
+  explicit RegisterValue(llvm::APInt inst) : m_type(eTypeUInt128) {
+    m_scalar = llvm::APInt(inst);
+  }
+
+  explicit RegisterValue(float value) : m_type(eTypeFloat) { m_scalar = value; }
+
+  explicit RegisterValue(double value) : m_type(eTypeDouble) {
+    m_scalar = value;
+  }
+
+  explicit RegisterValue(long double value) : m_type(eTypeLongDouble) {
+    m_scalar = value;
+  }
+
+  explicit RegisterValue(uint8_t *bytes, size_t length,
+                         lldb::ByteOrder byte_order) {
+    SetBytes(bytes, length, byte_order);
+  }
+
+  RegisterValue::Type GetType() const { return m_type; }
+
+  bool CopyValue(const RegisterValue &rhs);
+
+  void SetType(RegisterValue::Type type) { m_type = type; }
+
+  RegisterValue::Type SetType(const RegisterInfo *reg_info);
+
+  bool GetData(DataExtractor &data) const;
+
+  // Copy the register value from this object into a buffer in "dst" and obey
+  // the "dst_byte_order" when copying the data. Also watch out in case
+  // "dst_len" is longer or shorter than the register value described by
+  // "reg_info" and only copy the least significant bytes of the register
+  // value, or pad the destination with zeroes if the register byte size is
+  // shorter that "dst_len" (all while correctly abiding the "dst_byte_order").
+  // Returns the number of bytes copied into "dst".
+  uint32_t GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
+                           uint32_t dst_len, lldb::ByteOrder dst_byte_order,
+                           Status &error) const;
+
+  uint32_t SetFromMemoryData(const RegisterInfo *reg_info, const void *src,
+                             uint32_t src_len, lldb::ByteOrder src_byte_order,
+                             Status &error);
+
+  bool GetScalarValue(Scalar &scalar) const;
+
+  uint8_t GetAsUInt8(uint8_t fail_value = UINT8_MAX,
+                     bool *success_ptr = nullptr) const {
+    if (m_type == eTypeUInt8) {
+      if (success_ptr)
+        *success_ptr = true;
+      return m_scalar.UChar(fail_value);
+    }
+    if (success_ptr)
+      *success_ptr = true;
+    return fail_value;
+  }
+
+  uint16_t GetAsUInt16(uint16_t fail_value = UINT16_MAX,
+                       bool *success_ptr = nullptr) const;
+
+  uint32_t GetAsUInt32(uint32_t fail_value = UINT32_MAX,
+                       bool *success_ptr = nullptr) const;
+
+  uint64_t GetAsUInt64(uint64_t fail_value = UINT64_MAX,
+                       bool *success_ptr = nullptr) const;
+
+  llvm::APInt GetAsUInt128(const llvm::APInt &fail_value,
+                           bool *success_ptr = nullptr) const;
+
+  float GetAsFloat(float fail_value = 0.0f, bool *success_ptr = nullptr) const;
+
+  double GetAsDouble(double fail_value = 0.0,
+                     bool *success_ptr = nullptr) const;
+
+  long double GetAsLongDouble(long double fail_value = 0.0,
+                              bool *success_ptr = nullptr) const;
+
+  void SetValueToInvalid() { m_type = eTypeInvalid; }
+
+  bool ClearBit(uint32_t bit);
+
+  bool SetBit(uint32_t bit);
+
+  bool operator==(const RegisterValue &rhs) const;
+
+  bool operator!=(const RegisterValue &rhs) const;
+
+  void operator=(uint8_t uint) {
+    m_type = eTypeUInt8;
+    m_scalar = uint;
+  }
+
+  void operator=(uint16_t uint) {
+    m_type = eTypeUInt16;
+    m_scalar = uint;
+  }
+
+  void operator=(uint32_t uint) {
+    m_type = eTypeUInt32;
+    m_scalar = uint;
+  }
+
+  void operator=(uint64_t uint) {
+    m_type = eTypeUInt64;
+    m_scalar = uint;
+  }
+
+  void operator=(llvm::APInt uint) {
+    m_type = eTypeUInt128;
+    m_scalar = llvm::APInt(uint);
+  }
+
+  void operator=(float f) {
+    m_type = eTypeFloat;
+    m_scalar = f;
+  }
+
+  void operator=(double f) {
+    m_type = eTypeDouble;
+    m_scalar = f;
+  }
+
+  void operator=(long double f) {
+    m_type = eTypeLongDouble;
+    m_scalar = f;
+  }
+
+  void SetUInt8(uint8_t uint) {
+    m_type = eTypeUInt8;
+    m_scalar = uint;
+  }
+
+  void SetUInt16(uint16_t uint) {
+    m_type = eTypeUInt16;
+    m_scalar = uint;
+  }
+
+  void SetUInt32(uint32_t uint, Type t = eTypeUInt32) {
+    m_type = t;
+    m_scalar = uint;
+  }
+
+  void SetUInt64(uint64_t uint, Type t = eTypeUInt64) {
+    m_type = t;
+    m_scalar = uint;
+  }
+
+  void SetUInt128(llvm::APInt uint) {
+    m_type = eTypeUInt128;
+    m_scalar = uint;
+  }
+
+  bool SetUInt(uint64_t uint, uint32_t byte_size);
+
+  void SetFloat(float f) {
+    m_type = eTypeFloat;
+    m_scalar = f;
+  }
+
+  void SetDouble(double f) {
+    m_type = eTypeDouble;
+    m_scalar = f;
+  }
+
+  void SetLongDouble(long double f) {
+    m_type = eTypeLongDouble;
+    m_scalar = f;
+  }
+
+  void SetBytes(const void *bytes, size_t length, lldb::ByteOrder byte_order);
+
+  bool SignExtend(uint32_t sign_bitpos);
+
+  Status SetValueFromString(const RegisterInfo *reg_info,
+                            llvm::StringRef value_str);
+  Status SetValueFromString(const RegisterInfo *reg_info,
+                            const char *value_str) = delete;
+
+  Status SetValueFromData(const RegisterInfo *reg_info, DataExtractor &data,
+                          lldb::offset_t offset, bool partial_data_ok);
+
+  const void *GetBytes() const;
+
+  lldb::ByteOrder GetByteOrder() const {
+    if (m_type == eTypeBytes)
+      return buffer.byte_order;
+    return endian::InlHostByteOrder();
+  }
+
+  uint32_t GetByteSize() const;
+
+  static uint32_t GetMaxByteSize() { return kMaxRegisterByteSize; }
+
+  void Clear();
+
+protected:
+  RegisterValue::Type m_type;
+  Scalar m_scalar;
+
+  struct {
+    uint8_t bytes[kMaxRegisterByteSize]; // This must be big enough to hold any
+                                         // register for any supported target.
+    uint8_t length;
+    lldb::ByteOrder byte_order;
+  } buffer;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_REGISTERVALUE_H

lldb/trunk/include/lldb/Utility/Scalar.h

+//===-- Scalar.h ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_SCALAR_H
+#define LLDB_UTILITY_SCALAR_H
+
+#include "lldb/Utility/Status.h"     // for Status
+#include "lldb/lldb-enumerations.h"  // for Encoding, ByteOrder
+#include "lldb/lldb-private-types.h" // for type128
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APInt.h"
+#include <cstddef> // for size_t
+#include <cstdint> // for uint32_t, uint64_t, int64_t
+
+namespace lldb_private {
+class DataExtractor;
+class Stream;
+} // namespace lldb_private
+
+#define NUM_OF_WORDS_INT128 2
+#define BITWIDTH_INT128 128
+#define NUM_OF_WORDS_INT256 4
+#define BITWIDTH_INT256 256
+
+namespace lldb_private {
+
+//----------------------------------------------------------------------
+// A class designed to hold onto values and their corresponding types.
+// Operators are defined and Scalar objects will correctly promote their types
+// and values before performing these operations. Type promotion currently
+// follows the ANSI C type promotion rules.
+//----------------------------------------------------------------------
+class Scalar {
+public:
+  enum Type {
+    e_void = 0,
+    e_sint,
+    e_uint,
+    e_slong,
+    e_ulong,
+    e_slonglong,
+    e_ulonglong,
+    e_sint128,
+    e_uint128,
+    e_sint256,
+    e_uint256,
+    e_float,
+    e_double,
+    e_long_double
+  };
+
+  //------------------------------------------------------------------
+  // Constructors and Destructors
+  //------------------------------------------------------------------
+  Scalar();
+  Scalar(int v) : m_type(e_sint), m_float((float)0) {
+    m_integer = llvm::APInt(sizeof(int) * 8, v, true);
+  }
+  Scalar(unsigned int v) : m_type(e_uint), m_float((float)0) {
+    m_integer = llvm::APInt(sizeof(int) * 8, v);
+  }
+  Scalar(long v) : m_type(e_slong), m_float((float)0) {
+    m_integer = llvm::APInt(sizeof(long) * 8, v, true);
+  }
+  Scalar(unsigned long v) : m_type(e_ulong), m_float((float)0) {
+    m_integer = llvm::APInt(sizeof(long) * 8, v);
+  }
+  Scalar(long long v) : m_type(e_slonglong), m_float((float)0) {
+    m_integer = llvm::APInt(sizeof(long long) * 8, v, true);
+  }
+  Scalar(unsigned long long v) : m_type(e_ulonglong), m_float((float)0) {
+    m_integer = llvm::APInt(sizeof(long long) * 8, v);
+  }
+  Scalar(float v) : m_type(e_float), m_float(v) { m_float = llvm::APFloat(v); }
+  Scalar(double v) : m_type(e_double), m_float(v) {
+    m_float = llvm::APFloat(v);
+  }
+  Scalar(long double v, bool ieee_quad)
+      : m_type(e_long_double), m_float((float)0), m_ieee_quad(ieee_quad) {
+    if (ieee_quad)
+      m_float = llvm::APFloat(llvm::APFloat::IEEEquad(),
+                              llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+                                          ((type128 *)&v)->x));
+    else
+      m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
+                              llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+                                          ((type128 *)&v)->x));
+  }
+  Scalar(llvm::APInt v) : m_type(), m_float((float)0) {
+    m_integer = llvm::APInt(v);
+    switch (m_integer.getBitWidth()) {
+    case 8:
+    case 16:
+    case 32:
+      if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
+        m_type = e_sint;
+      else
+        m_type = e_uint;
+      break;
+    case 64:
+      if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
+        m_type = e_slonglong;
+      else
+        m_type = e_ulonglong;
+      break;
+    case 128:
+      if (m_integer.isSignedIntN(BITWIDTH_INT128))
+        m_type = e_sint128;
+      else
+        m_type = e_uint128;
+      break;
+    case 256:
+      if (m_integer.isSignedIntN(BITWIDTH_INT256))
+        m_type = e_sint256;
+      else
+        m_type = e_uint256;
+      break;
+    }
+  }
+  Scalar(const Scalar &rhs);
+  // Scalar(const RegisterValue& reg_value);
+  virtual ~Scalar();
+
+  bool SignExtend(uint32_t bit_pos);
+
+  bool ExtractBitfield(uint32_t bit_size, uint32_t bit_offset);
+
+  bool SetBit(uint32_t bit);
+
+  bool ClearBit(uint32_t bit);
+
+  const void *GetBytes() const;
+
+  size_t GetByteSize() const;
+
+  bool GetData(DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const;
+
+  size_t GetAsMemoryData(void *dst, size_t dst_len,
+                         lldb::ByteOrder dst_byte_order, Status &error) const;
+
+  bool IsZero() const;
+
+  void Clear() {
+    m_type = e_void;
+    m_integer.clearAllBits();
+  }
+
+  const char *GetTypeAsCString() const;
+
+  void GetValue(Stream *s, bool show_type) const;
+
+  bool IsValid() const {
+    return (m_type >= e_sint) && (m_type <= e_long_double);
+  }
+
+  bool Promote(Scalar::Type type);
+
+  bool MakeSigned();
+
+  bool MakeUnsigned();
+
+  static const char *GetValueTypeAsCString(Scalar::Type value_type);
+
+  static Scalar::Type
+  GetValueTypeForSignedIntegerWithByteSize(size_t byte_size);
+
+  static Scalar::Type
+  GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size);
+
+  static Scalar::Type GetValueTypeForFloatWithByteSize(size_t byte_size);
+
+  //----------------------------------------------------------------------
+  // All operators can benefits from the implicit conversions that will happen
+  // automagically by the compiler, so no temporary objects will need to be
+  // created. As a result, we currently don't need a variety of overloaded set
+  // value accessors.
+  //----------------------------------------------------------------------
+  Scalar &operator=(const int i);
+  Scalar &operator=(unsigned int v);
+  Scalar &operator=(long v);
+  Scalar &operator=(unsigned long v);
+  Scalar &operator=(long long v);
+  Scalar &operator=(unsigned long long v);
+  Scalar &operator=(float v);
+  Scalar &operator=(double v);
+  Scalar &operator=(long double v);
+  Scalar &operator=(llvm::APInt v);
+  Scalar &operator=(const Scalar &rhs); // Assignment operator
+  Scalar &operator+=(const Scalar &rhs);
+  Scalar &operator<<=(const Scalar &rhs); // Shift left
+  Scalar &operator>>=(const Scalar &rhs); // Shift right (arithmetic)
+  Scalar &operator&=(const Scalar &rhs);
+
+  //----------------------------------------------------------------------
+  // Shifts the current value to the right without maintaining the current sign
+  // of the value (if it is signed).
+  //----------------------------------------------------------------------
+  bool ShiftRightLogical(const Scalar &rhs); // Returns true on success
+
+  //----------------------------------------------------------------------
+  // Takes the absolute value of the current value if it is signed, else the
+  // value remains unchanged. Returns false if the contained value has a void
+  // type.
+  //----------------------------------------------------------------------
+  bool AbsoluteValue(); // Returns true on success
+  //----------------------------------------------------------------------
+  // Negates the current value (even for unsigned values). Returns false if the
+  // contained value has a void type.
+  //----------------------------------------------------------------------
+  bool UnaryNegate(); // Returns true on success
+  //----------------------------------------------------------------------
+  // Inverts all bits in the current value as long as it isn't void or a
+  // float/double/long double type. Returns false if the contained value has a
+  // void/float/double/long double type, else the value is inverted and true is
+  // returned.
+  //----------------------------------------------------------------------
+  bool OnesComplement(); // Returns true on success
+
+  //----------------------------------------------------------------------
+  // Access the type of the current value.
+  //----------------------------------------------------------------------
+  Scalar::Type GetType() const { return m_type; }
+
+  //----------------------------------------------------------------------
+  // Returns a casted value of the current contained data without modifying the
+  // current value. FAIL_VALUE will be returned if the type of the value is
+  // void or invalid.
+  //----------------------------------------------------------------------
+  int SInt(int fail_value = 0) const;
+
+  unsigned char UChar(unsigned char fail_value = 0) const;
+
+  signed char SChar(char fail_value = 0) const;
+
+  unsigned short UShort(unsigned short fail_value = 0) const;
+
+  short SShort(short fail_value = 0) const;
+
+  unsigned int UInt(unsigned int fail_value = 0) const;
+
+  long SLong(long fail_value = 0) const;
+
+  unsigned long ULong(unsigned long fail_value = 0) const;
+
+  long long SLongLong(long long fail_value = 0) const;
+
+  unsigned long long ULongLong(unsigned long long fail_value = 0) const;
+
+  llvm::APInt SInt128(llvm::APInt &fail_value) const;
+
+  llvm::APInt UInt128(const llvm::APInt &fail_value) const;
+
+  llvm::APInt SInt256(llvm::APInt &fail_value) const;
+
+  llvm::APInt UInt256(const llvm::APInt &fail_value) const;
+
+  float Float(float fail_value = 0.0f) const;
+
+  double Double(double fail_value = 0.0) const;
+
+  long double LongDouble(long double fail_value = 0.0) const;
+
+  Status SetValueFromCString(const char *s, lldb::Encoding encoding,
+                             size_t byte_size);
+
+  Status SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
+                          size_t byte_size);
+
+  static bool UIntValueIsValidForSize(uint64_t uval64, size_t total_byte_size) {
+    if (total_byte_size > 8)
+      return false;
+
+    if (total_byte_size == 8)
+      return true;
+
+    const uint64_t max = ((uint64_t)1 << (uint64_t)(total_byte_size * 8)) - 1;
+    return uval64 <= max;
+  }
+
+  static bool SIntValueIsValidForSize(int64_t sval64, size_t total_byte_size) {
+    if (total_byte_size > 8)
+      return false;
+
+    if (total_byte_size == 8)
+      return true;
+
+    const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
+    const int64_t min = ~(max);
+    return min <= sval64 && sval64 <= max;
+  }
+
+protected:
+  typedef char schar_t;
+  typedef unsigned char uchar_t;
+  typedef short sshort_t;
+  typedef unsigned short ushort_t;
+  typedef int sint_t;
+  typedef unsigned int uint_t;
+  typedef long slong_t;
+  typedef unsigned long ulong_t;
+  typedef long long slonglong_t;
+  typedef unsigned long long ulonglong_t;
+  typedef float float_t;
+  typedef double double_t;
+  typedef long double long_double_t;
+
+  //------------------------------------------------------------------
+  // Classes that inherit from Scalar can see and modify these
+  //------------------------------------------------------------------
+  Scalar::Type m_type;
+  llvm::APInt m_integer;
+  llvm::APFloat m_float;
+  bool m_ieee_quad = false;
+
+private:
+  friend const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator-(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator/(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator*(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator&(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator|(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator%(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator^(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator<<(const Scalar &lhs, const Scalar &rhs);
+  friend const Scalar operator>>(const Scalar &lhs, const Scalar &rhs);
+  friend bool operator==(const Scalar &lhs, const Scalar &rhs);
+  friend bool operator!=(const Scalar &lhs, const Scalar &rhs);
+  friend bool operator<(const Scalar &lhs, const Scalar &rhs);
+  friend bool operator<=(const Scalar &lhs, const Scalar &rhs);
+  friend bool operator>(const Scalar &lhs, const Scalar &rhs);
+  friend bool operator>=(const Scalar &lhs, const Scalar &rhs);
+};
+
+//----------------------------------------------------------------------
+// Split out the operators into a format where the compiler will be able to
+// implicitly convert numbers into Scalar objects.
+//
+// This allows code like:
+//      Scalar two(2);
+//      Scalar four = two * 2;
+//      Scalar eight = 2 * four;    // This would cause an error if the
+//                                  // operator* was implemented as a
+//                                  // member function.
+// SEE:
+//  Item 19 of "Effective C++ Second Edition" by Scott Meyers
+//  Differentiate among members functions, non-member functions, and
+//  friend functions
+//----------------------------------------------------------------------
+const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator-(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator/(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator*(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator&(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator|(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator%(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator^(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator<<(const Scalar &lhs, const Scalar &rhs);
+const Scalar operator>>(const Scalar &lhs, const Scalar &rhs);
+bool operator==(const Scalar &lhs, const Scalar &rhs);
+bool operator!=(const Scalar &lhs, const Scalar &rhs);
+bool operator<(const Scalar &lhs, const Scalar &rhs);
+bool operator<=(const Scalar &lhs, const Scalar &rhs);
+bool operator>(const Scalar &lhs, const Scalar &rhs);
+bool operator>=(const Scalar &lhs, const Scalar &rhs);
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_SCALAR_H

lldb/trunk/include/lldb/Utility/State.h

+//===-- State.h -------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_STATE_H
+#define LLDB_UTILITY_STATE_H
+
+#include "lldb/lldb-enumerations.h" // for StateType
+#include "llvm/ADT/StringRef.h"     // for StringRef
+#include "llvm/Support/FormatProviders.h"
+#include "llvm/Support/raw_ostream.h" // for raw_ostream
+#include <cstdint>                    // for uint32_t
+
+namespace lldb_private {
+
+//------------------------------------------------------------------
+/// Converts a StateType to a C string.
+///
+/// @param[in] state
+///     The StateType object to convert.
+///
+/// @return
+///     A NULL terminated C string that describes \a state. The
+///     returned string comes from constant string buffers and does
+///     not need to be freed.
+//------------------------------------------------------------------
+const char *StateAsCString(lldb::StateType state);
+
+//------------------------------------------------------------------
+/// Check if a state represents a state where the process or thread
+/// is running.
+///
+/// @param[in] state
+///     The StateType enumeration value
+///
+/// @return
+///     \b true if the state represents a process or thread state
+///     where the process or thread is running, \b false otherwise.
+//------------------------------------------------------------------
+bool StateIsRunningState(lldb::StateType state);
+
+//------------------------------------------------------------------
+/// Check if a state represents a state where the process or thread
+/// is stopped. Stopped can mean stopped when the process is still
+/// around, or stopped when the process has exited or doesn't exist
+/// yet. The \a must_exist argument tells us which of these cases is
+/// desired.
+///
+/// @param[in] state
+///     The StateType enumeration value
+///
+/// @param[in] must_exist
+///     A boolean that indicates the thread must also be alive
+///     so states like unloaded or exited won't return true.
+///
+/// @return
+///     \b true if the state represents a process or thread state
+///     where the process or thread is stopped. If \a must_exist is
+///     \b true, then the process can't be exited or unloaded,
+///     otherwise exited and unloaded or other states where the
+///     process no longer exists are considered to be stopped.
+//------------------------------------------------------------------
+bool StateIsStoppedState(lldb::StateType state, bool must_exist);
+
+const char *GetPermissionsAsCString(uint32_t permissions);
+
+} // namespace lldb_private
+
+namespace llvm {
+template <> struct format_provider<lldb::StateType> {
+  static void format(const lldb::StateType &state, raw_ostream &Stream,
+                     StringRef Style) {
+    Stream << lldb_private::StateAsCString(state);
+  }
+};
+} // namespace llvm
+
+#endif // LLDB_UTILITY_STATE_H

lldb/trunk/source/API/SBDebugger.cpp

 #include "lldb/API/SBTypeFilter.h"
 #include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeNameSpecifier.h"
 #include "lldb/API/SBTypeSummary.h"
 #include "lldb/API/SBTypeSynthetic.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Initialization/SystemLifetimeManager.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/Args.h"
+#include "lldb/Utility/State.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/API/SBProcess.cpp

 #include <inttypes.h>
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 
 // Project includes
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"

lldb/trunk/source/API/SBThread.cpp

 //===-- SBThread.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepRange.h"
 #include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StructuredData.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"

lldb/trunk/source/API/SBThreadPlan.cpp

 //===-- SBThreadPlan.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanPython.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepRange.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StructuredData.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"

lldb/trunk/source/API/SBValue.cpp

 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeFilter.h"
 #include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeSummary.h"
 #include "lldb/API/SBTypeSynthetic.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Stream.h"
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp

 // Project includes
 #include "CommandObjectBreakpointCommand.h"
 #include "CommandObjectBreakpoint.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/IOHandler.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/State.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointCommandAdd

lldb/trunk/source/Commands/CommandObjectProcess.cpp

 // Other libraries and framework includes
 // Project includes
 #include "CommandObjectProcess.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Args.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class CommandObjectProcessLaunchOrAttach : public CommandObjectParsed {
 public:
   CommandObjectProcessLaunchOrAttach(CommandInterpreter &interpreter,
                                      const char *name, const char *help,

lldb/trunk/source/Commands/CommandObjectRegister.cpp

 //===-- CommandObjectRegister.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectRegister.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/DumpRegisterValue.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionValueArray.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueUInt64.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Errno.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // "register read"
 //----------------------------------------------------------------------

lldb/trunk/source/Commands/CommandObjectTarget.cpp

 #include "CommandObjectTarget.h"
 
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"

 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Args.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatAdapters.h"
 
 // C Includes
 // C++ Includes
 #include <cerrno>

lldb/trunk/source/Commands/CommandObjectThread.cpp

 //===-- CommandObjectThread.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectThread.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/SourceManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepRange.h"
+#include "lldb/Utility/State.h"
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectIterateOverThreads
 //-------------------------------------------------------------------------

lldb/trunk/source/Commands/CommandObjectType.cpp

 // C++ Includes
 #include <algorithm>
 #include <cctype>
 #include <functional>
 
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
-#include "lldb/Core/State.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueLanguage.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/RegularExpression.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StringList.h"
 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/trunk/source/Commands/CommandObjectWatchpointCommand.cpp

 
 // Other libraries and framework includes
 // Project includes
 #include "CommandObjectWatchpoint.h"
 #include "CommandObjectWatchpointCommand.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/IOHandler.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectWatchpointCommandAdd
 //-------------------------------------------------------------------------
 

lldb/trunk/source/Core/CMakeLists.txt

add_lldb_library(lldbCore
   IOHandler.cpp
   Listener.cpp
   Mangled.cpp
   Module.cpp
   ModuleChild.cpp
   ModuleList.cpp
   Opcode.cpp
   PluginManager.cpp
-  RegisterValue.cpp
-  Scalar.cpp
   SearchFilter.cpp
   Section.cpp
   SourceManager.cpp
-  State.cpp
   StreamAsynchronousIO.cpp
   StreamFile.cpp
   UserSettingsController.cpp
   Value.cpp
   ValueObject.cpp
   ValueObjectCast.cpp
   ValueObjectChild.cpp
   ValueObjectConstResult.cpp

lldb/trunk/source/Core/Debugger.cpp

 //===-- Debugger.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Debugger.h"
 
 #include "lldb/Breakpoint/Breakpoint.h" // for Breakpoint, Brea...
 #include "lldb/Core/Event.h"            // for Event, EventData...
 #include "lldb/Core/FormatEntity.h"
-#include "lldb/Core/Listener.h" // for Listener
-#include "lldb/Core/Mangled.h"  // for Mangled
-#include "lldb/Core/ModuleList.h"  // for Mangled
+#include "lldb/Core/Listener.h"   // for Listener
+#include "lldb/Core/Mangled.h"    // for Mangled
+#include "lldb/Core/ModuleList.h" // for Mangled
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamAsynchronousIO.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Expression/REPL.h"
 #include "lldb/Host/File.h" // for File, File::kInv...
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Host/ThreadLauncher.h"

 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h" // for ThreadList
 #include "lldb/Utility/AnsiTerminal.h"
-#include "lldb/Utility/Log.h"    // for LLDB_LOG_OPTION_...
+#include "lldb/Utility/Log.h" // for LLDB_LOG_OPTION_...
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h" // for Stream
 #include "lldb/Utility/StreamCallback.h"
 #include "lldb/Utility/StreamString.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h" // for PATH_MAX
 #endif
 

lldb/trunk/source/Core/DumpRegisterValue.cpp

 //===-- DumpRegisterValue.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/DumpDataExtractor.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-private-types.h"
 
 using namespace lldb;
 
 bool lldb_private::DumpRegisterValue(const RegisterValue &reg_val, Stream *s,
                                      const RegisterInfo *reg_info,
                                      bool prefix_with_name,

lldb/trunk/source/Core/EmulateInstruction.cpp

 //===-- EmulateInstruction.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/EmulateInstruction.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"   // for StackFrame
 #include "lldb/Utility/ConstString.h" // for ConstString
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h" // for Stream, Stream::::eBinary
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-forward.h"            // for ProcessSP
 #include "lldb/lldb-private-interfaces.h" // for EmulateInstructionCreateIn...
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 

lldb/trunk/source/Core/FormatEntity.cpp

 //===-- FormatEntity.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/FormatEntity.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h" // for AddressRange
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h" // for RegisterValue
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormatClasses.h" // for TypeNameSpecifier...
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/TypeSummary.h" // for TypeSummaryImpl::...
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Interpreter/CommandInterpreter.h"

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/ArchSpec.h"    // for ArchSpec
 #include "lldb/Utility/ConstString.h" // for ConstString, oper...
 #include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"        // for Log
-#include "lldb/Utility/Logging.h"    // for GetLogIfAllCatego...
-#include "lldb/Utility/SharingPtr.h" // for SharingPtr
+#include "lldb/Utility/Log.h"           // for Log
+#include "lldb/Utility/Logging.h"       // for GetLogIfAllCatego...
+#include "lldb/Utility/RegisterValue.h" // for RegisterValue
+#include "lldb/Utility/SharingPtr.h"    // for SharingPtr
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"     // for StringList
 #include "lldb/Utility/StructuredData.h" // for StructuredData::O...
 #include "lldb/lldb-defines.h"           // for LLDB_INVALID_ADDRESS
 #include "lldb/lldb-forward.h"           // for ValueObjectSP
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"

lldb/trunk/source/Core/IOHandler.cpp

 #ifndef LLDB_DISABLE_LIBEDIT
 #include "lldb/Host/Editline.h"
 #endif
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #ifndef LLDB_DISABLE_CURSES
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/State.h"
 #endif
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 
 #ifdef _MSC_VER
 #include "lldb/Host/windows/windows.h"
 #endif
 

lldb/trunk/source/Core/RegisterValue.cpp

-//===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/RegisterValue.h"
-
-#include "lldb/Core/Scalar.h"
-#include "lldb/Utility/Args.h"
-#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h"
-#include "lldb/Utility/StreamString.h"
-#include "lldb/lldb-defines.h"       // for LLDB_INVALID_ADDRESS
-#include "lldb/lldb-private-types.h" // for RegisterInfo, type128
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
-
-#include <cstdint> // for uint8_t, uint32_t, uint64_t
-#include <string>  // for string
-#include <tuple>   // for tie, tuple
-#include <vector>
-
-#include <assert.h>   // for assert
-#include <inttypes.h> // for PRIx64
-#include <stdio.h>    // for sscanf
-
-using namespace lldb;
-using namespace lldb_private;
-
-bool RegisterValue::GetData(DataExtractor &data) const {
-  return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
-}
-
-uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
-                                        uint32_t dst_len,
-                                        lldb::ByteOrder dst_byte_order,
-                                        Status &error) const {
-  if (reg_info == nullptr) {
-    error.SetErrorString("invalid register info argument.");
-    return 0;
-  }
-
-  // ReadRegister should have already been called on this object prior to
-  // calling this.
-  if (GetType() == eTypeInvalid) {
-    // No value has been read into this object...
-    error.SetErrorStringWithFormat(
-        "invalid register value type for register %s", reg_info->name);
-    return 0;
-  }
-
-  if (dst_len > kMaxRegisterByteSize) {
-    error.SetErrorString("destination is too big");
-    return 0;
-  }
-
-  const uint32_t src_len = reg_info->byte_size;
-
-  // Extract the register data into a data extractor
-  DataExtractor reg_data;
-  if (!GetData(reg_data)) {
-    error.SetErrorString("invalid register value to copy into");
-    return 0;
-  }
-
-  // Prepare a memory buffer that contains some or all of the register value
-  const uint32_t bytes_copied =
-      reg_data.CopyByteOrderedData(0,               // src offset
-                                   src_len,         // src length
-                                   dst,             // dst buffer
-                                   dst_len,         // dst length
-                                   dst_byte_order); // dst byte order
-  if (bytes_copied == 0)
-    error.SetErrorStringWithFormat(
-        "failed to copy data for register write of %s", reg_info->name);
-
-  return bytes_copied;
-}
-
-uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo *reg_info,
-                                          const void *src, uint32_t src_len,
-                                          lldb::ByteOrder src_byte_order,
-                                          Status &error) {
-  if (reg_info == nullptr) {
-    error.SetErrorString("invalid register info argument.");
-    return 0;
-  }
-
-  // Moving from addr into a register
-  //
-  // Case 1: src_len == dst_len
-  //
-  //   |AABBCCDD| Address contents
-  //   |AABBCCDD| Register contents
-  //
-  // Case 2: src_len > dst_len
-  //
-  //   Status!  (The register should always be big enough to hold the data)
-  //
-  // Case 3: src_len < dst_len
-  //
-  //   |AABB| Address contents
-  //   |AABB0000| Register contents [on little-endian hardware]
-  //   |0000AABB| Register contents [on big-endian hardware]
-  if (src_len > kMaxRegisterByteSize) {
-    error.SetErrorStringWithFormat(
-        "register buffer is too small to receive %u bytes of data.", src_len);
-    return 0;
-  }
-
-  const uint32_t dst_len = reg_info->byte_size;
-
-  if (src_len > dst_len) {
-    error.SetErrorStringWithFormat(
-        "%u bytes is too big to store in register %s (%u bytes)", src_len,
-        reg_info->name, dst_len);
-    return 0;
-  }
-
-  // Use a data extractor to correctly copy and pad the bytes read into the
-  // register value
-  DataExtractor src_data(src, src_len, src_byte_order, 4);
-
-  error = SetValueFromData(reg_info, src_data, 0, true);
-  if (error.Fail())
-    return 0;
-
-  // If SetValueFromData succeeded, we must have copied all of src_len
-  return src_len;
-}
-
-bool RegisterValue::GetScalarValue(Scalar &scalar) const {
-  switch (m_type) {
-  case eTypeInvalid:
-    break;
-  case eTypeBytes: {
-    switch (buffer.length) {
-    default:
-      break;
-    case 1:
-      scalar = *(const uint8_t *)buffer.bytes;
-      return true;
-    case 2:
-      scalar = *(const uint16_t *)buffer.bytes;
-      return true;
-    case 4:
-      scalar = *(const uint32_t *)buffer.bytes;
-      return true;
-    case 8:
-      scalar = *(const uint64_t *)buffer.bytes;
-      return true;
-    case 16:
-    case 32:
-      if (buffer.length % sizeof(uint64_t) == 0) {
-        const auto length_in_bits = buffer.length * 8;
-        const auto length_in_uint64 = buffer.length / sizeof(uint64_t);
-        scalar =
-            llvm::APInt(length_in_bits,
-                        llvm::ArrayRef<uint64_t>((const uint64_t *)buffer.bytes,
-                                                 length_in_uint64));
-        return true;
-      }
-      break;
-    }
-  } break;
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    scalar = m_scalar;
-    return true;
-  }
-  return false;
-}
-
-void RegisterValue::Clear() { m_type = eTypeInvalid; }
-
-RegisterValue::Type RegisterValue::SetType(const RegisterInfo *reg_info) {
-  // To change the type, we simply copy the data in again, using the new format
-  RegisterValue copy;
-  DataExtractor copy_data;
-  if (copy.CopyValue(*this) && copy.GetData(copy_data))
-    SetValueFromData(reg_info, copy_data, 0, true);
-
-  return m_type;
-}
-
-Status RegisterValue::SetValueFromData(const RegisterInfo *reg_info,
-                                       DataExtractor &src,
-                                       lldb::offset_t src_offset,
-                                       bool partial_data_ok) {
-  Status error;
-
-  if (src.GetByteSize() == 0) {
-    error.SetErrorString("empty data.");
-    return error;
-  }
-
-  if (reg_info->byte_size == 0) {
-    error.SetErrorString("invalid register info.");
-    return error;
-  }
-
-  uint32_t src_len = src.GetByteSize() - src_offset;
-
-  if (!partial_data_ok && (src_len < reg_info->byte_size)) {
-    error.SetErrorString("not enough data.");
-    return error;
-  }
-
-  // Cap the data length if there is more than enough bytes for this register
-  // value
-  if (src_len > reg_info->byte_size)
-    src_len = reg_info->byte_size;
-
-  // Zero out the value in case we get partial data...
-  memset(buffer.bytes, 0, sizeof(buffer.bytes));
-
-  type128 int128;
-
-  m_type = eTypeInvalid;
-  switch (reg_info->encoding) {
-  case eEncodingInvalid:
-    break;
-  case eEncodingUint:
-  case eEncodingSint:
-    if (reg_info->byte_size == 1)
-      SetUInt8(src.GetMaxU32(&src_offset, src_len));
-    else if (reg_info->byte_size <= 2)
-      SetUInt16(src.GetMaxU32(&src_offset, src_len));
-    else if (reg_info->byte_size <= 4)
-      SetUInt32(src.GetMaxU32(&src_offset, src_len));
-    else if (reg_info->byte_size <= 8)
-      SetUInt64(src.GetMaxU64(&src_offset, src_len));
-    else if (reg_info->byte_size <= 16) {
-      uint64_t data1 = src.GetU64(&src_offset);
-      uint64_t data2 = src.GetU64(&src_offset);
-      if (src.GetByteSize() == eByteOrderBig) {
-        int128.x[0] = data1;
-        int128.x[1] = data2;
-      } else {
-        int128.x[0] = data2;
-        int128.x[1] = data1;
-      }
-      SetUInt128(llvm::APInt(128, 2, int128.x));
-    }
-    break;
-  case eEncodingIEEE754:
-    if (reg_info->byte_size == sizeof(float))
-      SetFloat(src.GetFloat(&src_offset));
-    else if (reg_info->byte_size == sizeof(double))
-      SetDouble(src.GetDouble(&src_offset));
-    else if (reg_info->byte_size == sizeof(long double))
-      SetLongDouble(src.GetLongDouble(&src_offset));
-    break;
-  case eEncodingVector: {
-    m_type = eTypeBytes;
-    buffer.length = reg_info->byte_size;
-    buffer.byte_order = src.GetByteOrder();
-    assert(buffer.length <= kMaxRegisterByteSize);
-    if (buffer.length > kMaxRegisterByteSize)
-      buffer.length = kMaxRegisterByteSize;
-    if (src.CopyByteOrderedData(
-            src_offset,    // offset within "src" to start extracting data
-            src_len,       // src length
-            buffer.bytes,  // dst buffer
-            buffer.length, // dst length
-            buffer.byte_order) == 0) // dst byte order
-    {
-      error.SetErrorStringWithFormat(
-          "failed to copy data for register write of %s", reg_info->name);
-      return error;
-    }
-  }
-  }
-
-  if (m_type == eTypeInvalid)
-    error.SetErrorStringWithFormat(
-        "invalid register value type for register %s", reg_info->name);
-  return error;
-}
-
-// Helper function for RegisterValue::SetValueFromString()
-static bool ParseVectorEncoding(const RegisterInfo *reg_info,
-                                llvm::StringRef vector_str,
-                                const uint32_t byte_size,
-                                RegisterValue *reg_value) {
-  // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a
-  // 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
-  vector_str = vector_str.trim();
-  vector_str.consume_front("{");
-  vector_str.consume_back("}");
-  vector_str = vector_str.trim();
-
-  char Sep = ' ';
-
-  // The first split should give us:
-  // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f
-  // 0x2a 0x3e').
-  llvm::StringRef car;
-  llvm::StringRef cdr = vector_str;
-  std::tie(car, cdr) = vector_str.split(Sep);
-  std::vector<uint8_t> bytes;
-  unsigned byte = 0;
-
-  // Using radix auto-sensing by passing 0 as the radix. Keep on processing the
-  // vector elements as long as the parsing succeeds and the vector size is <
-  // byte_size.
-  while (!car.getAsInteger(0, byte) && bytes.size() < byte_size) {
-    bytes.push_back(byte);
-    std::tie(car, cdr) = cdr.split(Sep);
-  }
-
-  // Check for vector of exact byte_size elements.
-  if (bytes.size() != byte_size)
-    return false;
-
-  reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
-  return true;
-}
-
-Status RegisterValue::SetValueFromString(const RegisterInfo *reg_info,
-                                         llvm::StringRef value_str) {
-  Status error;
-  if (reg_info == nullptr) {
-    error.SetErrorString("Invalid register info argument.");
-    return error;
-  }
-
-  m_type = eTypeInvalid;
-  if (value_str.empty()) {
-    error.SetErrorString("Invalid c-string value string.");
-    return error;
-  }
-  const uint32_t byte_size = reg_info->byte_size;
-
-  uint64_t uval64;
-  int64_t ival64;
-  float flt_val;
-  double dbl_val;
-  long double ldbl_val;
-  switch (reg_info->encoding) {
-  case eEncodingInvalid:
-    error.SetErrorString("Invalid encoding.");
-    break;
-
-  case eEncodingUint:
-    if (byte_size > sizeof(uint64_t)) {
-      error.SetErrorStringWithFormat(
-          "unsupported unsigned integer byte size: %u", byte_size);
-      break;
-    }
-    if (value_str.getAsInteger(0, uval64)) {
-      error.SetErrorStringWithFormat(
-          "'%s' is not a valid unsigned integer string value",
-          value_str.str().c_str());
-      break;
-    }
-
-    if (!Args::UInt64ValueIsValidForByteSize(uval64, byte_size)) {
-      error.SetErrorStringWithFormat(
-          "value 0x%" PRIx64
-          " is too large to fit in a %u byte unsigned integer value",
-          uval64, byte_size);
-      break;
-    }
-
-    if (!SetUInt(uval64, reg_info->byte_size)) {
-      error.SetErrorStringWithFormat(
-          "unsupported unsigned integer byte size: %u", byte_size);
-      break;
-    }
-    // TODO: Shouldn't we be setting m_type here?
-    break;
-
-  case eEncodingSint:
-    if (byte_size > sizeof(long long)) {
-      error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
-                                     byte_size);
-      break;
-    }
-
-    if (value_str.getAsInteger(0, ival64)) {
-      error.SetErrorStringWithFormat(
-          "'%s' is not a valid signed integer string value",
-          value_str.str().c_str());
-      break;
-    }
-
-    if (!Args::SInt64ValueIsValidForByteSize(ival64, byte_size)) {
-      error.SetErrorStringWithFormat(
-          "value 0x%" PRIx64
-          " is too large to fit in a %u byte signed integer value",
-          ival64, byte_size);
-      break;
-    }
-
-    if (!SetUInt(ival64, reg_info->byte_size)) {
-      error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
-                                     byte_size);
-      break;
-    }
-
-    // TODO: Shouldn't we be setting m_type here?
-    break;
-
-  case eEncodingIEEE754: {
-    std::string value_string = value_str;
-    if (byte_size == sizeof(float)) {
-      if (::sscanf(value_string.c_str(), "%f", &flt_val) != 1) {
-        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
-                                       value_string.c_str());
-        break;
-      }
-      m_scalar = flt_val;
-      m_type = eTypeFloat;
-    } else if (byte_size == sizeof(double)) {
-      if (::sscanf(value_string.c_str(), "%lf", &dbl_val) != 1) {
-        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
-                                       value_string.c_str());
-        break;
-      }
-      m_scalar = dbl_val;
-      m_type = eTypeDouble;
-    } else if (byte_size == sizeof(long double)) {
-      if (::sscanf(value_string.c_str(), "%Lf", &ldbl_val) != 1) {
-        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
-                                       value_string.c_str());
-        break;
-      }
-      m_scalar = ldbl_val;
-      m_type = eTypeLongDouble;
-    } else {
-      error.SetErrorStringWithFormat("unsupported float byte size: %u",
-                                     byte_size);
-      return error;
-    }
-    break;
-  }
-  case eEncodingVector:
-    if (!ParseVectorEncoding(reg_info, value_str, byte_size, this))
-      error.SetErrorString("unrecognized vector encoding string value.");
-    break;
-  }
-
-  return error;
-}
-
-bool RegisterValue::SignExtend(uint32_t sign_bitpos) {
-  switch (m_type) {
-  case eTypeInvalid:
-    break;
-
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-    return m_scalar.SignExtend(sign_bitpos);
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-  case eTypeBytes:
-    break;
-  }
-  return false;
-}
-
-bool RegisterValue::CopyValue(const RegisterValue &rhs) {
-  if (this == &rhs)
-    return rhs.m_type == eTypeInvalid ? false : true;
-
-  m_type = rhs.m_type;
-  switch (m_type) {
-  case eTypeInvalid:
-    return false;
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    m_scalar = rhs.m_scalar;
-    break;
-  case eTypeBytes:
-    assert(rhs.buffer.length <= kMaxRegisterByteSize);
-    ::memcpy(buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize);
-    buffer.length = rhs.buffer.length;
-    buffer.byte_order = rhs.buffer.byte_order;
-    break;
-  }
-  return true;
-}
-
-uint16_t RegisterValue::GetAsUInt16(uint16_t fail_value,
-                                    bool *success_ptr) const {
-  if (success_ptr)
-    *success_ptr = true;
-
-  switch (m_type) {
-  default:
-    break;
-  case eTypeUInt8:
-  case eTypeUInt16:
-    return m_scalar.UShort(fail_value);
-  case eTypeBytes: {
-    switch (buffer.length) {
-    default:
-      break;
-    case 1:
-    case 2:
-      return *(const uint16_t *)buffer.bytes;
-    }
-  } break;
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-uint32_t RegisterValue::GetAsUInt32(uint32_t fail_value,
-                                    bool *success_ptr) const {
-  if (success_ptr)
-    *success_ptr = true;
-  switch (m_type) {
-  default:
-    break;
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.UInt(fail_value);
-  case eTypeBytes: {
-    switch (buffer.length) {
-    default:
-      break;
-    case 1:
-    case 2:
-    case 4:
-      return *(const uint32_t *)buffer.bytes;
-    }
-  } break;
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-uint64_t RegisterValue::GetAsUInt64(uint64_t fail_value,
-                                    bool *success_ptr) const {
-  if (success_ptr)
-    *success_ptr = true;
-  switch (m_type) {
-  default:
-    break;
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.ULongLong(fail_value);
-  case eTypeBytes: {
-    switch (buffer.length) {
-    default:
-      break;
-    case 1:
-      return *(const uint8_t *)buffer.bytes;
-    case 2:
-      return *(const uint16_t *)buffer.bytes;
-    case 4:
-      return *(const uint32_t *)buffer.bytes;
-    case 8:
-      return *(const uint64_t *)buffer.bytes;
-    }
-  } break;
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-llvm::APInt RegisterValue::GetAsUInt128(const llvm::APInt &fail_value,
-                                        bool *success_ptr) const {
-  if (success_ptr)
-    *success_ptr = true;
-  switch (m_type) {
-  default:
-    break;
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.UInt128(fail_value);
-  case eTypeBytes: {
-    switch (buffer.length) {
-    default:
-      break;
-    case 1:
-    case 2:
-    case 4:
-    case 8:
-    case 16:
-      return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
-                         ((const type128 *)buffer.bytes)->x);
-    }
-  } break;
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-float RegisterValue::GetAsFloat(float fail_value, bool *success_ptr) const {
-  if (success_ptr)
-    *success_ptr = true;
-  switch (m_type) {
-  default:
-    break;
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.Float(fail_value);
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-double RegisterValue::GetAsDouble(double fail_value, bool *success_ptr) const {
-  if (success_ptr)
-    *success_ptr = true;
-  switch (m_type) {
-  default:
-    break;
-
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.Double(fail_value);
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-long double RegisterValue::GetAsLongDouble(long double fail_value,
-                                           bool *success_ptr) const {
-  if (success_ptr)
-    *success_ptr = true;
-  switch (m_type) {
-  default:
-    break;
-
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.LongDouble();
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-const void *RegisterValue::GetBytes() const {
-  switch (m_type) {
-  case eTypeInvalid:
-    break;
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.GetBytes();
-  case eTypeBytes:
-    return buffer.bytes;
-  }
-  return nullptr;
-}
-
-uint32_t RegisterValue::GetByteSize() const {
-  switch (m_type) {
-  case eTypeInvalid:
-    break;
-  case eTypeUInt8:
-    return 1;
-  case eTypeUInt16:
-    return 2;
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar.GetByteSize();
-  case eTypeBytes:
-    return buffer.length;
-  }
-  return 0;
-}
-
-bool RegisterValue::SetUInt(uint64_t uint, uint32_t byte_size) {
-  if (byte_size == 0) {
-    SetUInt64(uint);
-  } else if (byte_size == 1) {
-    SetUInt8(uint);
-  } else if (byte_size <= 2) {
-    SetUInt16(uint);
-  } else if (byte_size <= 4) {
-    SetUInt32(uint);
-  } else if (byte_size <= 8) {
-    SetUInt64(uint);
-  } else if (byte_size <= 16) {
-    SetUInt128(llvm::APInt(128, uint));
-  } else
-    return false;
-  return true;
-}
-
-void RegisterValue::SetBytes(const void *bytes, size_t length,
-                             lldb::ByteOrder byte_order) {
-  // If this assertion fires off we need to increase the size of buffer.bytes,
-  // or make it something that is allocated on the heap. Since the data buffer
-  // is in a union, we can't make it a collection class like SmallVector...
-  if (bytes && length > 0) {
-    assert(length <= sizeof(buffer.bytes) &&
-           "Storing too many bytes in a RegisterValue.");
-    m_type = eTypeBytes;
-    buffer.length = length;
-    memcpy(buffer.bytes, bytes, length);
-    buffer.byte_order = byte_order;
-  } else {
-    m_type = eTypeInvalid;
-    buffer.length = 0;
-  }
-}
-
-bool RegisterValue::operator==(const RegisterValue &rhs) const {
-  if (m_type == rhs.m_type) {
-    switch (m_type) {
-    case eTypeInvalid:
-      return true;
-    case eTypeUInt8:
-    case eTypeUInt16:
-    case eTypeUInt32:
-    case eTypeUInt64:
-    case eTypeUInt128:
-    case eTypeFloat:
-    case eTypeDouble:
-    case eTypeLongDouble:
-      return m_scalar == rhs.m_scalar;
-    case eTypeBytes:
-      if (buffer.length != rhs.buffer.length)
-        return false;
-      else {
-        uint8_t length = buffer.length;
-        if (length > kMaxRegisterByteSize)
-          length = kMaxRegisterByteSize;
-        return memcmp(buffer.bytes, rhs.buffer.bytes, length) == 0;
-      }
-      break;
-    }
-  }
-  return false;
-}
-
-bool RegisterValue::operator!=(const RegisterValue &rhs) const {
-  if (m_type != rhs.m_type)
-    return true;
-  switch (m_type) {
-  case eTypeInvalid:
-    return false;
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    return m_scalar != rhs.m_scalar;
-  case eTypeBytes:
-    if (buffer.length != rhs.buffer.length) {
-      return true;
-    } else {
-      uint8_t length = buffer.length;
-      if (length > kMaxRegisterByteSize)
-        length = kMaxRegisterByteSize;
-      return memcmp(buffer.bytes, rhs.buffer.bytes, length) != 0;
-    }
-    break;
-  }
-  return true;
-}
-
-bool RegisterValue::ClearBit(uint32_t bit) {
-  switch (m_type) {
-  case eTypeInvalid:
-    break;
-
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-    if (bit < (GetByteSize() * 8)) {
-      return m_scalar.ClearBit(bit);
-    }
-    break;
-
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    break;
-
-  case eTypeBytes:
-    if (buffer.byte_order == eByteOrderBig ||
-        buffer.byte_order == eByteOrderLittle) {
-      uint32_t byte_idx;
-      if (buffer.byte_order == eByteOrderBig)
-        byte_idx = buffer.length - (bit / 8) - 1;
-      else
-        byte_idx = bit / 8;
-
-      const uint32_t byte_bit = bit % 8;
-      if (byte_idx < buffer.length) {
-        buffer.bytes[byte_idx] &= ~(1u << byte_bit);
-        return true;
-      }
-    }
-    break;
-  }
-  return false;
-}
-
-bool RegisterValue::SetBit(uint32_t bit) {
-  switch (m_type) {
-  case eTypeInvalid:
-    break;
-
-  case eTypeUInt8:
-  case eTypeUInt16:
-  case eTypeUInt32:
-  case eTypeUInt64:
-  case eTypeUInt128:
-    if (bit < (GetByteSize() * 8)) {
-      return m_scalar.SetBit(bit);
-    }
-    break;
-
-  case eTypeFloat:
-  case eTypeDouble:
-  case eTypeLongDouble:
-    break;
-
-  case eTypeBytes:
-    if (buffer.byte_order == eByteOrderBig ||
-        buffer.byte_order == eByteOrderLittle) {
-      uint32_t byte_idx;
-      if (buffer.byte_order == eByteOrderBig)
-        byte_idx = buffer.length - (bit / 8) - 1;
-      else
-        byte_idx = bit / 8;
-
-      const uint32_t byte_bit = bit % 8;
-      if (byte_idx < buffer.length) {
-        buffer.bytes[byte_idx] |= (1u << byte_bit);
-        return true;
-      }
-    }
-    break;
-  }
-  return false;
-}

lldb/trunk/source/Core/Scalar.cpp

-//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/Scalar.h"
-
-#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Endian.h"
-#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h"
-#include "lldb/lldb-types.h" // for offset_t
-
-#include "llvm/ADT/SmallString.h"
-
-#include <cinttypes>
-#include <cstdio>
-
-using namespace lldb;
-using namespace lldb_private;
-
-//----------------------------------------------------------------------
-// Promote to max type currently follows the ANSI C rule for type promotion in
-// expressions.
-//----------------------------------------------------------------------
-static Scalar::Type PromoteToMaxType(
-    const Scalar &lhs,  // The const left hand side object
-    const Scalar &rhs,  // The const right hand side object
-    Scalar &temp_value, // A modifiable temp value than can be used to hold
-                        // either the promoted lhs or rhs object
-    const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
-                                     // promoted value of lhs (at most one of
-                                     // lhs/rhs will get promoted)
-    const Scalar *&promoted_rhs_ptr  // Pointer to the resulting possibly
-                                     // promoted value of rhs (at most one of
-                                     // lhs/rhs will get promoted)
-    ) {
-  Scalar result;
-  // Initialize the promoted values for both the right and left hand side
-  // values to be the objects themselves. If no promotion is needed (both right
-  // and left have the same type), then the temp_value will not get used.
-  promoted_lhs_ptr = &lhs;
-  promoted_rhs_ptr = &rhs;
-  // Extract the types of both the right and left hand side values
-  Scalar::Type lhs_type = lhs.GetType();
-  Scalar::Type rhs_type = rhs.GetType();
-
-  if (lhs_type > rhs_type) {
-    // Right hand side need to be promoted
-    temp_value = rhs; // Copy right hand side into the temp value
-    if (temp_value.Promote(lhs_type)) // Promote it
-      promoted_rhs_ptr =
-          &temp_value; // Update the pointer for the promoted right hand side
-  } else if (lhs_type < rhs_type) {
-    // Left hand side need to be promoted
-    temp_value = lhs; // Copy left hand side value into the temp value
-    if (temp_value.Promote(rhs_type)) // Promote it
-      promoted_lhs_ptr =
-          &temp_value; // Update the pointer for the promoted left hand side
-  }
-
-  // Make sure our type promotion worked as expected
-  if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
-    return promoted_lhs_ptr->GetType(); // Return the resulting max type
-
-  // Return the void type (zero) if we fail to promote either of the values.
-  return Scalar::e_void;
-}
-
-Scalar::Scalar() : m_type(e_void), m_float((float)0) {}
-
-Scalar::Scalar(const Scalar &rhs)
-    : m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}
-
-// Scalar::Scalar(const RegisterValue& reg) :
-//  m_type(e_void),
-//  m_data()
-//{
-//  switch (reg.info.encoding)
-//  {
-//  case eEncodingUint:     // unsigned integer
-//      switch (reg.info.byte_size)
-//      {
-//      case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
-//      case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
-//      case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
-//      case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64;
-//      break;
-//      break;
-//      }
-//      break;
-//
-//  case eEncodingSint:     // signed integer
-//      switch (reg.info.byte_size)
-//      {
-//      case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
-//      case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
-//      case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
-//      case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64;
-//      break;
-//      break;
-//      }
-//      break;
-//
-//  case eEncodingIEEE754:  // float
-//      switch (reg.info.byte_size)
-//      {
-//      case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
-//      case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
-//      break;
-//      }
-//      break;
-//    case eEncodingVector: // vector registers
-//      break;
-//  }
-//}
-
-bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
-  size_t byte_size = GetByteSize();
-  if (byte_size > 0) {
-    const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
-
-    if (limit_byte_size < byte_size) {
-      if (endian::InlHostByteOrder() == eByteOrderLittle) {
-        // On little endian systems if we want fewer bytes from the current
-        // type we just specify fewer bytes since the LSByte is first...
-        byte_size = limit_byte_size;
-      } else if (endian::InlHostByteOrder() == eByteOrderBig) {
-        // On big endian systems if we want fewer bytes from the current type
-        // have to advance our initial byte pointer and trim down the number of
-        // bytes since the MSByte is first
-        bytes += byte_size - limit_byte_size;
-        byte_size = limit_byte_size;
-      }
-    }
-
-    data.SetData(bytes, byte_size, endian::InlHostByteOrder());
-    return true;
-  }
-  data.Clear();
-  return false;
-}
-
-const void *Scalar::GetBytes() const {
-  const uint64_t *apint_words;
-  const uint8_t *bytes;
-  static float_t flt_val;
-  static double_t dbl_val;
-  static uint64_t swapped_words[4];
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-    bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
-    // getRawData always returns a pointer to an uint64_t.  If we have a
-    // smaller type, we need to update the pointer on big-endian systems.
-    if (endian::InlHostByteOrder() == eByteOrderBig) {
-      size_t byte_size = m_integer.getBitWidth() / 8;
-      if (byte_size < 8)
-        bytes += 8 - byte_size;
-    }
-    return bytes;
-  case e_sint128:
-  case e_uint128:
-    apint_words = m_integer.getRawData();
-    // getRawData always returns a pointer to an array of two uint64_t values,
-    // where the least-significant word always comes first.  On big-endian
-    // systems we need to swap the two words.
-    if (endian::InlHostByteOrder() == eByteOrderBig) {
-      swapped_words[0] = apint_words[1];
-      swapped_words[1] = apint_words[0];
-      apint_words = swapped_words;
-    }
-    return reinterpret_cast<const void *>(apint_words);
-  case e_sint256:
-  case e_uint256:
-    apint_words = m_integer.getRawData();
-    // getRawData always returns a pointer to an array of four uint64_t values,
-    // where the least-significant word always comes first.  On big-endian
-    // systems we need to swap the four words.
-    if (endian::InlHostByteOrder() == eByteOrderBig) {
-      swapped_words[0] = apint_words[3];
-      swapped_words[1] = apint_words[2];
-      swapped_words[2] = apint_words[1];
-      swapped_words[3] = apint_words[0];
-      apint_words = swapped_words;
-    }
-    return reinterpret_cast<const void *>(apint_words);
-  case e_float:
-    flt_val = m_float.convertToFloat();
-    return reinterpret_cast<const void *>(&flt_val);
-  case e_double:
-    dbl_val = m_float.convertToDouble();
-    return reinterpret_cast<const void *>(&dbl_val);
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    apint_words = ldbl_val.getRawData();
-    // getRawData always returns a pointer to an array of two uint64_t values,
-    // where the least-significant word always comes first.  On big-endian
-    // systems we need to swap the two words.
-    if (endian::InlHostByteOrder() == eByteOrderBig) {
-      swapped_words[0] = apint_words[1];
-      swapped_words[1] = apint_words[0];
-      apint_words = swapped_words;
-    }
-    return reinterpret_cast<const void *>(apint_words);
-  }
-  return nullptr;
-}
-
-size_t Scalar::GetByteSize() const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (m_integer.getBitWidth() / 8);
-  case e_float:
-    return sizeof(float_t);
-  case e_double:
-    return sizeof(double_t);
-  case e_long_double:
-    return sizeof(long_double_t);
-  }
-  return 0;
-}
-
-bool Scalar::IsZero() const {
-  llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return llvm::APInt::isSameValue(zero_int, m_integer);
-  case e_float:
-  case e_double:
-  case e_long_double:
-    return m_float.isZero();
-  }
-  return false;
-}
-
-void Scalar::GetValue(Stream *s, bool show_type) const {
-  if (show_type)
-    s->Printf("(%s) ", GetTypeAsCString());
-
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_slong:
-  case e_slonglong:
-  case e_sint128:
-  case e_sint256:
-    s->PutCString(m_integer.toString(10, true));
-    break;
-  case e_uint:
-  case e_ulong:
-  case e_ulonglong:
-  case e_uint128:
-  case e_uint256:
-    s->PutCString(m_integer.toString(10, false));
-    break;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    llvm::SmallString<24> string;
-    m_float.toString(string);
-    s->Printf("%s", string.c_str());
-    break;
-  }
-}
-
-const char *Scalar::GetTypeAsCString() const {
-  switch (m_type) {
-  case e_void:
-    return "void";
-  case e_sint:
-    return "int";
-  case e_uint:
-    return "unsigned int";
-  case e_slong:
-    return "long";
-  case e_ulong:
-    return "unsigned long";
-  case e_slonglong:
-    return "long long";
-  case e_ulonglong:
-    return "unsigned long long";
-  case e_sint128:
-    return "int128_t";
-  case e_uint128:
-    return "unsigned int128_t";
-  case e_sint256:
-    return "int256_t";
-  case e_uint256:
-    return "unsigned int256_t";
-  case e_float:
-    return "float";
-  case e_double:
-    return "double";
-  case e_long_double:
-    return "long double";
-  }
-  return "<invalid Scalar type>";
-}
-
-Scalar &Scalar::operator=(const Scalar &rhs) {
-  if (this != &rhs) {
-    m_type = rhs.m_type;
-    m_integer = llvm::APInt(rhs.m_integer);
-    m_float = rhs.m_float;
-  }
-  return *this;
-}
-
-Scalar &Scalar::operator=(const int v) {
-  m_type = e_sint;
-  m_integer = llvm::APInt(sizeof(int) * 8, v, true);
-  return *this;
-}
-
-Scalar &Scalar::operator=(unsigned int v) {
-  m_type = e_uint;
-  m_integer = llvm::APInt(sizeof(int) * 8, v);
-  return *this;
-}
-
-Scalar &Scalar::operator=(long v) {
-  m_type = e_slong;
-  m_integer = llvm::APInt(sizeof(long) * 8, v, true);
-  return *this;
-}
-
-Scalar &Scalar::operator=(unsigned long v) {
-  m_type = e_ulong;
-  m_integer = llvm::APInt(sizeof(long) * 8, v);
-  return *this;
-}
-
-Scalar &Scalar::operator=(long long v) {
-  m_type = e_slonglong;
-  m_integer = llvm::APInt(sizeof(long) * 8, v, true);
-  return *this;
-}
-
-Scalar &Scalar::operator=(unsigned long long v) {
-  m_type = e_ulonglong;
-  m_integer = llvm::APInt(sizeof(long long) * 8, v);
-  return *this;
-}
-
-Scalar &Scalar::operator=(float v) {
-  m_type = e_float;
-  m_float = llvm::APFloat(v);
-  return *this;
-}
-
-Scalar &Scalar::operator=(double v) {
-  m_type = e_double;
-  m_float = llvm::APFloat(v);
-  return *this;
-}
-
-Scalar &Scalar::operator=(long double v) {
-  m_type = e_long_double;
-  if (m_ieee_quad)
-    m_float = llvm::APFloat(
-        llvm::APFloat::IEEEquad(),
-        llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
-  else
-    m_float = llvm::APFloat(
-        llvm::APFloat::x87DoubleExtended(),
-        llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
-  return *this;
-}
-
-Scalar &Scalar::operator=(llvm::APInt rhs) {
-  m_integer = llvm::APInt(rhs);
-  switch (m_integer.getBitWidth()) {
-  case 8:
-  case 16:
-  case 32:
-    if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
-      m_type = e_sint;
-    else
-      m_type = e_uint;
-    break;
-  case 64:
-    if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
-      m_type = e_slonglong;
-    else
-      m_type = e_ulonglong;
-    break;
-  case 128:
-    if (m_integer.isSignedIntN(BITWIDTH_INT128))
-      m_type = e_sint128;
-    else
-      m_type = e_uint128;
-    break;
-  case 256:
-    if (m_integer.isSignedIntN(BITWIDTH_INT256))
-      m_type = e_sint256;
-    else
-      m_type = e_uint256;
-    break;
-  }
-  return *this;
-}
-
-Scalar::~Scalar() = default;
-
-bool Scalar::Promote(Scalar::Type type) {
-  bool success = false;
-  switch (m_type) {
-  case e_void:
-    break;
-
-  case e_sint:
-    switch (type) {
-    case e_void:
-      break;
-    case e_sint:
-      success = true;
-      break;
-    case e_uint:
-      m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
-      success = true;
-      break;
-
-    case e_slong:
-      m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulong:
-      m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
-      success = true;
-      break;
-
-    case e_slonglong:
-      m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulonglong:
-      m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_sint128:
-    case e_uint128:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_uint:
-    switch (type) {
-    case e_void:
-    case e_sint:
-      break;
-    case e_uint:
-      success = true;
-      break;
-    case e_slong:
-      m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulong:
-      m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
-      success = true;
-      break;
-
-    case e_slonglong:
-      m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulonglong:
-      m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_sint128:
-    case e_uint128:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_slong:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-      break;
-    case e_slong:
-      success = true;
-      break;
-    case e_ulong:
-      m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
-      success = true;
-      break;
-
-    case e_slonglong:
-      m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulonglong:
-      m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_sint128:
-    case e_uint128:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_ulong:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-      break;
-    case e_ulong:
-      success = true;
-      break;
-    case e_slonglong:
-      m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulonglong:
-      m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_sint128:
-    case e_uint128:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_slonglong:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-      break;
-    case e_slonglong:
-      success = true;
-      break;
-    case e_ulonglong:
-      m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_sint128:
-    case e_uint128:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_ulonglong:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-      break;
-    case e_ulonglong:
-      success = true;
-      break;
-    case e_sint128:
-    case e_uint128:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_sint128:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-      break;
-    case e_sint128:
-      success = true;
-      break;
-    case e_uint128:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_uint128:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-      break;
-    case e_uint128:
-      success = true;
-      break;
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_sint256:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-      break;
-    case e_sint256:
-      success = true;
-      break;
-    case e_uint256:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, true,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_uint256:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-      break;
-    case e_uint256:
-      success = true;
-      break;
-    case e_float:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-
-    case e_long_double:
-      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                          : llvm::APFloat::x87DoubleExtended());
-      m_float.convertFromAPInt(m_integer, false,
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_float:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      break;
-    case e_float:
-      success = true;
-      break;
-    case e_double:
-      m_float = llvm::APFloat((double_t)m_float.convertToFloat());
-      success = true;
-      break;
-
-    case e_long_double: {
-      bool ignore;
-      m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                  : llvm::APFloat::x87DoubleExtended(),
-                      llvm::APFloat::rmNearestTiesToEven, &ignore);
-      success = true;
-      break;
-    }
-    }
-    break;
-
-  case e_double:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-    case e_float:
-      break;
-    case e_double:
-      success = true;
-      break;
-    case e_long_double: {
-      bool ignore;
-      m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
-                                  : llvm::APFloat::x87DoubleExtended(),
-                      llvm::APFloat::rmNearestTiesToEven, &ignore);
-      success = true;
-      break;
-    }
-    }
-    break;
-
-  case e_long_double:
-    switch (type) {
-    case e_void:
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-    case e_float:
-    case e_double:
-      break;
-    case e_long_double:
-      success = true;
-      break;
-    }
-    break;
-  }
-
-  if (success)
-    m_type = type;
-  return success;
-}
-
-const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
-  switch (type) {
-  case e_void:
-    return "void";
-  case e_sint:
-    return "int";
-  case e_uint:
-    return "unsigned int";
-  case e_slong:
-    return "long";
-  case e_ulong:
-    return "unsigned long";
-  case e_slonglong:
-    return "long long";
-  case e_ulonglong:
-    return "unsigned long long";
-  case e_float:
-    return "float";
-  case e_double:
-    return "double";
-  case e_long_double:
-    return "long double";
-  case e_sint128:
-    return "int128_t";
-  case e_uint128:
-    return "uint128_t";
-  case e_sint256:
-    return "int256_t";
-  case e_uint256:
-    return "uint256_t";
-  }
-  return "???";
-}
-
-Scalar::Type
-Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
-  if (byte_size <= sizeof(sint_t))
-    return e_sint;
-  if (byte_size <= sizeof(slong_t))
-    return e_slong;
-  if (byte_size <= sizeof(slonglong_t))
-    return e_slonglong;
-  return e_void;
-}
-
-Scalar::Type
-Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
-  if (byte_size <= sizeof(uint_t))
-    return e_uint;
-  if (byte_size <= sizeof(ulong_t))
-    return e_ulong;
-  if (byte_size <= sizeof(ulonglong_t))
-    return e_ulonglong;
-  return e_void;
-}
-
-Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
-  if (byte_size == sizeof(float_t))
-    return e_float;
-  if (byte_size == sizeof(double_t))
-    return e_double;
-  if (byte_size == sizeof(long_double_t))
-    return e_long_double;
-  return e_void;
-}
-
-bool Scalar::MakeSigned() {
-  bool success = false;
-
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-    success = true;
-    break;
-  case e_uint:
-    m_type = e_sint;
-    success = true;
-    break;
-  case e_slong:
-    success = true;
-    break;
-  case e_ulong:
-    m_type = e_slong;
-    success = true;
-    break;
-  case e_slonglong:
-    success = true;
-    break;
-  case e_ulonglong:
-    m_type = e_slonglong;
-    success = true;
-    break;
-  case e_sint128:
-    success = true;
-    break;
-  case e_uint128:
-    m_type = e_sint128;
-    success = true;
-    break;
-  case e_sint256:
-    success = true;
-    break;
-  case e_uint256:
-    m_type = e_sint256;
-    success = true;
-    break;
-  case e_float:
-    success = true;
-    break;
-  case e_double:
-    success = true;
-    break;
-  case e_long_double:
-    success = true;
-    break;
-  }
-
-  return success;
-}
-
-bool Scalar::MakeUnsigned() {
-  bool success = false;
-
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-    m_type = e_uint;
-    success = true;
-    break;
-  case e_uint:
-    success = true;
-    break;
-  case e_slong:
-    m_type = e_ulong;
-    success = true;
-    break;
-  case e_ulong:
-    success = true;
-    break;
-  case e_slonglong:
-    m_type = e_ulonglong;
-    success = true;
-    break;
-  case e_ulonglong:
-    success = true;
-    break;
-  case e_sint128:
-    m_type = e_uint128;
-    success = true;
-    break;
-  case e_uint128:
-    success = true;
-    break;
-  case e_sint256:
-    m_type = e_uint256;
-    success = true;
-    break;
-  case e_uint256:
-    success = true;
-    break;
-  case e_float:
-    success = true;
-    break;
-  case e_double:
-    success = true;
-    break;
-  case e_long_double:
-    success = true;
-    break;
-  }
-
-  return success;
-}
-
-signed char Scalar::SChar(char fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
-  case e_float:
-    return (schar_t)m_float.convertToFloat();
-  case e_double:
-    return (schar_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
-  }
-  return fail_value;
-}
-
-unsigned char Scalar::UChar(unsigned char fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
-  case e_float:
-    return (uchar_t)m_float.convertToFloat();
-  case e_double:
-    return (uchar_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
-  }
-  return fail_value;
-}
-
-short Scalar::SShort(short fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8))
-        .getSExtValue();
-  case e_float:
-    return (sshort_t)m_float.convertToFloat();
-  case e_double:
-    return (sshort_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8))
-        .getSExtValue();
-  }
-  return fail_value;
-}
-
-unsigned short Scalar::UShort(unsigned short fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8))
-        .getZExtValue();
-  case e_float:
-    return (ushort_t)m_float.convertToFloat();
-  case e_double:
-    return (ushort_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8))
-        .getZExtValue();
-  }
-  return fail_value;
-}
-
-int Scalar::SInt(int fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
-  case e_float:
-    return (sint_t)m_float.convertToFloat();
-  case e_double:
-    return (sint_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
-  }
-  return fail_value;
-}
-
-unsigned int Scalar::UInt(unsigned int fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
-  case e_float:
-    return (uint_t)m_float.convertToFloat();
-  case e_double:
-    return (uint_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
-  }
-  return fail_value;
-}
-
-long Scalar::SLong(long fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
-  case e_float:
-    return (slong_t)m_float.convertToFloat();
-  case e_double:
-    return (slong_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
-  }
-  return fail_value;
-}
-
-unsigned long Scalar::ULong(unsigned long fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
-  case e_float:
-    return (ulong_t)m_float.convertToFloat();
-  case e_double:
-    return (ulong_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
-  }
-  return fail_value;
-}
-
-long long Scalar::SLongLong(long long fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8))
-        .getSExtValue();
-  case e_float:
-    return (slonglong_t)m_float.convertToFloat();
-  case e_double:
-    return (slonglong_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8))
-        .getSExtValue();
-  }
-  return fail_value;
-}
-
-unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
-        .getZExtValue();
-  case e_float:
-    return (ulonglong_t)m_float.convertToFloat();
-  case e_double:
-    return (ulonglong_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8))
-        .getZExtValue();
-  }
-  return fail_value;
-}
-
-llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return m_integer;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    return m_float.bitcastToAPInt();
-  }
-  return fail_value;
-}
-
-llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return m_integer;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    return m_float.bitcastToAPInt();
-  }
-  return fail_value;
-}
-
-llvm::APInt Scalar::SInt256(llvm::APInt &fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return m_integer;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    return m_float.bitcastToAPInt();
-  }
-  return fail_value;
-}
-
-llvm::APInt Scalar::UInt256(const llvm::APInt &fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return m_integer;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    return m_float.bitcastToAPInt();
-  }
-  return fail_value;
-}
-
-float Scalar::Float(float fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return llvm::APIntOps::RoundAPIntToFloat(m_integer);
-  case e_float:
-    return m_float.convertToFloat();
-  case e_double:
-    return (float_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return ldbl_val.bitsToFloat();
-  }
-  return fail_value;
-}
-
-double Scalar::Double(double fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return llvm::APIntOps::RoundAPIntToDouble(m_integer);
-  case e_float:
-    return (double_t)m_float.convertToFloat();
-  case e_double:
-    return m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return ldbl_val.bitsToFloat();
-  }
-  return fail_value;
-}
-
-long double Scalar::LongDouble(long double fail_value) const {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
-  case e_float:
-    return (long_double_t)m_float.convertToFloat();
-  case e_double:
-    return (long_double_t)m_float.convertToDouble();
-  case e_long_double:
-    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (long_double_t)ldbl_val.bitsToDouble();
-  }
-  return fail_value;
-}
-
-Scalar &Scalar::operator+=(const Scalar &rhs) {
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (m_type) {
-    case e_void:
-      break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      m_integer = a->m_integer + b->m_integer;
-      break;
-
-    case e_float:
-    case e_double:
-    case e_long_double:
-      m_float = a->m_float + b->m_float;
-      break;
-    }
-  }
-  return *this;
-}
-
-Scalar &Scalar::operator<<=(const Scalar &rhs) {
-  switch (m_type) {
-  case e_void:
-  case e_float:
-  case e_double:
-  case e_long_double:
-    m_type = e_void;
-    break;
-
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    switch (rhs.m_type) {
-    case e_void:
-    case e_float:
-    case e_double:
-    case e_long_double:
-      m_type = e_void;
-      break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer << rhs.m_integer;
-      break;
-    }
-    break;
-  }
-  return *this;
-}
-
-bool Scalar::ShiftRightLogical(const Scalar &rhs) {
-  switch (m_type) {
-  case e_void:
-  case e_float:
-  case e_double:
-  case e_long_double:
-    m_type = e_void;
-    break;
-
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    switch (rhs.m_type) {
-    case e_void:
-    case e_float:
-    case e_double:
-    case e_long_double:
-      m_type = e_void;
-      break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.lshr(rhs.m_integer);
-      break;
-    }
-    break;
-  }
-  return m_type != e_void;
-}
-
-Scalar &Scalar::operator>>=(const Scalar &rhs) {
-  switch (m_type) {
-  case e_void:
-  case e_float:
-  case e_double:
-  case e_long_double:
-    m_type = e_void;
-    break;
-
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    switch (rhs.m_type) {
-    case e_void:
-    case e_float:
-    case e_double:
-    case e_long_double:
-      m_type = e_void;
-      break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_integer.ashr(rhs.m_integer);
-      break;
-    }
-    break;
-  }
-  return *this;
-}
-
-Scalar &Scalar::operator&=(const Scalar &rhs) {
-  switch (m_type) {
-  case e_void:
-  case e_float:
-  case e_double:
-  case e_long_double:
-    m_type = e_void;
-    break;
-
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    switch (rhs.m_type) {
-    case e_void:
-    case e_float:
-    case e_double:
-    case e_long_double:
-      m_type = e_void;
-      break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      m_integer &= rhs.m_integer;
-      break;
-    }
-    break;
-  }
-  return *this;
-}
-
-bool Scalar::AbsoluteValue() {
-  switch (m_type) {
-  case e_void:
-    break;
-
-  case e_sint:
-  case e_slong:
-  case e_slonglong:
-  case e_sint128:
-  case e_sint256:
-    if (m_integer.isNegative())
-      m_integer = -m_integer;
-    return true;
-
-  case e_uint:
-  case e_ulong:
-  case e_ulonglong:
-    return true;
-  case e_uint128:
-  case e_uint256:
-  case e_float:
-  case e_double:
-  case e_long_double:
-    m_float.clearSign();
-    return true;
-  }
-  return false;
-}
-
-bool Scalar::UnaryNegate() {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    m_integer = -m_integer;
-    return true;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    m_float.changeSign();
-    return true;
-  }
-  return false;
-}
-
-bool Scalar::OnesComplement() {
-  switch (m_type) {
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    m_integer = ~m_integer;
-    return true;
-
-  case e_void:
-  case e_float:
-  case e_double:
-  case e_long_double:
-    break;
-  }
-  return false;
-}
-
-const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    case Scalar::e_void:
-      break;
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-      result.m_integer = a->m_integer + b->m_integer;
-      break;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      result.m_float = a->m_float + b->m_float;
-      break;
-    }
-  }
-  return result;
-}
-
-const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    case Scalar::e_void:
-      break;
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-      result.m_integer = a->m_integer - b->m_integer;
-      break;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      result.m_float = a->m_float - b->m_float;
-      break;
-    }
-  }
-  return result;
-}
-
-const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    case Scalar::e_void:
-      break;
-    case Scalar::e_sint:
-    case Scalar::e_slong:
-    case Scalar::e_slonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_sint256:
-      if (b->m_integer != 0) {
-        result.m_integer = a->m_integer.sdiv(b->m_integer);
-        return result;
-      }
-      break;
-    case Scalar::e_uint:
-    case Scalar::e_ulong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_uint128:
-    case Scalar::e_uint256:
-      if (b->m_integer != 0) {
-        result.m_integer = a->m_integer.udiv(b->m_integer);
-        return result;
-      }
-      break;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      if (!b->m_float.isZero()) {
-        result.m_float = a->m_float / b->m_float;
-        return result;
-      }
-      break;
-    }
-  }
-  // For division only, the only way it should make it here is if a promotion
-  // failed, or if we are trying to do a divide by zero.
-  result.m_type = Scalar::e_void;
-  return result;
-}
-
-const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    case Scalar::e_void:
-      break;
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-      result.m_integer = a->m_integer * b->m_integer;
-      break;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      result.m_float = a->m_float * b->m_float;
-      break;
-    }
-  }
-  return result;
-}
-
-const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-      result.m_integer = a->m_integer & b->m_integer;
-      break;
-    case Scalar::e_void:
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      // No bitwise AND on floats, doubles of long doubles
-      result.m_type = Scalar::e_void;
-      break;
-    }
-  }
-  return result;
-}
-
-const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-      result.m_integer = a->m_integer | b->m_integer;
-      break;
-
-    case Scalar::e_void:
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      // No bitwise AND on floats, doubles of long doubles
-      result.m_type = Scalar::e_void;
-      break;
-    }
-  }
-  return result;
-}
-
-const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    default:
-      break;
-    case Scalar::e_void:
-      break;
-    case Scalar::e_sint:
-    case Scalar::e_slong:
-    case Scalar::e_slonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_sint256:
-      if (b->m_integer != 0) {
-        result.m_integer = a->m_integer.srem(b->m_integer);
-        return result;
-      }
-      break;
-    case Scalar::e_uint:
-    case Scalar::e_ulong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_uint128:
-    case Scalar::e_uint256:
-      if (b->m_integer != 0) {
-        result.m_integer = a->m_integer.urem(b->m_integer);
-        return result;
-      }
-      break;
-    }
-  }
-  result.m_type = Scalar::e_void;
-  return result;
-}
-
-const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result;
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
-      Scalar::e_void) {
-    switch (result.m_type) {
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-      result.m_integer = a->m_integer ^ b->m_integer;
-      break;
-
-    case Scalar::e_void:
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      // No bitwise AND on floats, doubles of long doubles
-      result.m_type = Scalar::e_void;
-      break;
-    }
-  }
-  return result;
-}
-
-const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result = lhs;
-  result <<= rhs;
-  return result;
-}
-
-const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
-  Scalar result = lhs;
-  result >>= rhs;
-  return result;
-}
-
-Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
-                                   size_t byte_size) {
-  Status error;
-  if (value_str == nullptr || value_str[0] == '\0') {
-    error.SetErrorString("Invalid c-string value string.");
-    return error;
-  }
-  switch (encoding) {
-  case eEncodingInvalid:
-    error.SetErrorString("Invalid encoding.");
-    break;
-
-  case eEncodingUint:
-    if (byte_size <= sizeof(uint64_t)) {
-      uint64_t uval64;
-      if (!llvm::to_integer(value_str, uval64))
-        error.SetErrorStringWithFormat(
-            "'%s' is not a valid unsigned integer string value", value_str);
-      else if (!UIntValueIsValidForSize(uval64, byte_size))
-        error.SetErrorStringWithFormat("value 0x%" PRIx64
-                                       " is too large to fit in a %" PRIu64
-                                       " byte unsigned integer value",
-                                       uval64, (uint64_t)byte_size);
-      else {
-        m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
-        switch (m_type) {
-        case e_uint:
-          m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
-          break;
-        case e_ulong:
-          m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
-          break;
-        case e_ulonglong:
-          m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
-          break;
-        default:
-          error.SetErrorStringWithFormat(
-              "unsupported unsigned integer byte size: %" PRIu64 "",
-              (uint64_t)byte_size);
-          break;
-        }
-      }
-    } else {
-      error.SetErrorStringWithFormat(
-          "unsupported unsigned integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
-      return error;
-    }
-    break;
-
-  case eEncodingSint:
-    if (byte_size <= sizeof(int64_t)) {
-      int64_t sval64;
-      if (!llvm::to_integer(value_str, sval64))
-        error.SetErrorStringWithFormat(
-            "'%s' is not a valid signed integer string value", value_str);
-      else if (!SIntValueIsValidForSize(sval64, byte_size))
-        error.SetErrorStringWithFormat("value 0x%" PRIx64
-                                       " is too large to fit in a %" PRIu64
-                                       " byte signed integer value",
-                                       sval64, (uint64_t)byte_size);
-      else {
-        m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
-        switch (m_type) {
-        case e_sint:
-          m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
-          break;
-        case e_slong:
-          m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
-          break;
-        case e_slonglong:
-          m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
-          break;
-        default:
-          error.SetErrorStringWithFormat(
-              "unsupported signed integer byte size: %" PRIu64 "",
-              (uint64_t)byte_size);
-          break;
-        }
-      }
-    } else {
-      error.SetErrorStringWithFormat(
-          "unsupported signed integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
-      return error;
-    }
-    break;
-
-  case eEncodingIEEE754:
-    static float f_val;
-    static double d_val;
-    static long double l_val;
-    if (byte_size == sizeof(float)) {
-      if (::sscanf(value_str, "%f", &f_val) == 1) {
-        m_float = llvm::APFloat(f_val);
-        m_type = e_float;
-      } else
-        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
-                                       value_str);
-    } else if (byte_size == sizeof(double)) {
-      if (::sscanf(value_str, "%lf", &d_val) == 1) {
-        m_float = llvm::APFloat(d_val);
-        m_type = e_double;
-      } else
-        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
-                                       value_str);
-    } else if (byte_size == sizeof(long double)) {
-      if (::sscanf(value_str, "%Lf", &l_val) == 1) {
-        m_float =
-            llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
-                          llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
-                                      ((type128 *)&l_val)->x));
-        m_type = e_long_double;
-      } else
-        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
-                                       value_str);
-    } else {
-      error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
-                                     (uint64_t)byte_size);
-      return error;
-    }
-    break;
-
-  case eEncodingVector:
-    error.SetErrorString("vector encoding unsupported.");
-    break;
-  }
-  if (error.Fail())
-    m_type = e_void;
-
-  return error;
-}
-
-Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
-                                size_t byte_size) {
-  Status error;
-
-  type128 int128;
-  type256 int256;
-  switch (encoding) {
-  case lldb::eEncodingInvalid:
-    error.SetErrorString("invalid encoding");
-    break;
-  case lldb::eEncodingVector:
-    error.SetErrorString("vector encoding unsupported");
-    break;
-  case lldb::eEncodingUint: {
-    lldb::offset_t offset = 0;
-
-    switch (byte_size) {
-    case 1:
-      operator=((uint8_t)data.GetU8(&offset));
-      break;
-    case 2:
-      operator=((uint16_t)data.GetU16(&offset));
-      break;
-    case 4:
-      operator=((uint32_t)data.GetU32(&offset));
-      break;
-    case 8:
-      operator=((uint64_t)data.GetU64(&offset));
-      break;
-    case 16:
-      if (data.GetByteOrder() == eByteOrderBig) {
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
-      } else {
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
-      }
-      operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
-      break;
-    case 32:
-      if (data.GetByteOrder() == eByteOrderBig) {
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
-      } else {
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
-      }
-      operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
-      break;
-    default:
-      error.SetErrorStringWithFormat(
-          "unsupported unsigned integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
-      break;
-    }
-  } break;
-  case lldb::eEncodingSint: {
-    lldb::offset_t offset = 0;
-
-    switch (byte_size) {
-    case 1:
-      operator=((int8_t)data.GetU8(&offset));
-      break;
-    case 2:
-      operator=((int16_t)data.GetU16(&offset));
-      break;
-    case 4:
-      operator=((int32_t)data.GetU32(&offset));
-      break;
-    case 8:
-      operator=((int64_t)data.GetU64(&offset));
-      break;
-    case 16:
-      if (data.GetByteOrder() == eByteOrderBig) {
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
-      } else {
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
-      }
-      operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
-      break;
-    case 32:
-      if (data.GetByteOrder() == eByteOrderBig) {
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
-      } else {
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
-      }
-      operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
-      break;
-    default:
-      error.SetErrorStringWithFormat(
-          "unsupported signed integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
-      break;
-    }
-  } break;
-  case lldb::eEncodingIEEE754: {
-    lldb::offset_t offset = 0;
-
-    if (byte_size == sizeof(float))
-      operator=((float)data.GetFloat(&offset));
-    else if (byte_size == sizeof(double))
-      operator=((double)data.GetDouble(&offset));
-    else if (byte_size == sizeof(long double))
-      operator=((long double)data.GetLongDouble(&offset));
-    else
-      error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
-                                     (uint64_t)byte_size);
-  } break;
-  }
-
-  return error;
-}
-
-bool Scalar::SignExtend(uint32_t sign_bit_pos) {
-  const uint32_t max_bit_pos = GetByteSize() * 8;
-
-  if (sign_bit_pos < max_bit_pos) {
-    switch (m_type) {
-    case Scalar::e_void:
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-      return false;
-
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-      if (max_bit_pos == sign_bit_pos)
-        return true;
-      else if (sign_bit_pos < (max_bit_pos - 1)) {
-        llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
-        llvm::APInt bitwize_and = m_integer & sign_bit;
-        if (bitwize_and.getBoolValue()) {
-          const llvm::APInt mask =
-              ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
-          m_integer |= mask;
-        }
-        return true;
-      }
-      break;
-    }
-  }
-  return false;
-}
-
-size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
-                               lldb::ByteOrder dst_byte_order,
-                               Status &error) const {
-  // Get a data extractor that points to the native scalar data
-  DataExtractor data;
-  if (!GetData(data)) {
-    error.SetErrorString("invalid scalar value");
-    return 0;
-  }
-
-  const size_t src_len = data.GetByteSize();
-
-  // Prepare a memory buffer that contains some or all of the register value
-  const size_t bytes_copied =
-      data.CopyByteOrderedData(0,               // src offset
-                               src_len,         // src length
-                               dst,             // dst buffer
-                               dst_len,         // dst length
-                               dst_byte_order); // dst byte order
-  if (bytes_copied == 0)
-    error.SetErrorString("failed to copy data");
-
-  return bytes_copied;
-}
-
-bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
-  if (bit_size == 0)
-    return true;
-
-  switch (m_type) {
-  case Scalar::e_void:
-  case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
-    break;
-
-  case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-    m_integer = m_integer.ashr(bit_offset)
-                    .sextOrTrunc(bit_size)
-                    .sextOrSelf(8 * GetByteSize());
-    return true;
-
-  case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-    m_integer = m_integer.lshr(bit_offset)
-                    .zextOrTrunc(bit_size)
-                    .zextOrSelf(8 * GetByteSize());
-    return true;
-  }
-  return false;
-}
-
-bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
-  // If either entry is void then we can just compare the types
-  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
-    return lhs.m_type == rhs.m_type;
-
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
-  case Scalar::e_void:
-    break;
-  case Scalar::e_sint:
-  case Scalar::e_uint:
-  case Scalar::e_slong:
-  case Scalar::e_ulong:
-  case Scalar::e_slonglong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_uint128:
-  case Scalar::e_sint256:
-  case Scalar::e_uint256:
-    return a->m_integer == b->m_integer;
-  case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
-    result = a->m_float.compare(b->m_float);
-    if (result == llvm::APFloat::cmpEqual)
-      return true;
-  }
-  return false;
-}
-
-bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
-  // If either entry is void then we can just compare the types
-  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
-    return lhs.m_type != rhs.m_type;
-
-  Scalar
-      temp_value; // A temp value that might get a copy of either promoted value
-  const Scalar *a;
-  const Scalar *b;
-  llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
-  case Scalar::e_void:
-    break;
-  case Scalar::e_sint:
-  case Scalar::e_uint:
-  case Scalar::e_slong:
-  case Scalar::e_ulong:
-  case Scalar::e_slonglong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_uint128:
-  case Scalar::e_sint256:
-  case Scalar::e_uint256:
-    return a->m_integer != b->m_integer;
-  case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
-    result = a->m_float.compare(b->m_float);
-    if (result != llvm::APFloat::cmpEqual)
-      return true;
-  }
-  return true;
-}
-
-bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
-  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
-    return false;
-
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
-  case Scalar::e_void:
-    break;
-  case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-    return a->m_integer.slt(b->m_integer);
-  case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-    return a->m_integer.ult(b->m_integer);
-  case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
-    result = a->m_float.compare(b->m_float);
-    if (result == llvm::APFloat::cmpLessThan)
-      return true;
-  }
-  return false;
-}
-
-bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
-  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
-    return false;
-
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
-  case Scalar::e_void:
-    break;
-  case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-    return a->m_integer.sle(b->m_integer);
-  case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-    return a->m_integer.ule(b->m_integer);
-  case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
-    result = a->m_float.compare(b->m_float);
-    if (result == llvm::APFloat::cmpLessThan ||
-        result == llvm::APFloat::cmpEqual)
-      return true;
-  }
-  return false;
-}
-
-bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
-  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
-    return false;
-
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
-  case Scalar::e_void:
-    break;
-  case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-    return a->m_integer.sgt(b->m_integer);
-  case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-    return a->m_integer.ugt(b->m_integer);
-  case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
-    result = a->m_float.compare(b->m_float);
-    if (result == llvm::APFloat::cmpGreaterThan)
-      return true;
-  }
-  return false;
-}
-
-bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
-  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
-    return false;
-
-  Scalar temp_value;
-  const Scalar *a;
-  const Scalar *b;
-  llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
-  case Scalar::e_void:
-    break;
-  case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-    return a->m_integer.sge(b->m_integer);
-  case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-    return a->m_integer.uge(b->m_integer);
-  case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
-    result = a->m_float.compare(b->m_float);
-    if (result == llvm::APFloat::cmpGreaterThan ||
-        result == llvm::APFloat::cmpEqual)
-      return true;
-  }
-  return false;
-}
-
-bool Scalar::ClearBit(uint32_t bit) {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    m_integer.clearBit(bit);
-    return true;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    break;
-  }
-  return false;
-}
-
-bool Scalar::SetBit(uint32_t bit) {
-  switch (m_type) {
-  case e_void:
-    break;
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    m_integer.setBit(bit);
-    return true;
-  case e_float:
-  case e_double:
-  case e_long_double:
-    break;
-  }
-  return false;
-}

lldb/trunk/source/Core/State.cpp

-//===-- State.cpp -----------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
-#include "lldb/Core/State.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-const char *lldb_private::StateAsCString(StateType state) {
-  switch (state) {
-  case eStateInvalid:
-    return "invalid";
-  case eStateUnloaded:
-    return "unloaded";
-  case eStateConnected:
-    return "connected";
-  case eStateAttaching:
-    return "attaching";
-  case eStateLaunching:
-    return "launching";
-  case eStateStopped:
-    return "stopped";
-  case eStateRunning:
-    return "running";
-  case eStateStepping:
-    return "stepping";
-  case eStateCrashed:
-    return "crashed";
-  case eStateDetached:
-    return "detached";
-  case eStateExited:
-    return "exited";
-  case eStateSuspended:
-    return "suspended";
-  }
-  return "unknown";
-}
-
-const char *lldb_private::GetPermissionsAsCString(uint32_t permissions) {
-  switch (permissions) {
-  case 0:
-    return "---";
-  case ePermissionsWritable:
-    return "-w-";
-  case ePermissionsReadable:
-    return "r--";
-  case ePermissionsExecutable:
-    return "--x";
-  case ePermissionsReadable | ePermissionsWritable:
-    return "rw-";
-  case ePermissionsReadable | ePermissionsExecutable:
-    return "r-x";
-  case ePermissionsWritable | ePermissionsExecutable:
-    return "-wx";
-  case ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable:
-    return "rwx";
-  default:
-    break;
-  }
-  return "???";
-}
-
-bool lldb_private::StateIsRunningState(StateType state) {
-  switch (state) {
-  case eStateAttaching:
-  case eStateLaunching:
-  case eStateRunning:
-  case eStateStepping:
-    return true;
-
-  case eStateConnected:
-  case eStateDetached:
-  case eStateInvalid:
-  case eStateUnloaded:
-  case eStateStopped:
-  case eStateCrashed:
-  case eStateExited:
-  case eStateSuspended:
-    break;
-  }
-  return false;
-}
-
-bool lldb_private::StateIsStoppedState(StateType state, bool must_exist) {
-  switch (state) {
-  case eStateInvalid:
-  case eStateConnected:
-  case eStateAttaching:
-  case eStateLaunching:
-  case eStateRunning:
-  case eStateStepping:
-  case eStateDetached:
-    break;
-
-  case eStateUnloaded:
-  case eStateExited:
-    return !must_exist;
-
-  case eStateStopped:
-  case eStateCrashed:
-  case eStateSuspended:
-    return true;
-  }
-  return false;
-}

lldb/trunk/source/Core/Value.cpp

 //===-- Value.cpp -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Value.h"
 
-#include "lldb/Core/Address.h"  // for Address
+#include "lldb/Core/Address.h" // for Address
 #include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"   // for InlHostByteOrder
 #include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
 #include "lldb/lldb-forward.h" // for DataBufferSP, ModuleSP
 #include "lldb/lldb-types.h"   // for addr_t
 
 #include <memory> // for make_shared
 #include <string> // for string
 

lldb/trunk/source/Core/ValueObject.cpp

 //===-- ValueObject.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObject.h"
 
 #include "lldb/Core/Address.h" // for Address
 #include "lldb/Core/Module.h"
-#include "lldb/Core/Scalar.h" // for Scalar
 #include "lldb/Core/ValueObjectCast.h"
 #include "lldb/Core/ValueObjectChild.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectSyntheticFilter.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/DumpValueObjectOptions.h" // for DumpValueObj...
-#include "lldb/DataFormatters/FormatManager.h" // for FormatManager
+#include "lldb/DataFormatters/FormatManager.h"          // for FormatManager
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeFormat.h"    // for TypeFormatImpl_F...
 #include "lldb/DataFormatters/TypeSummary.h"   // for TypeSummaryOptions
 #include "lldb/DataFormatters/TypeValidator.h" // for TypeValidatorImp...
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Expression/ExpressionVariable.h" // for ExpressionVariable
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"

 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"  // for ThreadList
 #include "lldb/Utility/DataBuffer.h" // for DataBuffer
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Flags.h" // for Flags
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"    // for GetLogIfAllCateg...
+#include "lldb/Utility/Scalar.h"     // for Scalar
 #include "lldb/Utility/SharingPtr.h" // for SharingPtr
 #include "lldb/Utility/Stream.h"     // for Stream
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-private-types.h" // for RegisterInfo
 
 #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
 
 #include <algorithm> // for min

lldb/trunk/source/Core/ValueObjectCast.cpp

 //===-- ValueObjectCast.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectCast.h"
 
-#include "lldb/Core/Scalar.h" // for operator!=, Scalar
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Utility/Scalar.h" // for operator!=, Scalar
 #include "lldb/Utility/Status.h" // for Status
 
 namespace lldb_private {
 class ConstString;
 }
 
 using namespace lldb_private;
 

lldb/trunk/source/Core/ValueObjectChild.cpp

 //===-- ValueObjectChild.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectChild.h"
 
-#include "lldb/Core/Scalar.h" // for Scalar
-#include "lldb/Core/Value.h"  // for Value, Value::ValueType::e...
+#include "lldb/Core/Value.h" // for Value, Value::ValueType::e...
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Flags.h"  // for Flags
+#include "lldb/Utility/Scalar.h" // for Scalar
 #include "lldb/Utility/Status.h" // for Status
 #include "lldb/lldb-forward.h"   // for ProcessSP, ModuleSP
 
 #include <functional> // for _Func_impl<>::_Mybase
 #include <memory>     // for shared_ptr
 #include <vector>     // for vector
 
 #include <stdio.h>  // for snprintf, size_t

lldb/trunk/source/Core/ValueObjectConstResult.cpp

 //===-- ValueObjectConstResult.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectConstResult.h"
 
-#include "lldb/Core/Scalar.h" // for Scalar
 #include "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextScope
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBuffer.h"     // for DataBuffer
 #include "lldb/Utility/DataBufferHeap.h" // for DataBufferHeap
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h" // for Scalar
 
 namespace lldb_private {
 class Module;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/trunk/source/Core/ValueObjectConstResultImpl.cpp

 //===-- ValueObjectConstResultImpl.cpp ---------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectConstResultImpl.h"
 
-#include "lldb/Core/Scalar.h"      // for Scalar
 #include "lldb/Core/Value.h"       // for Value, Value::Val...
 #include "lldb/Core/ValueObject.h" // for ValueObject
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectConstResultCast.h"
 #include "lldb/Core/ValueObjectConstResultChild.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Utility/DataBufferHeap.h" // for DataBufferHeap
 #include "lldb/Utility/Endian.h"         // for InlHostByteOrder
+#include "lldb/Utility/Scalar.h"         // for Scalar
 #include "lldb/Utility/SharingPtr.h"     // for SharingPtr
 
 #include <string> // for string
 
 namespace lldb_private {
 class DataExtractor;
 }
 namespace lldb_private {

lldb/trunk/source/Core/ValueObjectDynamicValue.cpp

 //===-- ValueObjectDynamicValue.cpp ------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectDynamicValue.h"
-#include "lldb/Core/Scalar.h" // for Scalar, operator!=
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h" // for DataExtractor
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h" // for GetLogIfAllCategoriesSet
+#include "lldb/Utility/Scalar.h"  // for Scalar, operator!=
 #include "lldb/Utility/Status.h"  // for Status
 #include "lldb/lldb-types.h"      // for addr_t, offset_t
 
 #include <string.h> // for strcmp, size_t
 namespace lldb_private {
 class Declaration;
 }
 

lldb/trunk/source/Core/ValueObjectMemory.cpp

 //===-- ValueObjectMemory.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectMemory.h"
-#include "lldb/Core/Scalar.h" // for Scalar, operator!=
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h" // for DataExtractor
+#include "lldb/Utility/Scalar.h"        // for Scalar, operator!=
 #include "lldb/Utility/Status.h"        // for Status
 #include "lldb/lldb-types.h"            // for addr_t
 #include "llvm/Support/ErrorHandling.h" // for llvm_unreachable
 
 #include <assert.h> // for assert
 #include <memory>   // for shared_ptr
 
 namespace lldb_private {

lldb/trunk/source/Core/ValueObjectRegister.cpp

 //===-- ValueObjectRegister.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectRegister.h"
 
 #include "lldb/Core/Module.h"
-#include "lldb/Core/Scalar.h" // for Scalar
-#include "lldb/Core/Value.h"  // for Value, Value::ContextType:...
+#include "lldb/Core/Value.h" // for Value, Value::ContextType:...
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h" // for TypeSystem
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h" // for StackFrame
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h" // for DataExtractor
+#include "lldb/Utility/Scalar.h"        // for Scalar
 #include "lldb/Utility/Status.h"        // for Status
 #include "lldb/Utility/Stream.h"        // for Stream
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 
 #include <assert.h> // for assert
 #include <memory>   // for shared_ptr
 

lldb/trunk/source/Core/ValueObjectVariable.cpp

 //===-- ValueObjectVariable.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectVariable.h"
 
 #include "lldb/Core/Address.h"      // for Address
 #include "lldb/Core/AddressRange.h" // for AddressRange
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h" // for Scalar, operator!=
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h" // for DWARFExpression
 #include "lldb/Symbol/Declaration.h"         // for Declaration
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/DataExtractor.h"     // for DataExtractor
+#include "lldb/Utility/DataExtractor.h" // for DataExtractor
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"            // for Scalar, operator!=
 #include "lldb/Utility/Status.h"            // for Status
 #include "lldb/lldb-private-enumerations.h" // for AddressType::eAddressTy...
 #include "lldb/lldb-types.h"                // for addr_t
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 
 #include <assert.h> // for assert
 #include <memory>   // for shared_ptr

lldb/trunk/source/Expression/DWARFExpression.cpp

 
 // C Includes
 #include <inttypes.h>
 
 // C++ Includes
 #include <vector>
 
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/VMRange.h"
 
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/Endian.h"
 
 #include "lldb/Symbol/Function.h"
 

lldb/trunk/source/Expression/FunctionCaller.cpp

 //===-- FunctionCaller.cpp ---------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 
 // Project includes
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // FunctionCaller constructor
 //----------------------------------------------------------------------
 FunctionCaller::FunctionCaller(ExecutionContextScope &exe_scope,
                                const CompilerType &return_type,

lldb/trunk/source/Expression/IRInterpreter.cpp

 //===-- IRInterpreter.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"

lldb/trunk/source/Expression/IRMemoryMap.cpp

 //===-- IRMemoryMap.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/IRMemoryMap.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb_private;
 
 IRMemoryMap::IRMemoryMap(lldb::TargetSP target_sp) : m_target_wp(target_sp) {
   if (target_sp)
     m_process_wp = target_sp->GetProcessSP();
 }

lldb/trunk/source/Expression/Materializer.cpp

 //===-- Materializer.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Core/DumpDataExtractor.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb_private;
 
 uint32_t Materializer::AddStructMember(Entity &entity) {
   uint32_t size = entity.GetSize();
   uint32_t alignment = entity.GetAlignment();
 
   uint32_t ret;

lldb/trunk/source/Host/common/NativeProcessProtocol.cpp

 //===-- NativeProcessProtocol.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/common/NativeProcessProtocol.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Host/common/SoftwareBreakpoint.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // -----------------------------------------------------------------------------
 // NativeProcessProtocol Members
 // -----------------------------------------------------------------------------

lldb/trunk/source/Host/common/NativeRegisterContext.cpp

 //===-- NativeRegisterContext.cpp -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/common/NativeRegisterContext.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

 #include "Commands/CommandObjectTarget.h"
 #include "Commands/CommandObjectThread.h"
 #include "Commands/CommandObjectType.h"
 #include "Commands/CommandObjectVersion.h"
 #include "Commands/CommandObjectWatchpoint.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 #ifndef LLDB_DISABLE_LIBEDIT
 #include "lldb/Host/Editline.h"
 #endif
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"

lldb/trunk/source/Interpreter/OptionValueArch.cpp

 //===-- OptionValueArch.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueArch.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/State.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Utility/Args.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueArch::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                                 uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());

lldb/trunk/source/Interpreter/OptionValueDictionary.cpp

 //===-- OptionValueDictionary.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueDictionary.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
 // Project includes
-#include "lldb/Core/State.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Utility/Args.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueDictionary::DumpValue(const ExecutionContext *exe_ctx,
                                       Stream &strm, uint32_t dump_mask) {
   const Type dict_type = ConvertTypeMaskToType(m_type_mask);
   if (dump_mask & eDumpOptionType) {

lldb/trunk/source/Interpreter/OptionValueFileSpec.cpp

 //===-- OptionValueFileSpec.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueFileSpec.h"
 
-#include "lldb/Core/State.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataBufferLLVM.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionValueFileSpec::OptionValueFileSpec(bool resolve)
     : OptionValue(), m_current_value(), m_default_value(), m_data_sp(),
       m_data_mod_time(),
       m_completion_mask(CommandCompletions::eDiskFileCompletion),

lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Utility/ARMDefines.h"
 #include "Utility/ARM_DWARF_Registers.h"
 #include "Utility/ARM_ehframe_Registers.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

 #include <vector>
 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 
 #include "Utility/ARM64_DWARF_Registers.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const char *pluginDesc = "Mac OS X ABI for arm64 targets";

lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 enum {
   ehframe_eax = 0,
   ehframe_ecx,

lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Utility/ARMDefines.h"
 #include "Utility/ARM_DWARF_Registers.h"
 #include "Utility/ARM_ehframe_Registers.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 
 #include "Utility/ARM64_DWARF_Registers.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static RegisterInfo g_register_infos[] = {

lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/DerivedTypes.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static RegisterInfo g_register_infos[] = {
     // hexagon-core.xml
     {"r00",

lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //   This source file uses the following document as a reference:
 //====================================================================
 //             System V Application Binary Interface

lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 enum dwarf_regnums {
   dwarf_r0 = 0,
   dwarf_r1,

lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 enum dwarf_regnums {
   dwarf_r0 = 0,
   dwarf_r1,

lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 enum dwarf_regnums {
   dwarf_r0 = 0,
   dwarf_r1,

lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "Utility/PPC64LE_DWARF_Registers.h"
 #include "Utility/PPC64_DWARF_Registers.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 
 #define DECLARE_REGISTER_INFOS_PPC64_STRUCT
 #include "Plugins/Process/Utility/RegisterInfos_ppc64.h"

lldb/trunk/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 enum dwarf_regnums {
   // General Purpose Registers
   dwarf_r0_s390x = 0,

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 enum dwarf_regnums {
   dwarf_rax = 0,
   dwarf_rdx,

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

 
 #include "Plugins/Platform/MacOSX/PlatformDarwinKernel.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/OperatingSystem.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 #include "DynamicLoaderDarwinKernel.h"
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
 #else

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

 #include "DynamicLoaderDarwin.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

 //===-- DynamicLoaderMacOS.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 #include "DynamicLoaderDarwin.h"
 #include "DynamicLoaderMacOS.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

 //===-- DynamicLoaderMacOSXDYLD.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 #include "DynamicLoaderDarwin.h"
 #include "DynamicLoaderMacOSXDYLD.h"
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 #include "ASTDumper.h"
 #include "ClangASTSource.h"
 #include "ClangModulesDeclVendor.h"
 #include "ClangPersistentVariables.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/Function.h"

 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/RecursiveASTVisitor.h"

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/IR/Module.h"
 
 // Project includes
 #include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // ClangFunctionCaller constructor
 //----------------------------------------------------------------------
 ClangFunctionCaller::ClangFunctionCaller(ExecutionContextScope &exe_scope,
                                          const CompilerType &return_type,

lldb/trunk/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 
 #include "clang/AST/ASTContext.h"
 
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <map>
 
 using namespace llvm;
 
 static char ID;
 

lldb/trunk/source/Plugins/Instruction/ARM/EmulationStateARM.cpp

 //===-- EmulationStateARM.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "EmulationStateARM.h"
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Interpreter/OptionValueArray.h"
 #include "lldb/Interpreter/OptionValueDictionary.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 
 #include "Utility/ARM_DWARF_Registers.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 EmulationStateARM::EmulationStateARM() : m_gpr(), m_vfp_regs(), m_memory() {
   ClearPseudoRegisters();

lldb/trunk/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

 //===-- EmulateInstructionARM64.cpp ------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "EmulateInstructionARM64.h"
 
 #include <stdlib.h>
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Stream.h"
 
 #include "Plugins/Process/Utility/ARMDefines.h"
 #include "Plugins/Process/Utility/ARMUtils.h"
 #include "Plugins/Process/Utility/lldb-arm64-register-enums.h"
 
 #define GPR_OFFSET(idx) ((idx)*8)
 #define GPR_OFFSET_NAME(reg) 0

lldb/trunk/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

 //===-- EmulateInstructionMIPS.cpp -------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "EmulateInstructionMIPS.h"
 
 #include <stdlib.h>
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Opcode.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Stream.h"
 #include "llvm-c/Disassembler.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"

lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

 //===-- EmulateInstructionMIPS64.cpp -----------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "EmulateInstructionMIPS64.h"
 
 #include <stdlib.h>
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Opcode.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Stream.h"
 #include "llvm-c/Disassembler.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

 //===-- ItaniumABILanguageRuntime.cpp --------------------------------------*-
 //C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ItaniumABILanguageRuntime.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const char *vtable_demangled_prefix = "vtable for ";

lldb/trunk/source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.cpp

 //===-- GoLanguageRuntime.cpp --------------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "GoLanguageRuntime.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Symbol/GoASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "llvm/ADT/Twine.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

 #include "AppleObjCTrampolineHandler.h"
 
 #include "clang/AST/Type.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

 #include "AppleObjCDeclVendor.h"
 #include "AppleObjCTrampolineHandler.h"
 
 #include "clang/AST/Type.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 #include "lldb/Host/OptionParser.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 #include "AppleObjCClassDescriptorV2.h"
 #include "AppleObjCDeclVendor.h"
 #include "AppleObjCRuntimeV2.h"

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 // Project includes
 #include "RenderScriptRuntime.h"
 #include "RenderScriptScriptGroup.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_renderscript;
 
 #define FMT_COORD "(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")"

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 #include "Plugins/Process/Utility/RegisterContextDarwin_i386.h"
 #include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RangeMap.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/UUID.h"
 
 #include "lldb/Utility/SafeMachO.h"
 
 #include "llvm/Support/MemoryBuffer.h"

lldb/trunk/source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

 #include "OperatingSystemGo.h"
 
 #include "Plugins/Process/Utility/DynamicRegisterInfo.h"
 #include "Plugins/Process/Utility/RegisterContextMemory.h"
 #include "Plugins/Process/Utility/ThreadMemory.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/OptionGroupUInt64.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
 static PropertyDefinition g_properties[] = {

lldb/trunk/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

 // Other libraries and framework includes
 #include "Plugins/Process/Utility/DynamicRegisterInfo.h"
 #include "Plugins/Process/Utility/RegisterContextDummy.h"
 #include "Plugins/Process/Utility/RegisterContextMemory.h"
 #include "Plugins/Process/Utility/ThreadMemory.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OperatingSystemPython::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

 //===-- PlatformAndroid.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/UriParser.h"
 
 // Project includes
 #include "AdbClient.h"
 #include "PlatformAndroid.h"
 #include "PlatformAndroidRemoteGDBServer.h"
 #include "lldb/Target/Target.h"
 

lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from FreeBSD mman.h for use when targeting remote
 // FreeBSD systems even when host has different values.
 #define MAP_PRIVATE 0x0002
 #define MAP_ANON 0x1000
 

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp

 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from Linux mman.h for use when targeting remote linux
 // systems even when host has different values.
 #define MAP_PRIVATE 2
 #define MAP_ANON 0x20
 

lldb/trunk/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from NetBSD mman.h for use when targeting remote
 // netbsd systems even when host has different values.
 #define MAP_PRIVATE 0x0002
 #define MAP_ANON 0x1000
 

lldb/trunk/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 // Define these constants from OpenBSD mman.h for use when targeting remote
 // openbsd systems even when host has different values.
 #define MAP_PRIVATE 0x0002
 #define MAP_ANON 0x1000
 

lldb/trunk/source/Plugins/Process/Darwin/NativeProcessDarwin.cpp

 #include <mach/mach_traps.h>
 #include <sys/ptrace.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 
 // C++ includes
 // LLDB includes
-#include "lldb/Core/State.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "CFBundle.h"
 #include "CFString.h"
 #include "DarwinProcessLauncher.h"
 
 #include "MachException.h"
 

lldb/trunk/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp

 #include <pthread_np.h>
 #include <stdlib.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/user.h>
 
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/State.h"
 #include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/State.h"
 
 // Project includes
 #include "FreeBSDThread.h"
 #include "POSIXStopInfo.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
 #include "Plugins/Process/Utility/UnwindLLDB.h"
 #include "ProcessFreeBSD.h"
 #include "ProcessMonitor.h"
 #include "RegisterContextPOSIXProcessMonitor_arm.h"
 #include "RegisterContextPOSIXProcessMonitor_arm64.h"
 #include "RegisterContextPOSIXProcessMonitor_mips64.h"
 #include "RegisterContextPOSIXProcessMonitor_powerpc.h"
 #include "RegisterContextPOSIXProcessMonitor_x86.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Debugger.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
+#include "lldb/Utility/State.h"
 #include "llvm/ADT/SmallString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 FreeBSDThread::FreeBSDThread(Process &process, lldb::tid_t tid)
     : Thread(process, tid), m_frame_ap(), m_breakpoint(),
       m_thread_name_valid(false), m_thread_name(), m_posix_thread(nullptr) {

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 #include <machine/elf.h>
 
 // C++ Includes
 #include <mutex>
 #include <unordered_map>
 
 // Other libraries and framework includes
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/State.h"
 
 #include "FreeBSDThread.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/FreeBSDSignals.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
 #include "ProcessFreeBSD.h"
 #include "ProcessMonitor.h"
 
 // Other libraries and framework includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/State.h"
 
 #include "lldb/Host/posix/Fcntl.h"
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp

 #include <sys/ptrace.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "llvm/Support/Errno.h"
 
 #include "FreeBSDThread.h"
 #include "Plugins/Process/POSIX/CrashReason.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "ProcessFreeBSD.h"
 #include "ProcessMonitor.h"

lldb/trunk/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.cpp

 //===-- RegisterContextPOSIXProcessMonitor_arm.cpp -----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "ProcessFreeBSD.h"
 #include "ProcessMonitor.h"
 #include "RegisterContextPOSIXProcessMonitor_arm.h"
 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm.h"
 
 using namespace lldb_private;
 using namespace lldb;

lldb/trunk/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.cpp

 //===-- RegisterContextPOSIXProcessMonitor_arm64.cpp -----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
 #include "ProcessFreeBSD.h"
 #include "ProcessMonitor.h"
 #include "RegisterContextPOSIXProcessMonitor_arm64.h"
 
 #define REG_CONTEXT_SIZE (GetGPRSize())
 

lldb/trunk/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp

 //===-- RegisterContextPOSIXProcessMonitor_mips64.cpp -----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "Plugins/Process/Utility/RegisterContextPOSIX_mips64.h"
 #include "ProcessFreeBSD.h"
 #include "ProcessMonitor.h"
 #include "RegisterContextPOSIXProcessMonitor_mips64.h"
 
 using namespace lldb_private;
 using namespace lldb;

lldb/trunk/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp

 //===-- RegisterContextPOSIXProcessMonitor_powerpc.cpp ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "ProcessFreeBSD.h"
 #include "ProcessMonitor.h"
 #include "RegisterContextPOSIXProcessMonitor_powerpc.h"
 #include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
 
 using namespace lldb_private;
 using namespace lldb;

lldb/trunk/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp

 //===-- RegisterContextPOSIXProcessMonitor_x86.cpp --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
 #include "Plugins/Process/FreeBSD/ProcessMonitor.h"
 #include "RegisterContextPOSIXProcessMonitor_x86.h"
 
 using namespace lldb_private;
 using namespace lldb;
 

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include <mutex>
 #include <sstream>
 #include <string>
 #include <unordered_map>
 
 // Other libraries and framework includes
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/common/NativeBreakpoint.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/linux/Ptrace.h"
 #include "lldb/Host/linux/Uio.h"
 #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 #include "NativeThreadLinux.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

 //===-- NativeRegisterContextLinux.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeRegisterContextLinux.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Host/linux/Ptrace.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 NativeRegisterContextLinux::NativeRegisterContextLinux(

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
 
 #include "NativeRegisterContextLinux_arm.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include <elf.h>
 #include <sys/socket.h>
 
 #define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(m_fpr))
 
 #ifndef PTRACE_GETVFPREGS

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

 
 #include "NativeRegisterContextLinux_arm.h"
 #include "NativeRegisterContextLinux_arm64.h"
 
 // C Includes
 // C++ Includes
 
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
 
 // System includes - They have to be included after framework includes because

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 
 // Other libraries and framework includes
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
 #include "lldb/Core/EmulateInstruction.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private-enumerations.h"
 #define NT_MIPS_MSA 0x600
 #define CONFIG5_FRE (1 << 8)
 #define SR_FR (1 << 26)
 #define NUM_REGISTERS 32
 

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp

 //===-- NativeRegisterContextLinux_ppc64le.cpp ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This implementation is related to the OpenPOWER ABI for Power Architecture
 // 64-bit ELF V2 ABI
 
 #if defined(__powerpc64__)
 
 #include "NativeRegisterContextLinux_ppc64le.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.h"
 
 // System includes - They have to be included after framework includes because

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp

 //===-- NativeRegisterContextLinux_s390x.cpp --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__s390x__) && defined(__linux__)
 
 #include "NativeRegisterContextLinux_s390x.h"
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h"
 
 #include <asm/ptrace.h>
 #include <linux/uio.h>
 #include <sys/ptrace.h>
 

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

 //===-- NativeRegisterContextLinux_x86_64.cpp ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__i386__) || defined(__x86_64__)
 
 #include "NativeRegisterContextLinux_x86_64.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 
 #include <linux/elf.h>
 
 using namespace lldb_private;

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.cpp

 
 #include <signal.h>
 #include <sstream>
 
 #include "NativeProcessLinux.h"
 #include "NativeRegisterContextLinux.h"
 #include "SingleStepCheck.h"
 
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/linux/Ptrace.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/SmallString.h"
 
 #include "Plugins/Process/POSIX/CrashReason.h"
 
 #include <sys/syscall.h>
 // Try to define a macro to encapsulate the tgkill syscall

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp

 #include <errno.h>
 #include <limits.h>
 #include <string.h>
 
 // C++ Includes
 
 // Other libraries and framework includes
 #include "lldb/Core/DumpDataExtractor.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/UUID.h"
 
 // Project includes
 #include "ProcessKDPLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 // C++ Includes
 #include <mutex>
 
 // Other libraries and framework includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
-#include "lldb/Utility/UUID.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupString.h"
 #include "lldb/Interpreter/OptionGroupUInt64.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StringExtractor.h"
+#include "lldb/Utility/UUID.h"
 
 #include "llvm/Support/Threading.h"
 
 #define USEC_PER_SEC 1000000
 
 // Project includes
 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp

 //===-- ThreadKDP.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ThreadKDP.h"
 
 #include "lldb/Utility/SafeMachO.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
-#include "lldb/Core/State.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "ProcessKDP.h"
 #include "ProcessKDPLog.h"
 #include "RegisterContextKDP_arm.h"
 #include "RegisterContextKDP_arm64.h"
 #include "RegisterContextKDP_i386.h"

lldb/trunk/source/Plugins/Process/NetBSD/CMakeLists.txt

 add_lldb_library(lldbPluginProcessNetBSD PLUGIN
   NativeProcessNetBSD.cpp
   NativeRegisterContextNetBSD.cpp
   NativeRegisterContextNetBSD_x86_64.cpp
   NativeThreadNetBSD.cpp
 
   LINK_LIBS
-    lldbCore
     lldbHost
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginProcessPOSIX
     lldbPluginProcessUtility
   LINK_COMPONENTS
     Support
   )

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

 #include "NativeProcessNetBSD.h"
 
 // C Includes
 
 // C++ Includes
 
 // Other libraries and framework includes
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/common/NativeBreakpoint.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/State.h"
 #include "llvm/Support/Errno.h"
 
 // System includes - They have to be included after framework includes because
 // they define some macros which collide with variable names in other modules
 // clang-format off
 #include <sys/types.h>
 #include <sys/ptrace.h>
 #include <sys/sysctl.h>

lldb/trunk/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.cpp

 //===-- NativeRegisterContextNetBSD_x86_64.cpp ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__x86_64__)
 
 #include "NativeRegisterContextNetBSD_x86_64.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Utility/RegisterContextNetBSD_x86_64.h"
 
 // clang-format off
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #include <x86/cpu.h>

lldb/trunk/source/Plugins/Process/NetBSD/NativeThreadNetBSD.cpp

 //===-- NativeThreadNetBSD.cpp -------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeThreadNetBSD.h"
 #include "NativeRegisterContextNetBSD.h"
 
 #include "NativeProcessNetBSD.h"
 
 #include "Plugins/Process/POSIX/CrashReason.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/State.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/State.h"
 
 #include <sstream>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_netbsd;
 
 NativeThreadNetBSD::NativeThreadNetBSD(NativeProcessNetBSD &process,

lldb/trunk/source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

 //===-- RegisterContextDarwin_arm.cpp ---------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextDarwin_arm.h"
 #include "RegisterContextDarwinConstants.h"
 
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "Plugins/Process/Utility/InstructionUtils.h"
 
 // Support building against older versions of LLVM, this macro was added
 // recently.
 #ifndef LLVM_EXTENSION
 #define LLVM_EXTENSION

lldb/trunk/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

 //===-- RegisterContextDarwin_arm64.cpp ---------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextDarwin_arm64.h"
 #include "RegisterContextDarwinConstants.h"
 
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
 
 #include "Plugins/Process/Utility/InstructionUtils.h"
 
 // Support building against older versions of LLVM, this macro was added
 // recently.
 #ifndef LLVM_EXTENSION

lldb/trunk/source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

 //===-- RegisterContextDarwin_i386.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <stddef.h> // offsetof
 
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
 
 // Support building against older versions of LLVM, this macro was added
 // recently.
 #ifndef LLVM_EXTENSION
 #define LLVM_EXTENSION
 #endif

lldb/trunk/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

 //===-- RegisterContextDarwin_x86_64.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <inttypes.h> // PRIx64
 #include <stdarg.h>
 #include <stddef.h> // offsetof
 
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
 
 // Support building against older versions of LLVM, this macro was added
 // recently.
 #ifndef LLVM_EXTENSION
 #define LLVM_EXTENSION
 #endif

lldb/trunk/source/Plugins/Process/Utility/RegisterContextDummy.cpp

 //===-- RegisterContextDummy.cpp ---------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private.h"
 
 #include "RegisterContextDummy.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextDummy::RegisterContextDummy(Thread &thread,

lldb/trunk/source/Plugins/Process/Utility/RegisterContextHistory.cpp

 //===-- RegisterContextHistory.cpp ---------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private.h"
 
 #include "RegisterContextHistory.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextHistory::RegisterContextHistory(Thread &thread,

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

 //===-- RegisterContextLLDB.cpp --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private.h"
 
 #include "RegisterContextLLDB.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {

lldb/trunk/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp

 //===-- RegisterContextMacOSXFrameBackchain.cpp -----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextMacOSXFrameBackchain.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 // Project includes
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------

lldb/trunk/source/Plugins/Process/Utility/RegisterContextMemory.cpp

 //===-- RegisterContextMemory.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextMemory.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "DynamicRegisterInfo.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // RegisterContextMemory constructor
 //----------------------------------------------------------------------

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp

 //===-- RegisterContextPOSIX_arm.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 #include <errno.h>
 #include <stdint.h>
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "RegisterContextPOSIX_arm.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // arm general purpose registers.

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp

 //===-- RegisterContextPOSIX_arm64.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 #include <errno.h>
 #include <stdint.h>
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "RegisterContextPOSIX_arm64.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ARM64 general purpose registers.

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp

 //===-- RegisterContextPOSIX_mips64.cpp -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 #include <errno.h>
 #include <stdint.h>
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "RegisterContextPOSIX_mips64.h"
 #include "RegisterContextFreeBSD_mips64.h"
 #include "RegisterContextLinux_mips64.h"
 #include "RegisterContextLinux_mips.h"
 
 using namespace lldb_private;

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp

 //===-- RegisterContextPOSIX_powerpc.cpp -------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 #include <errno.h>
 #include <stdint.h>
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "RegisterContextPOSIX_powerpc.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 static const uint32_t g_gpr_regnums[] = {

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp

 //===-- RegisterContextPOSIX_ppc64le.cpp -------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 #include <errno.h>
 #include <stdint.h>
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "RegisterContextPOSIX_ppc64le.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 static const uint32_t g_gpr_regnums[] = {

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp

 //===-- RegisterContextPOSIX_s390x.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 #include <errno.h>
 #include <stdint.h>
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "RegisterContextPOSIX_s390x.h"
 #include "RegisterContext_s390x.h"
 
 using namespace lldb_private;
 using namespace lldb;
 

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp

 //===-- RegisterContextPOSIX_x86.cpp ----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 #include <errno.h>
 #include <stdint.h>
 
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "RegisterContextPOSIX_x86.h"
 #include "RegisterContext_x86.h"
 
 using namespace lldb_private;
 using namespace lldb;
 

lldb/trunk/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

 #include "lldb/Host/windows/windows.h"
 #include <psapi.h>
 
 // Other libraries and framework includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostNativeProcessBase.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/State.h"
 
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "DebuggerThread.h"
 #include "ExceptionRecord.h"

lldb/trunk/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp

 //===-- TargetThreadWindows.cpp----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThreadBase.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
+#include "lldb/Utility/State.h"
 
 #include "Plugins/Process/Utility/UnwindLLDB.h"
 #include "ProcessWindows.h"
 #include "ProcessWindowsLog.h"
 #include "TargetThreadWindows.h"
 
 #if defined(_WIN64)
 #include "x64/RegisterContextWindows_x64.h"

lldb/trunk/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp

 //===-- RegisterContextWindows_x64.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 
 #include "RegisterContextWindows_x64.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "TargetThreadWindows.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 

lldb/trunk/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp

 //===-- RegisterContextWindows_x86.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 
 #include "ProcessWindowsLog.h"
 #include "RegisterContextWindows_x86.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "TargetThreadWindows.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"

lldb/trunk/source/Plugins/Process/elf-core/ProcessElfCore.cpp

 // C++ Includes
 #include <mutex>
 
 // Other libraries and framework includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "ProcessElfCore.h"

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm.cpp

 //===-- RegisterContextPOSIXCore_arm.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_arm.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_arm::RegisterContextCorePOSIX_arm(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm(thread, 0, register_info) {
   m_gpr_buffer.reset(

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

 //===-- RegisterContextPOSIXCore_arm64.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_arm64.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_arm64::RegisterContextCorePOSIX_arm64(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm64(thread, 0, register_info) {
   m_gpr_buffer.reset(

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp

 //===-- RegisterContextPOSIXCore_mips64.cpp ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_mips64.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_mips64::RegisterContextCorePOSIX_mips64(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_mips64(thread, 0, register_info) {
   m_gpr_buffer.reset(

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_powerpc.cpp

 //===-- RegisterContextPOSIXCore_powerpc.cpp --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_powerpc.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_powerpc::RegisterContextCorePOSIX_powerpc(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_powerpc(thread, 0, register_info) {
   m_gpr_buffer.reset(

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_ppc64le.cpp

 //===-- RegisterContextPOSIXCore_ppc64le.cpp --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_ppc64le.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 #include "Plugins/Process/Utility/lldb-ppc64le-register-enums.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_ppc64le::RegisterContextCorePOSIX_ppc64le(
     Thread &thread, RegisterInfoInterface *register_info,

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_s390x.cpp

 //===-- RegisterContextPOSIXCore_s390x.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_s390x.h"
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_s390x::RegisterContextCorePOSIX_s390x(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_s390x(thread, 0, register_info) {
   m_gpr_buffer.reset(

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.cpp

 //===-- RegisterContextPOSIXCore_x86_64.cpp ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_x86_64.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_x86_64::RegisterContextCorePOSIX_x86_64(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_x86(thread, 0, register_info) {
   size_t size, len;

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 #include <sys/stat.h>
 
 // C++ Includes
 #include <numeric>
 #include <sstream>
 
 // Other libraries and framework includes
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
 // Project includes
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 
 // C Includes
 // C++ Includes
 #include <chrono>
 #include <cstring>
 #include <thread>
 
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UriParser.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 // Project includes
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

 //===-- GDBRemoteRegisterContext.cpp ----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "GDBRemoteRegisterContext.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 // Project includes
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "Utility/ARM_DWARF_Registers.h"
 #include "Utility/ARM_ehframe_Registers.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 #include <mutex>
 #include <sstream>
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/PseudoTerminal.h"

 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 // Project includes
 #include "GDBRemoteRegisterContext.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"

lldb/trunk/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp

 //===-- ThreadGDBRemote.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ThreadGDBRemote.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
-#include "lldb/Core/State.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/Plugins/Process/mach-core/ProcessMachCore.cpp

 #include <mutex>
 
 // Other libraries and framework includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 // Project includes
 #include "ProcessMachCore.h"
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "ThreadMachCore.h"
 
 // Needed for the plug-in names for the dynamic loaders.
 #include "lldb/Utility/SafeMachO.h"

lldb/trunk/source/Plugins/Process/mach-core/ThreadMachCore.cpp

 //===-- ThreadMachCore.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ThreadMachCore.h"
 
 #include "lldb/Utility/SafeMachO.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
-#include "lldb/Core/State.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "ProcessMachCore.h"
 //#include "RegisterContextKDP_arm.h"
 //#include "RegisterContextKDP_i386.h"
 //#include "RegisterContextKDP_x86_64.h"
 
 using namespace lldb;

lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp

 #include "ProcessMinidump.h"
 #include "ThreadMinidump.h"
 
 // Other libraries and framework includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/State.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 // C includes
 // C++ includes
 

lldb/trunk/source/Plugins/Process/minidump/RegisterContextMinidump_ARM.cpp

 //===-- RegisterContextMinidump_ARM.cpp -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Project includes
 #include "RegisterContextMinidump_ARM.h"
 
 // Other libraries and framework includes
 #include "Utility/ARM_DWARF_Registers.h"
-#include "lldb/Core/RegisterValue.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/lldb-enumerations.h"
 
 // C includes
 #include <assert.h>
 
 // C++ includes

lldb/trunk/source/Plugins/Process/minidump/RegisterContextMinidump_ARM64.cpp

 //===-- RegisterContextMinidump_ARM64.cpp -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Project includes
 #include "RegisterContextMinidump_ARM64.h"
 
 // Other libraries and framework includes
 #include "Utility/ARM64_DWARF_Registers.h"
-#include "lldb/Core/RegisterValue.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/lldb-enumerations.h"
 
 // C includes
 #include <assert.h>
 
 // C++ includes
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 // Other libraries and framework includes
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/RegularExpression.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"

lldb/trunk/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h

 #ifndef liblldb_UnwindAssemblyInstEmulation_h_
 #define liblldb_UnwindAssemblyInstEmulation_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/EmulateInstruction.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/UnwindAssembly.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private.h"
 
 class UnwindAssemblyInstEmulation : public lldb_private::UnwindAssembly {
 public:
   ~UnwindAssemblyInstEmulation() override = default;
 
   bool GetNonCallSiteUnwindPlanFromAssembly(
       lldb_private::AddressRange &func, lldb_private::Thread &thread,

lldb/trunk/source/Symbol/ClangASTContext.cpp

 #include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VerifyDecl.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
+#include "lldb/Utility/Scalar.h"
 
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/PDB/PDBASTParser.h"
 
 #include <stdio.h>
 
 #include <mutex>
 

lldb/trunk/source/Symbol/CompilerType.cpp

 //===-- CompilerType.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/CompilerType.h"
 
 #include "lldb/Core/Debugger.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <iterator>
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/Symbol/Type.cpp

 //===-- Type.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <stdio.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Module.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"

lldb/trunk/source/Target/ExecutionContext.cpp

 //===-- ExecutionContext.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/ExecutionContext.h"
-#include "lldb/Core/State.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb_private;
 
 ExecutionContext::ExecutionContext()
     : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {}
 
 ExecutionContext::ExecutionContext(const ExecutionContext &rhs)
     : m_target_sp(rhs.m_target_sp), m_process_sp(rhs.m_process_sp),

lldb/trunk/source/Target/Memory.cpp

 //===-- Memory.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Memory.h"
 // C Includes
 #include <inttypes.h>
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/RangeMap.h"
-#include "lldb/Core/State.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // MemoryCache constructor
 //----------------------------------------------------------------------
 MemoryCache::MemoryCache(Process &process)

lldb/trunk/source/Target/Process.cpp

 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/IRDynamicChecks.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"

 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanBase.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/SelectHelper.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std::chrono;
 
 // Comment out line below to disable memory caching, overriding the process
 // setting target.process.disable-memory-cache
 #define ENABLE_MEMORY_CACHING

lldb/trunk/source/Target/RegisterContext.cpp

 //===-- RegisterContext.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContext::RegisterContext(Thread &thread, uint32_t concrete_frame_idx)
     : m_thread(thread), m_concrete_frame_idx(concrete_frame_idx),
       m_stop_id(thread.GetProcess()->GetStopID()) {}
 

lldb/trunk/source/Target/StackFrame.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegisterValue.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // The first bits in the flags are reserved for the SymbolContext::Scope bits
 // so we know if we have tried to look up information in our internal symbol
 // context (m_sc) already.
 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))

lldb/trunk/source/Target/Target.cpp

 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/SourceManager.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/REPL.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout;
 

lldb/trunk/source/Target/TargetList.cpp

 //===-- TargetList.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Project includes
 #include "lldb/Target/TargetList.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 #include "lldb/Utility/Timer.h"
 
 // Other libraries and framework includes
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;

lldb/trunk/source/Target/Thread.cpp

 // Project includes
 #include "lldb/Target/Thread.h"
 #include "Plugins/Process/Utility/UnwindLLDB.h"
 #include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"

 #include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
 #include "lldb/Target/ThreadPlanStepOverRange.h"
 #include "lldb/Target/ThreadPlanStepThrough.h"
 #include "lldb/Target/ThreadPlanStepUntil.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
+#include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const ThreadPropertiesSP &Thread::GetGlobalProperties() {

lldb/trunk/source/Target/ThreadList.cpp

 // C Includes
 #include <stdlib.h>
 
 // C++ Includes
 #include <algorithm>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/State.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 ThreadList::ThreadList(Process *process)
     : ThreadCollection(), m_process(process), m_stop_id(0),
       m_selected_tid(LLDB_INVALID_THREAD_ID) {}
 

lldb/trunk/source/Target/ThreadPlan.cpp

 //===-- ThreadPlan.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Core/Debugger.h"
-#include "lldb/Core/State.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // ThreadPlan constructor
 //----------------------------------------------------------------------
 ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,

lldb/trunk/source/Target/ThreadPlanPython.cpp

 //===-- ThreadPlanPython.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/ThreadPlan.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
-#include "lldb/Core/State.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanPython.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // ThreadPlanPython
 //----------------------------------------------------------------------
 

lldb/trunk/source/Target/ThreadPlanTracer.cpp

 // C Includes
 // C++ Includes
 #include <cstring>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark ThreadPlanTracer
 
 ThreadPlanTracer::ThreadPlanTracer(Thread &thread, lldb::StreamSP &stream_sp)
     : m_thread(thread), m_single_step(true), m_enabled(false),

lldb/trunk/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   FileSpec.cpp
   IOObject.cpp
   JSON.cpp
   LLDBAssert.cpp
   Log.cpp
   Logging.cpp
   NameMatches.cpp
   Range.cpp
+  RegisterValue.cpp
   RegularExpression.cpp
+  Scalar.cpp
   SelectHelper.cpp
   SharingPtr.cpp
+  State.cpp
   Status.cpp
   Stream.cpp
   StreamCallback.cpp
   StreamGDBRemote.cpp
   StreamString.cpp
   StringExtractor.cpp
   StringExtractorGDBRemote.cpp
   StringLexer.cpp

lldb/trunk/source/Utility/RegisterValue.cpp

+//===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/RegisterValue.h"
+
+#include "lldb/Utility/Args.h"
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StreamString.h"
+#include "lldb/lldb-defines.h"       // for LLDB_INVALID_ADDRESS
+#include "lldb/lldb-private-types.h" // for RegisterInfo, type128
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <cstdint> // for uint8_t, uint32_t, uint64_t
+#include <string>  // for string
+#include <tuple>   // for tie, tuple
+#include <vector>
+
+#include <assert.h>   // for assert
+#include <inttypes.h> // for PRIx64
+#include <stdio.h>    // for sscanf
+
+using namespace lldb;
+using namespace lldb_private;
+
+bool RegisterValue::GetData(DataExtractor &data) const {
+  return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
+}
+
+uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
+                                        uint32_t dst_len,
+                                        lldb::ByteOrder dst_byte_order,
+                                        Status &error) const {
+  if (reg_info == nullptr) {
+    error.SetErrorString("invalid register info argument.");
+    return 0;
+  }
+
+  // ReadRegister should have already been called on this object prior to
+  // calling this.
+  if (GetType() == eTypeInvalid) {
+    // No value has been read into this object...
+    error.SetErrorStringWithFormat(
+        "invalid register value type for register %s", reg_info->name);
+    return 0;
+  }
+
+  if (dst_len > kMaxRegisterByteSize) {
+    error.SetErrorString("destination is too big");
+    return 0;
+  }
+
+  const uint32_t src_len = reg_info->byte_size;
+
+  // Extract the register data into a data extractor
+  DataExtractor reg_data;
+  if (!GetData(reg_data)) {
+    error.SetErrorString("invalid register value to copy into");
+    return 0;
+  }
+
+  // Prepare a memory buffer that contains some or all of the register value
+  const uint32_t bytes_copied =
+      reg_data.CopyByteOrderedData(0,               // src offset
+                                   src_len,         // src length
+                                   dst,             // dst buffer
+                                   dst_len,         // dst length
+                                   dst_byte_order); // dst byte order
+  if (bytes_copied == 0)
+    error.SetErrorStringWithFormat(
+        "failed to copy data for register write of %s", reg_info->name);
+
+  return bytes_copied;
+}
+
+uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo *reg_info,
+                                          const void *src, uint32_t src_len,
+                                          lldb::ByteOrder src_byte_order,
+                                          Status &error) {
+  if (reg_info == nullptr) {
+    error.SetErrorString("invalid register info argument.");
+    return 0;
+  }
+
+  // Moving from addr into a register
+  //
+  // Case 1: src_len == dst_len
+  //
+  //   |AABBCCDD| Address contents
+  //   |AABBCCDD| Register contents
+  //
+  // Case 2: src_len > dst_len
+  //
+  //   Status!  (The register should always be big enough to hold the data)
+  //
+  // Case 3: src_len < dst_len
+  //
+  //   |AABB| Address contents
+  //   |AABB0000| Register contents [on little-endian hardware]
+  //   |0000AABB| Register contents [on big-endian hardware]
+  if (src_len > kMaxRegisterByteSize) {
+    error.SetErrorStringWithFormat(
+        "register buffer is too small to receive %u bytes of data.", src_len);
+    return 0;
+  }
+
+  const uint32_t dst_len = reg_info->byte_size;
+
+  if (src_len > dst_len) {
+    error.SetErrorStringWithFormat(
+        "%u bytes is too big to store in register %s (%u bytes)", src_len,
+        reg_info->name, dst_len);
+    return 0;
+  }
+
+  // Use a data extractor to correctly copy and pad the bytes read into the
+  // register value
+  DataExtractor src_data(src, src_len, src_byte_order, 4);
+
+  error = SetValueFromData(reg_info, src_data, 0, true);
+  if (error.Fail())
+    return 0;
+
+  // If SetValueFromData succeeded, we must have copied all of src_len
+  return src_len;
+}
+
+bool RegisterValue::GetScalarValue(Scalar &scalar) const {
+  switch (m_type) {
+  case eTypeInvalid:
+    break;
+  case eTypeBytes: {
+    switch (buffer.length) {
+    default:
+      break;
+    case 1:
+      scalar = *(const uint8_t *)buffer.bytes;
+      return true;
+    case 2:
+      scalar = *(const uint16_t *)buffer.bytes;
+      return true;
+    case 4:
+      scalar = *(const uint32_t *)buffer.bytes;
+      return true;
+    case 8:
+      scalar = *(const uint64_t *)buffer.bytes;
+      return true;
+    case 16:
+    case 32:
+      if (buffer.length % sizeof(uint64_t) == 0) {
+        const auto length_in_bits = buffer.length * 8;
+        const auto length_in_uint64 = buffer.length / sizeof(uint64_t);
+        scalar =
+            llvm::APInt(length_in_bits,
+                        llvm::ArrayRef<uint64_t>((const uint64_t *)buffer.bytes,
+                                                 length_in_uint64));
+        return true;
+      }
+      break;
+    }
+  } break;
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    scalar = m_scalar;
+    return true;
+  }
+  return false;
+}
+
+void RegisterValue::Clear() { m_type = eTypeInvalid; }
+
+RegisterValue::Type RegisterValue::SetType(const RegisterInfo *reg_info) {
+  // To change the type, we simply copy the data in again, using the new format
+  RegisterValue copy;
+  DataExtractor copy_data;
+  if (copy.CopyValue(*this) && copy.GetData(copy_data))
+    SetValueFromData(reg_info, copy_data, 0, true);
+
+  return m_type;
+}
+
+Status RegisterValue::SetValueFromData(const RegisterInfo *reg_info,
+                                       DataExtractor &src,
+                                       lldb::offset_t src_offset,
+                                       bool partial_data_ok) {
+  Status error;
+
+  if (src.GetByteSize() == 0) {
+    error.SetErrorString("empty data.");
+    return error;
+  }
+
+  if (reg_info->byte_size == 0) {
+    error.SetErrorString("invalid register info.");
+    return error;
+  }
+
+  uint32_t src_len = src.GetByteSize() - src_offset;
+
+  if (!partial_data_ok && (src_len < reg_info->byte_size)) {
+    error.SetErrorString("not enough data.");
+    return error;
+  }
+
+  // Cap the data length if there is more than enough bytes for this register
+  // value
+  if (src_len > reg_info->byte_size)
+    src_len = reg_info->byte_size;
+
+  // Zero out the value in case we get partial data...
+  memset(buffer.bytes, 0, sizeof(buffer.bytes));
+
+  type128 int128;
+
+  m_type = eTypeInvalid;
+  switch (reg_info->encoding) {
+  case eEncodingInvalid:
+    break;
+  case eEncodingUint:
+  case eEncodingSint:
+    if (reg_info->byte_size == 1)
+      SetUInt8(src.GetMaxU32(&src_offset, src_len));
+    else if (reg_info->byte_size <= 2)
+      SetUInt16(src.GetMaxU32(&src_offset, src_len));
+    else if (reg_info->byte_size <= 4)
+      SetUInt32(src.GetMaxU32(&src_offset, src_len));
+    else if (reg_info->byte_size <= 8)
+      SetUInt64(src.GetMaxU64(&src_offset, src_len));
+    else if (reg_info->byte_size <= 16) {
+      uint64_t data1 = src.GetU64(&src_offset);
+      uint64_t data2 = src.GetU64(&src_offset);
+      if (src.GetByteSize() == eByteOrderBig) {
+        int128.x[0] = data1;
+        int128.x[1] = data2;
+      } else {
+        int128.x[0] = data2;
+        int128.x[1] = data1;
+      }
+      SetUInt128(llvm::APInt(128, 2, int128.x));
+    }
+    break;
+  case eEncodingIEEE754:
+    if (reg_info->byte_size == sizeof(float))
+      SetFloat(src.GetFloat(&src_offset));
+    else if (reg_info->byte_size == sizeof(double))
+      SetDouble(src.GetDouble(&src_offset));
+    else if (reg_info->byte_size == sizeof(long double))
+      SetLongDouble(src.GetLongDouble(&src_offset));
+    break;
+  case eEncodingVector: {
+    m_type = eTypeBytes;
+    buffer.length = reg_info->byte_size;
+    buffer.byte_order = src.GetByteOrder();
+    assert(buffer.length <= kMaxRegisterByteSize);
+    if (buffer.length > kMaxRegisterByteSize)
+      buffer.length = kMaxRegisterByteSize;
+    if (src.CopyByteOrderedData(
+            src_offset,    // offset within "src" to start extracting data
+            src_len,       // src length
+            buffer.bytes,  // dst buffer
+            buffer.length, // dst length
+            buffer.byte_order) == 0) // dst byte order
+    {
+      error.SetErrorStringWithFormat(
+          "failed to copy data for register write of %s", reg_info->name);
+      return error;
+    }
+  }
+  }
+
+  if (m_type == eTypeInvalid)
+    error.SetErrorStringWithFormat(
+        "invalid register value type for register %s", reg_info->name);
+  return error;
+}
+
+// Helper function for RegisterValue::SetValueFromString()
+static bool ParseVectorEncoding(const RegisterInfo *reg_info,
+                                llvm::StringRef vector_str,
+                                const uint32_t byte_size,
+                                RegisterValue *reg_value) {
+  // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a
+  // 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
+  vector_str = vector_str.trim();
+  vector_str.consume_front("{");
+  vector_str.consume_back("}");
+  vector_str = vector_str.trim();
+
+  char Sep = ' ';
+
+  // The first split should give us:
+  // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f
+  // 0x2a 0x3e').
+  llvm::StringRef car;
+  llvm::StringRef cdr = vector_str;
+  std::tie(car, cdr) = vector_str.split(Sep);
+  std::vector<uint8_t> bytes;
+  unsigned byte = 0;
+
+  // Using radix auto-sensing by passing 0 as the radix. Keep on processing the
+  // vector elements as long as the parsing succeeds and the vector size is <
+  // byte_size.
+  while (!car.getAsInteger(0, byte) && bytes.size() < byte_size) {
+    bytes.push_back(byte);
+    std::tie(car, cdr) = cdr.split(Sep);
+  }
+
+  // Check for vector of exact byte_size elements.
+  if (bytes.size() != byte_size)
+    return false;
+
+  reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
+  return true;
+}
+
+Status RegisterValue::SetValueFromString(const RegisterInfo *reg_info,
+                                         llvm::StringRef value_str) {
+  Status error;
+  if (reg_info == nullptr) {
+    error.SetErrorString("Invalid register info argument.");
+    return error;
+  }
+
+  m_type = eTypeInvalid;
+  if (value_str.empty()) {
+    error.SetErrorString("Invalid c-string value string.");
+    return error;
+  }
+  const uint32_t byte_size = reg_info->byte_size;
+
+  uint64_t uval64;
+  int64_t ival64;
+  float flt_val;
+  double dbl_val;
+  long double ldbl_val;
+  switch (reg_info->encoding) {
+  case eEncodingInvalid:
+    error.SetErrorString("Invalid encoding.");
+    break;
+
+  case eEncodingUint:
+    if (byte_size > sizeof(uint64_t)) {
+      error.SetErrorStringWithFormat(
+          "unsupported unsigned integer byte size: %u", byte_size);
+      break;
+    }
+    if (value_str.getAsInteger(0, uval64)) {
+      error.SetErrorStringWithFormat(
+          "'%s' is not a valid unsigned integer string value",
+          value_str.str().c_str());
+      break;
+    }
+
+    if (!Args::UInt64ValueIsValidForByteSize(uval64, byte_size)) {
+      error.SetErrorStringWithFormat(
+          "value 0x%" PRIx64
+          " is too large to fit in a %u byte unsigned integer value",
+          uval64, byte_size);
+      break;
+    }
+
+    if (!SetUInt(uval64, reg_info->byte_size)) {
+      error.SetErrorStringWithFormat(
+          "unsupported unsigned integer byte size: %u", byte_size);
+      break;
+    }
+    // TODO: Shouldn't we be setting m_type here?
+    break;
+
+  case eEncodingSint:
+    if (byte_size > sizeof(long long)) {
+      error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
+                                     byte_size);
+      break;
+    }
+
+    if (value_str.getAsInteger(0, ival64)) {
+      error.SetErrorStringWithFormat(
+          "'%s' is not a valid signed integer string value",
+          value_str.str().c_str());
+      break;
+    }
+
+    if (!Args::SInt64ValueIsValidForByteSize(ival64, byte_size)) {
+      error.SetErrorStringWithFormat(
+          "value 0x%" PRIx64
+          " is too large to fit in a %u byte signed integer value",
+          ival64, byte_size);
+      break;
+    }
+
+    if (!SetUInt(ival64, reg_info->byte_size)) {
+      error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
+                                     byte_size);
+      break;
+    }
+
+    // TODO: Shouldn't we be setting m_type here?
+    break;
+
+  case eEncodingIEEE754: {
+    std::string value_string = value_str;
+    if (byte_size == sizeof(float)) {
+      if (::sscanf(value_string.c_str(), "%f", &flt_val) != 1) {
+        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
+                                       value_string.c_str());
+        break;
+      }
+      m_scalar = flt_val;
+      m_type = eTypeFloat;
+    } else if (byte_size == sizeof(double)) {
+      if (::sscanf(value_string.c_str(), "%lf", &dbl_val) != 1) {
+        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
+                                       value_string.c_str());
+        break;
+      }
+      m_scalar = dbl_val;
+      m_type = eTypeDouble;
+    } else if (byte_size == sizeof(long double)) {
+      if (::sscanf(value_string.c_str(), "%Lf", &ldbl_val) != 1) {
+        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
+                                       value_string.c_str());
+        break;
+      }
+      m_scalar = ldbl_val;
+      m_type = eTypeLongDouble;
+    } else {
+      error.SetErrorStringWithFormat("unsupported float byte size: %u",
+                                     byte_size);
+      return error;
+    }
+    break;
+  }
+  case eEncodingVector:
+    if (!ParseVectorEncoding(reg_info, value_str, byte_size, this))
+      error.SetErrorString("unrecognized vector encoding string value.");
+    break;
+  }
+
+  return error;
+}
+
+bool RegisterValue::SignExtend(uint32_t sign_bitpos) {
+  switch (m_type) {
+  case eTypeInvalid:
+    break;
+
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+    return m_scalar.SignExtend(sign_bitpos);
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+  case eTypeBytes:
+    break;
+  }
+  return false;
+}
+
+bool RegisterValue::CopyValue(const RegisterValue &rhs) {
+  if (this == &rhs)
+    return rhs.m_type == eTypeInvalid ? false : true;
+
+  m_type = rhs.m_type;
+  switch (m_type) {
+  case eTypeInvalid:
+    return false;
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    m_scalar = rhs.m_scalar;
+    break;
+  case eTypeBytes:
+    assert(rhs.buffer.length <= kMaxRegisterByteSize);
+    ::memcpy(buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize);
+    buffer.length = rhs.buffer.length;
+    buffer.byte_order = rhs.buffer.byte_order;
+    break;
+  }
+  return true;
+}
+
+uint16_t RegisterValue::GetAsUInt16(uint16_t fail_value,
+                                    bool *success_ptr) const {
+  if (success_ptr)
+    *success_ptr = true;
+
+  switch (m_type) {
+  default:
+    break;
+  case eTypeUInt8:
+  case eTypeUInt16:
+    return m_scalar.UShort(fail_value);
+  case eTypeBytes: {
+    switch (buffer.length) {
+    default:
+      break;
+    case 1:
+    case 2:
+      return *(const uint16_t *)buffer.bytes;
+    }
+  } break;
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+uint32_t RegisterValue::GetAsUInt32(uint32_t fail_value,
+                                    bool *success_ptr) const {
+  if (success_ptr)
+    *success_ptr = true;
+  switch (m_type) {
+  default:
+    break;
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.UInt(fail_value);
+  case eTypeBytes: {
+    switch (buffer.length) {
+    default:
+      break;
+    case 1:
+    case 2:
+    case 4:
+      return *(const uint32_t *)buffer.bytes;
+    }
+  } break;
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+uint64_t RegisterValue::GetAsUInt64(uint64_t fail_value,
+                                    bool *success_ptr) const {
+  if (success_ptr)
+    *success_ptr = true;
+  switch (m_type) {
+  default:
+    break;
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.ULongLong(fail_value);
+  case eTypeBytes: {
+    switch (buffer.length) {
+    default:
+      break;
+    case 1:
+      return *(const uint8_t *)buffer.bytes;
+    case 2:
+      return *(const uint16_t *)buffer.bytes;
+    case 4:
+      return *(const uint32_t *)buffer.bytes;
+    case 8:
+      return *(const uint64_t *)buffer.bytes;
+    }
+  } break;
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+llvm::APInt RegisterValue::GetAsUInt128(const llvm::APInt &fail_value,
+                                        bool *success_ptr) const {
+  if (success_ptr)
+    *success_ptr = true;
+  switch (m_type) {
+  default:
+    break;
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.UInt128(fail_value);
+  case eTypeBytes: {
+    switch (buffer.length) {
+    default:
+      break;
+    case 1:
+    case 2:
+    case 4:
+    case 8:
+    case 16:
+      return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+                         ((const type128 *)buffer.bytes)->x);
+    }
+  } break;
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+float RegisterValue::GetAsFloat(float fail_value, bool *success_ptr) const {
+  if (success_ptr)
+    *success_ptr = true;
+  switch (m_type) {
+  default:
+    break;
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.Float(fail_value);
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+double RegisterValue::GetAsDouble(double fail_value, bool *success_ptr) const {
+  if (success_ptr)
+    *success_ptr = true;
+  switch (m_type) {
+  default:
+    break;
+
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.Double(fail_value);
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+long double RegisterValue::GetAsLongDouble(long double fail_value,
+                                           bool *success_ptr) const {
+  if (success_ptr)
+    *success_ptr = true;
+  switch (m_type) {
+  default:
+    break;
+
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.LongDouble();
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+const void *RegisterValue::GetBytes() const {
+  switch (m_type) {
+  case eTypeInvalid:
+    break;
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.GetBytes();
+  case eTypeBytes:
+    return buffer.bytes;
+  }
+  return nullptr;
+}
+
+uint32_t RegisterValue::GetByteSize() const {
+  switch (m_type) {
+  case eTypeInvalid:
+    break;
+  case eTypeUInt8:
+    return 1;
+  case eTypeUInt16:
+    return 2;
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar.GetByteSize();
+  case eTypeBytes:
+    return buffer.length;
+  }
+  return 0;
+}
+
+bool RegisterValue::SetUInt(uint64_t uint, uint32_t byte_size) {
+  if (byte_size == 0) {
+    SetUInt64(uint);
+  } else if (byte_size == 1) {
+    SetUInt8(uint);
+  } else if (byte_size <= 2) {
+    SetUInt16(uint);
+  } else if (byte_size <= 4) {
+    SetUInt32(uint);
+  } else if (byte_size <= 8) {
+    SetUInt64(uint);
+  } else if (byte_size <= 16) {
+    SetUInt128(llvm::APInt(128, uint));
+  } else
+    return false;
+  return true;
+}
+
+void RegisterValue::SetBytes(const void *bytes, size_t length,
+                             lldb::ByteOrder byte_order) {
+  // If this assertion fires off we need to increase the size of buffer.bytes,
+  // or make it something that is allocated on the heap. Since the data buffer
+  // is in a union, we can't make it a collection class like SmallVector...
+  if (bytes && length > 0) {
+    assert(length <= sizeof(buffer.bytes) &&
+           "Storing too many bytes in a RegisterValue.");
+    m_type = eTypeBytes;
+    buffer.length = length;
+    memcpy(buffer.bytes, bytes, length);
+    buffer.byte_order = byte_order;
+  } else {
+    m_type = eTypeInvalid;
+    buffer.length = 0;
+  }
+}
+
+bool RegisterValue::operator==(const RegisterValue &rhs) const {
+  if (m_type == rhs.m_type) {
+    switch (m_type) {
+    case eTypeInvalid:
+      return true;
+    case eTypeUInt8:
+    case eTypeUInt16:
+    case eTypeUInt32:
+    case eTypeUInt64:
+    case eTypeUInt128:
+    case eTypeFloat:
+    case eTypeDouble:
+    case eTypeLongDouble:
+      return m_scalar == rhs.m_scalar;
+    case eTypeBytes:
+      if (buffer.length != rhs.buffer.length)
+        return false;
+      else {
+        uint8_t length = buffer.length;
+        if (length > kMaxRegisterByteSize)
+          length = kMaxRegisterByteSize;
+        return memcmp(buffer.bytes, rhs.buffer.bytes, length) == 0;
+      }
+      break;
+    }
+  }
+  return false;
+}
+
+bool RegisterValue::operator!=(const RegisterValue &rhs) const {
+  if (m_type != rhs.m_type)
+    return true;
+  switch (m_type) {
+  case eTypeInvalid:
+    return false;
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    return m_scalar != rhs.m_scalar;
+  case eTypeBytes:
+    if (buffer.length != rhs.buffer.length) {
+      return true;
+    } else {
+      uint8_t length = buffer.length;
+      if (length > kMaxRegisterByteSize)
+        length = kMaxRegisterByteSize;
+      return memcmp(buffer.bytes, rhs.buffer.bytes, length) != 0;
+    }
+    break;
+  }
+  return true;
+}
+
+bool RegisterValue::ClearBit(uint32_t bit) {
+  switch (m_type) {
+  case eTypeInvalid:
+    break;
+
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+    if (bit < (GetByteSize() * 8)) {
+      return m_scalar.ClearBit(bit);
+    }
+    break;
+
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    break;
+
+  case eTypeBytes:
+    if (buffer.byte_order == eByteOrderBig ||
+        buffer.byte_order == eByteOrderLittle) {
+      uint32_t byte_idx;
+      if (buffer.byte_order == eByteOrderBig)
+        byte_idx = buffer.length - (bit / 8) - 1;
+      else
+        byte_idx = bit / 8;
+
+      const uint32_t byte_bit = bit % 8;
+      if (byte_idx < buffer.length) {
+        buffer.bytes[byte_idx] &= ~(1u << byte_bit);
+        return true;
+      }
+    }
+    break;
+  }
+  return false;
+}
+
+bool RegisterValue::SetBit(uint32_t bit) {
+  switch (m_type) {
+  case eTypeInvalid:
+    break;
+
+  case eTypeUInt8:
+  case eTypeUInt16:
+  case eTypeUInt32:
+  case eTypeUInt64:
+  case eTypeUInt128:
+    if (bit < (GetByteSize() * 8)) {
+      return m_scalar.SetBit(bit);
+    }
+    break;
+
+  case eTypeFloat:
+  case eTypeDouble:
+  case eTypeLongDouble:
+    break;
+
+  case eTypeBytes:
+    if (buffer.byte_order == eByteOrderBig ||
+        buffer.byte_order == eByteOrderLittle) {
+      uint32_t byte_idx;
+      if (buffer.byte_order == eByteOrderBig)
+        byte_idx = buffer.length - (bit / 8) - 1;
+      else
+        byte_idx = bit / 8;
+
+      const uint32_t byte_bit = bit % 8;
+      if (byte_idx < buffer.length) {
+        buffer.bytes[byte_idx] |= (1u << byte_bit);
+        return true;
+      }
+    }
+    break;
+  }
+  return false;
+}

lldb/trunk/source/Utility/Scalar.cpp

+//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/Scalar.h"
+
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/lldb-types.h" // for offset_t
+
+#include "llvm/ADT/SmallString.h"
+
+#include <cinttypes>
+#include <cstdio>
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// Promote to max type currently follows the ANSI C rule for type promotion in
+// expressions.
+//----------------------------------------------------------------------
+static Scalar::Type PromoteToMaxType(
+    const Scalar &lhs,  // The const left hand side object
+    const Scalar &rhs,  // The const right hand side object
+    Scalar &temp_value, // A modifiable temp value than can be used to hold
+                        // either the promoted lhs or rhs object
+    const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
+                                     // promoted value of lhs (at most one of
+                                     // lhs/rhs will get promoted)
+    const Scalar *&promoted_rhs_ptr  // Pointer to the resulting possibly
+                                     // promoted value of rhs (at most one of
+                                     // lhs/rhs will get promoted)
+) {
+  Scalar result;
+  // Initialize the promoted values for both the right and left hand side
+  // values to be the objects themselves. If no promotion is needed (both right
+  // and left have the same type), then the temp_value will not get used.
+  promoted_lhs_ptr = &lhs;
+  promoted_rhs_ptr = &rhs;
+  // Extract the types of both the right and left hand side values
+  Scalar::Type lhs_type = lhs.GetType();
+  Scalar::Type rhs_type = rhs.GetType();
+
+  if (lhs_type > rhs_type) {
+    // Right hand side need to be promoted
+    temp_value = rhs; // Copy right hand side into the temp value
+    if (temp_value.Promote(lhs_type)) // Promote it
+      promoted_rhs_ptr =
+          &temp_value; // Update the pointer for the promoted right hand side
+  } else if (lhs_type < rhs_type) {
+    // Left hand side need to be promoted
+    temp_value = lhs; // Copy left hand side value into the temp value
+    if (temp_value.Promote(rhs_type)) // Promote it
+      promoted_lhs_ptr =
+          &temp_value; // Update the pointer for the promoted left hand side
+  }
+
+  // Make sure our type promotion worked as expected
+  if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
+    return promoted_lhs_ptr->GetType(); // Return the resulting max type
+
+  // Return the void type (zero) if we fail to promote either of the values.
+  return Scalar::e_void;
+}
+
+Scalar::Scalar() : m_type(e_void), m_float((float)0) {}
+
+Scalar::Scalar(const Scalar &rhs)
+    : m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}
+
+// Scalar::Scalar(const RegisterValue& reg) :
+//  m_type(e_void),
+//  m_data()
+//{
+//  switch (reg.info.encoding)
+//  {
+//  case eEncodingUint:     // unsigned integer
+//      switch (reg.info.byte_size)
+//      {
+//      case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
+//      case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
+//      case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
+//      case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64;
+//      break;
+//      break;
+//      }
+//      break;
+//
+//  case eEncodingSint:     // signed integer
+//      switch (reg.info.byte_size)
+//      {
+//      case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
+//      case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
+//      case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
+//      case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64;
+//      break;
+//      break;
+//      }
+//      break;
+//
+//  case eEncodingIEEE754:  // float
+//      switch (reg.info.byte_size)
+//      {
+//      case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
+//      case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
+//      break;
+//      }
+//      break;
+//    case eEncodingVector: // vector registers
+//      break;
+//  }
+//}
+
+bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
+  size_t byte_size = GetByteSize();
+  if (byte_size > 0) {
+    const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
+
+    if (limit_byte_size < byte_size) {
+      if (endian::InlHostByteOrder() == eByteOrderLittle) {
+        // On little endian systems if we want fewer bytes from the current
+        // type we just specify fewer bytes since the LSByte is first...
+        byte_size = limit_byte_size;
+      } else if (endian::InlHostByteOrder() == eByteOrderBig) {
+        // On big endian systems if we want fewer bytes from the current type
+        // have to advance our initial byte pointer and trim down the number of
+        // bytes since the MSByte is first
+        bytes += byte_size - limit_byte_size;
+        byte_size = limit_byte_size;
+      }
+    }
+
+    data.SetData(bytes, byte_size, endian::InlHostByteOrder());
+    return true;
+  }
+  data.Clear();
+  return false;
+}
+
+const void *Scalar::GetBytes() const {
+  const uint64_t *apint_words;
+  const uint8_t *bytes;
+  static float_t flt_val;
+  static double_t dbl_val;
+  static uint64_t swapped_words[4];
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+    bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
+    // getRawData always returns a pointer to an uint64_t.  If we have a
+    // smaller type, we need to update the pointer on big-endian systems.
+    if (endian::InlHostByteOrder() == eByteOrderBig) {
+      size_t byte_size = m_integer.getBitWidth() / 8;
+      if (byte_size < 8)
+        bytes += 8 - byte_size;
+    }
+    return bytes;
+  case e_sint128:
+  case e_uint128:
+    apint_words = m_integer.getRawData();
+    // getRawData always returns a pointer to an array of two uint64_t values,
+    // where the least-significant word always comes first.  On big-endian
+    // systems we need to swap the two words.
+    if (endian::InlHostByteOrder() == eByteOrderBig) {
+      swapped_words[0] = apint_words[1];
+      swapped_words[1] = apint_words[0];
+      apint_words = swapped_words;
+    }
+    return reinterpret_cast<const void *>(apint_words);
+  case e_sint256:
+  case e_uint256:
+    apint_words = m_integer.getRawData();
+    // getRawData always returns a pointer to an array of four uint64_t values,
+    // where the least-significant word always comes first.  On big-endian
+    // systems we need to swap the four words.
+    if (endian::InlHostByteOrder() == eByteOrderBig) {
+      swapped_words[0] = apint_words[3];
+      swapped_words[1] = apint_words[2];
+      swapped_words[2] = apint_words[1];
+      swapped_words[3] = apint_words[0];
+      apint_words = swapped_words;
+    }
+    return reinterpret_cast<const void *>(apint_words);
+  case e_float:
+    flt_val = m_float.convertToFloat();
+    return reinterpret_cast<const void *>(&flt_val);
+  case e_double:
+    dbl_val = m_float.convertToDouble();
+    return reinterpret_cast<const void *>(&dbl_val);
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    apint_words = ldbl_val.getRawData();
+    // getRawData always returns a pointer to an array of two uint64_t values,
+    // where the least-significant word always comes first.  On big-endian
+    // systems we need to swap the two words.
+    if (endian::InlHostByteOrder() == eByteOrderBig) {
+      swapped_words[0] = apint_words[1];
+      swapped_words[1] = apint_words[0];
+      apint_words = swapped_words;
+    }
+    return reinterpret_cast<const void *>(apint_words);
+  }
+  return nullptr;
+}
+
+size_t Scalar::GetByteSize() const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (m_integer.getBitWidth() / 8);
+  case e_float:
+    return sizeof(float_t);
+  case e_double:
+    return sizeof(double_t);
+  case e_long_double:
+    return sizeof(long_double_t);
+  }
+  return 0;
+}
+
+bool Scalar::IsZero() const {
+  llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return llvm::APInt::isSameValue(zero_int, m_integer);
+  case e_float:
+  case e_double:
+  case e_long_double:
+    return m_float.isZero();
+  }
+  return false;
+}
+
+void Scalar::GetValue(Stream *s, bool show_type) const {
+  if (show_type)
+    s->Printf("(%s) ", GetTypeAsCString());
+
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_slong:
+  case e_slonglong:
+  case e_sint128:
+  case e_sint256:
+    s->PutCString(m_integer.toString(10, true));
+    break;
+  case e_uint:
+  case e_ulong:
+  case e_ulonglong:
+  case e_uint128:
+  case e_uint256:
+    s->PutCString(m_integer.toString(10, false));
+    break;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    llvm::SmallString<24> string;
+    m_float.toString(string);
+    s->Printf("%s", string.c_str());
+    break;
+  }
+}
+
+const char *Scalar::GetTypeAsCString() const {
+  switch (m_type) {
+  case e_void:
+    return "void";
+  case e_sint:
+    return "int";
+  case e_uint:
+    return "unsigned int";
+  case e_slong:
+    return "long";
+  case e_ulong:
+    return "unsigned long";
+  case e_slonglong:
+    return "long long";
+  case e_ulonglong:
+    return "unsigned long long";
+  case e_sint128:
+    return "int128_t";
+  case e_uint128:
+    return "unsigned int128_t";
+  case e_sint256:
+    return "int256_t";
+  case e_uint256:
+    return "unsigned int256_t";
+  case e_float:
+    return "float";
+  case e_double:
+    return "double";
+  case e_long_double:
+    return "long double";
+  }
+  return "<invalid Scalar type>";
+}
+
+Scalar &Scalar::operator=(const Scalar &rhs) {
+  if (this != &rhs) {
+    m_type = rhs.m_type;
+    m_integer = llvm::APInt(rhs.m_integer);
+    m_float = rhs.m_float;
+  }
+  return *this;
+}
+
+Scalar &Scalar::operator=(const int v) {
+  m_type = e_sint;
+  m_integer = llvm::APInt(sizeof(int) * 8, v, true);
+  return *this;
+}
+
+Scalar &Scalar::operator=(unsigned int v) {
+  m_type = e_uint;
+  m_integer = llvm::APInt(sizeof(int) * 8, v);
+  return *this;
+}
+
+Scalar &Scalar::operator=(long v) {
+  m_type = e_slong;
+  m_integer = llvm::APInt(sizeof(long) * 8, v, true);
+  return *this;
+}
+
+Scalar &Scalar::operator=(unsigned long v) {
+  m_type = e_ulong;
+  m_integer = llvm::APInt(sizeof(long) * 8, v);
+  return *this;
+}
+
+Scalar &Scalar::operator=(long long v) {
+  m_type = e_slonglong;
+  m_integer = llvm::APInt(sizeof(long) * 8, v, true);
+  return *this;
+}
+
+Scalar &Scalar::operator=(unsigned long long v) {
+  m_type = e_ulonglong;
+  m_integer = llvm::APInt(sizeof(long long) * 8, v);
+  return *this;
+}
+
+Scalar &Scalar::operator=(float v) {
+  m_type = e_float;
+  m_float = llvm::APFloat(v);
+  return *this;
+}
+
+Scalar &Scalar::operator=(double v) {
+  m_type = e_double;
+  m_float = llvm::APFloat(v);
+  return *this;
+}
+
+Scalar &Scalar::operator=(long double v) {
+  m_type = e_long_double;
+  if (m_ieee_quad)
+    m_float = llvm::APFloat(
+        llvm::APFloat::IEEEquad(),
+        llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
+  else
+    m_float = llvm::APFloat(
+        llvm::APFloat::x87DoubleExtended(),
+        llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
+  return *this;
+}
+
+Scalar &Scalar::operator=(llvm::APInt rhs) {
+  m_integer = llvm::APInt(rhs);
+  switch (m_integer.getBitWidth()) {
+  case 8:
+  case 16:
+  case 32:
+    if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
+      m_type = e_sint;
+    else
+      m_type = e_uint;
+    break;
+  case 64:
+    if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
+      m_type = e_slonglong;
+    else
+      m_type = e_ulonglong;
+    break;
+  case 128:
+    if (m_integer.isSignedIntN(BITWIDTH_INT128))
+      m_type = e_sint128;
+    else
+      m_type = e_uint128;
+    break;
+  case 256:
+    if (m_integer.isSignedIntN(BITWIDTH_INT256))
+      m_type = e_sint256;
+    else
+      m_type = e_uint256;
+    break;
+  }
+  return *this;
+}
+
+Scalar::~Scalar() = default;
+
+bool Scalar::Promote(Scalar::Type type) {
+  bool success = false;
+  switch (m_type) {
+  case e_void:
+    break;
+
+  case e_sint:
+    switch (type) {
+    case e_void:
+      break;
+    case e_sint:
+      success = true;
+      break;
+    case e_uint:
+      m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
+      success = true;
+      break;
+
+    case e_slong:
+      m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
+      success = true;
+      break;
+
+    case e_ulong:
+      m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
+      success = true;
+      break;
+
+    case e_slonglong:
+      m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_ulonglong:
+      m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_sint128:
+    case e_uint128:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+      success = true;
+      break;
+
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_uint:
+    switch (type) {
+    case e_void:
+    case e_sint:
+      break;
+    case e_uint:
+      success = true;
+      break;
+    case e_slong:
+      m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
+      success = true;
+      break;
+
+    case e_ulong:
+      m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
+      success = true;
+      break;
+
+    case e_slonglong:
+      m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_ulonglong:
+      m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_sint128:
+    case e_uint128:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+      success = true;
+      break;
+
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_slong:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+      break;
+    case e_slong:
+      success = true;
+      break;
+    case e_ulong:
+      m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
+      success = true;
+      break;
+
+    case e_slonglong:
+      m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_ulonglong:
+      m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_sint128:
+    case e_uint128:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+      success = true;
+      break;
+
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_ulong:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+      break;
+    case e_ulong:
+      success = true;
+      break;
+    case e_slonglong:
+      m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_ulonglong:
+      m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_sint128:
+    case e_uint128:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+      success = true;
+      break;
+
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_slonglong:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+      break;
+    case e_slonglong:
+      success = true;
+      break;
+    case e_ulonglong:
+      m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
+      success = true;
+      break;
+
+    case e_sint128:
+    case e_uint128:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+      success = true;
+      break;
+
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_ulonglong:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+      break;
+    case e_ulonglong:
+      success = true;
+      break;
+    case e_sint128:
+    case e_uint128:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+      success = true;
+      break;
+
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_sint128:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+      break;
+    case e_sint128:
+      success = true;
+      break;
+    case e_uint128:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+      success = true;
+      break;
+
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_uint128:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+      break;
+    case e_uint128:
+      success = true;
+      break;
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_sint256:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+      break;
+    case e_sint256:
+      success = true;
+      break;
+    case e_uint256:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+      success = true;
+      break;
+
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_uint256:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+      break;
+    case e_uint256:
+      success = true;
+      break;
+    case e_float:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_double:
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+
+    case e_long_double:
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                          : llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false,
+                               llvm::APFloat::rmNearestTiesToEven);
+      success = true;
+      break;
+    }
+    break;
+
+  case e_float:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+      break;
+    case e_float:
+      success = true;
+      break;
+    case e_double:
+      m_float = llvm::APFloat((double_t)m_float.convertToFloat());
+      success = true;
+      break;
+
+    case e_long_double: {
+      bool ignore;
+      m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                  : llvm::APFloat::x87DoubleExtended(),
+                      llvm::APFloat::rmNearestTiesToEven, &ignore);
+      success = true;
+      break;
+    }
+    }
+    break;
+
+  case e_double:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+    case e_float:
+      break;
+    case e_double:
+      success = true;
+      break;
+    case e_long_double: {
+      bool ignore;
+      m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
+                                  : llvm::APFloat::x87DoubleExtended(),
+                      llvm::APFloat::rmNearestTiesToEven, &ignore);
+      success = true;
+      break;
+    }
+    }
+    break;
+
+  case e_long_double:
+    switch (type) {
+    case e_void:
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+    case e_float:
+    case e_double:
+      break;
+    case e_long_double:
+      success = true;
+      break;
+    }
+    break;
+  }
+
+  if (success)
+    m_type = type;
+  return success;
+}
+
+const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
+  switch (type) {
+  case e_void:
+    return "void";
+  case e_sint:
+    return "int";
+  case e_uint:
+    return "unsigned int";
+  case e_slong:
+    return "long";
+  case e_ulong:
+    return "unsigned long";
+  case e_slonglong:
+    return "long long";
+  case e_ulonglong:
+    return "unsigned long long";
+  case e_float:
+    return "float";
+  case e_double:
+    return "double";
+  case e_long_double:
+    return "long double";
+  case e_sint128:
+    return "int128_t";
+  case e_uint128:
+    return "uint128_t";
+  case e_sint256:
+    return "int256_t";
+  case e_uint256:
+    return "uint256_t";
+  }
+  return "???";
+}
+
+Scalar::Type
+Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
+  if (byte_size <= sizeof(sint_t))
+    return e_sint;
+  if (byte_size <= sizeof(slong_t))
+    return e_slong;
+  if (byte_size <= sizeof(slonglong_t))
+    return e_slonglong;
+  return e_void;
+}
+
+Scalar::Type
+Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
+  if (byte_size <= sizeof(uint_t))
+    return e_uint;
+  if (byte_size <= sizeof(ulong_t))
+    return e_ulong;
+  if (byte_size <= sizeof(ulonglong_t))
+    return e_ulonglong;
+  return e_void;
+}
+
+Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
+  if (byte_size == sizeof(float_t))
+    return e_float;
+  if (byte_size == sizeof(double_t))
+    return e_double;
+  if (byte_size == sizeof(long_double_t))
+    return e_long_double;
+  return e_void;
+}
+
+bool Scalar::MakeSigned() {
+  bool success = false;
+
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+    success = true;
+    break;
+  case e_uint:
+    m_type = e_sint;
+    success = true;
+    break;
+  case e_slong:
+    success = true;
+    break;
+  case e_ulong:
+    m_type = e_slong;
+    success = true;
+    break;
+  case e_slonglong:
+    success = true;
+    break;
+  case e_ulonglong:
+    m_type = e_slonglong;
+    success = true;
+    break;
+  case e_sint128:
+    success = true;
+    break;
+  case e_uint128:
+    m_type = e_sint128;
+    success = true;
+    break;
+  case e_sint256:
+    success = true;
+    break;
+  case e_uint256:
+    m_type = e_sint256;
+    success = true;
+    break;
+  case e_float:
+    success = true;
+    break;
+  case e_double:
+    success = true;
+    break;
+  case e_long_double:
+    success = true;
+    break;
+  }
+
+  return success;
+}
+
+bool Scalar::MakeUnsigned() {
+  bool success = false;
+
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+    m_type = e_uint;
+    success = true;
+    break;
+  case e_uint:
+    success = true;
+    break;
+  case e_slong:
+    m_type = e_ulong;
+    success = true;
+    break;
+  case e_ulong:
+    success = true;
+    break;
+  case e_slonglong:
+    m_type = e_ulonglong;
+    success = true;
+    break;
+  case e_ulonglong:
+    success = true;
+    break;
+  case e_sint128:
+    m_type = e_uint128;
+    success = true;
+    break;
+  case e_uint128:
+    success = true;
+    break;
+  case e_sint256:
+    m_type = e_uint256;
+    success = true;
+    break;
+  case e_uint256:
+    success = true;
+    break;
+  case e_float:
+    success = true;
+    break;
+  case e_double:
+    success = true;
+    break;
+  case e_long_double:
+    success = true;
+    break;
+  }
+
+  return success;
+}
+
+signed char Scalar::SChar(char fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
+  case e_float:
+    return (schar_t)m_float.convertToFloat();
+  case e_double:
+    return (schar_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
+  }
+  return fail_value;
+}
+
+unsigned char Scalar::UChar(unsigned char fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
+  case e_float:
+    return (uchar_t)m_float.convertToFloat();
+  case e_double:
+    return (uchar_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
+  }
+  return fail_value;
+}
+
+short Scalar::SShort(short fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8))
+        .getSExtValue();
+  case e_float:
+    return (sshort_t)m_float.convertToFloat();
+  case e_double:
+    return (sshort_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8))
+        .getSExtValue();
+  }
+  return fail_value;
+}
+
+unsigned short Scalar::UShort(unsigned short fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8))
+        .getZExtValue();
+  case e_float:
+    return (ushort_t)m_float.convertToFloat();
+  case e_double:
+    return (ushort_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8))
+        .getZExtValue();
+  }
+  return fail_value;
+}
+
+int Scalar::SInt(int fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
+  case e_float:
+    return (sint_t)m_float.convertToFloat();
+  case e_double:
+    return (sint_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
+  }
+  return fail_value;
+}
+
+unsigned int Scalar::UInt(unsigned int fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
+  case e_float:
+    return (uint_t)m_float.convertToFloat();
+  case e_double:
+    return (uint_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
+  }
+  return fail_value;
+}
+
+long Scalar::SLong(long fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
+  case e_float:
+    return (slong_t)m_float.convertToFloat();
+  case e_double:
+    return (slong_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
+  }
+  return fail_value;
+}
+
+unsigned long Scalar::ULong(unsigned long fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
+  case e_float:
+    return (ulong_t)m_float.convertToFloat();
+  case e_double:
+    return (ulong_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
+  }
+  return fail_value;
+}
+
+long long Scalar::SLongLong(long long fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8))
+        .getSExtValue();
+  case e_float:
+    return (slonglong_t)m_float.convertToFloat();
+  case e_double:
+    return (slonglong_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8))
+        .getSExtValue();
+  }
+  return fail_value;
+}
+
+unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
+        .getZExtValue();
+  case e_float:
+    return (ulonglong_t)m_float.convertToFloat();
+  case e_double:
+    return (ulonglong_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8))
+        .getZExtValue();
+  }
+  return fail_value;
+}
+
+llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return m_integer;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    return m_float.bitcastToAPInt();
+  }
+  return fail_value;
+}
+
+llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return m_integer;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    return m_float.bitcastToAPInt();
+  }
+  return fail_value;
+}
+
+llvm::APInt Scalar::SInt256(llvm::APInt &fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return m_integer;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    return m_float.bitcastToAPInt();
+  }
+  return fail_value;
+}
+
+llvm::APInt Scalar::UInt256(const llvm::APInt &fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return m_integer;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    return m_float.bitcastToAPInt();
+  }
+  return fail_value;
+}
+
+float Scalar::Float(float fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return llvm::APIntOps::RoundAPIntToFloat(m_integer);
+  case e_float:
+    return m_float.convertToFloat();
+  case e_double:
+    return (float_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return ldbl_val.bitsToFloat();
+  }
+  return fail_value;
+}
+
+double Scalar::Double(double fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return llvm::APIntOps::RoundAPIntToDouble(m_integer);
+  case e_float:
+    return (double_t)m_float.convertToFloat();
+  case e_double:
+    return m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return ldbl_val.bitsToFloat();
+  }
+  return fail_value;
+}
+
+long double Scalar::LongDouble(long double fail_value) const {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
+  case e_float:
+    return (long_double_t)m_float.convertToFloat();
+  case e_double:
+    return (long_double_t)m_float.convertToDouble();
+  case e_long_double:
+    llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+    return (long_double_t)ldbl_val.bitsToDouble();
+  }
+  return fail_value;
+}
+
+Scalar &Scalar::operator+=(const Scalar &rhs) {
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (m_type) {
+    case e_void:
+      break;
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+      m_integer = a->m_integer + b->m_integer;
+      break;
+
+    case e_float:
+    case e_double:
+    case e_long_double:
+      m_float = a->m_float + b->m_float;
+      break;
+    }
+  }
+  return *this;
+}
+
+Scalar &Scalar::operator<<=(const Scalar &rhs) {
+  switch (m_type) {
+  case e_void:
+  case e_float:
+  case e_double:
+  case e_long_double:
+    m_type = e_void;
+    break;
+
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    switch (rhs.m_type) {
+    case e_void:
+    case e_float:
+    case e_double:
+    case e_long_double:
+      m_type = e_void;
+      break;
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer << rhs.m_integer;
+      break;
+    }
+    break;
+  }
+  return *this;
+}
+
+bool Scalar::ShiftRightLogical(const Scalar &rhs) {
+  switch (m_type) {
+  case e_void:
+  case e_float:
+  case e_double:
+  case e_long_double:
+    m_type = e_void;
+    break;
+
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    switch (rhs.m_type) {
+    case e_void:
+    case e_float:
+    case e_double:
+    case e_long_double:
+      m_type = e_void;
+      break;
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.lshr(rhs.m_integer);
+      break;
+    }
+    break;
+  }
+  return m_type != e_void;
+}
+
+Scalar &Scalar::operator>>=(const Scalar &rhs) {
+  switch (m_type) {
+  case e_void:
+  case e_float:
+  case e_double:
+  case e_long_double:
+    m_type = e_void;
+    break;
+
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    switch (rhs.m_type) {
+    case e_void:
+    case e_float:
+    case e_double:
+    case e_long_double:
+      m_type = e_void;
+      break;
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+      m_integer = m_integer.ashr(rhs.m_integer);
+      break;
+    }
+    break;
+  }
+  return *this;
+}
+
+Scalar &Scalar::operator&=(const Scalar &rhs) {
+  switch (m_type) {
+  case e_void:
+  case e_float:
+  case e_double:
+  case e_long_double:
+    m_type = e_void;
+    break;
+
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    switch (rhs.m_type) {
+    case e_void:
+    case e_float:
+    case e_double:
+    case e_long_double:
+      m_type = e_void;
+      break;
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+      m_integer &= rhs.m_integer;
+      break;
+    }
+    break;
+  }
+  return *this;
+}
+
+bool Scalar::AbsoluteValue() {
+  switch (m_type) {
+  case e_void:
+    break;
+
+  case e_sint:
+  case e_slong:
+  case e_slonglong:
+  case e_sint128:
+  case e_sint256:
+    if (m_integer.isNegative())
+      m_integer = -m_integer;
+    return true;
+
+  case e_uint:
+  case e_ulong:
+  case e_ulonglong:
+    return true;
+  case e_uint128:
+  case e_uint256:
+  case e_float:
+  case e_double:
+  case e_long_double:
+    m_float.clearSign();
+    return true;
+  }
+  return false;
+}
+
+bool Scalar::UnaryNegate() {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    m_integer = -m_integer;
+    return true;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    m_float.changeSign();
+    return true;
+  }
+  return false;
+}
+
+bool Scalar::OnesComplement() {
+  switch (m_type) {
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    m_integer = ~m_integer;
+    return true;
+
+  case e_void:
+  case e_float:
+  case e_double:
+  case e_long_double:
+    break;
+  }
+  return false;
+}
+
+const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    case Scalar::e_void:
+      break;
+    case Scalar::e_sint:
+    case Scalar::e_uint:
+    case Scalar::e_slong:
+    case Scalar::e_ulong:
+    case Scalar::e_slonglong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_uint128:
+    case Scalar::e_sint256:
+    case Scalar::e_uint256:
+      result.m_integer = a->m_integer + b->m_integer;
+      break;
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      result.m_float = a->m_float + b->m_float;
+      break;
+    }
+  }
+  return result;
+}
+
+const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    case Scalar::e_void:
+      break;
+    case Scalar::e_sint:
+    case Scalar::e_uint:
+    case Scalar::e_slong:
+    case Scalar::e_ulong:
+    case Scalar::e_slonglong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_uint128:
+    case Scalar::e_sint256:
+    case Scalar::e_uint256:
+      result.m_integer = a->m_integer - b->m_integer;
+      break;
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      result.m_float = a->m_float - b->m_float;
+      break;
+    }
+  }
+  return result;
+}
+
+const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    case Scalar::e_void:
+      break;
+    case Scalar::e_sint:
+    case Scalar::e_slong:
+    case Scalar::e_slonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_sint256:
+      if (b->m_integer != 0) {
+        result.m_integer = a->m_integer.sdiv(b->m_integer);
+        return result;
+      }
+      break;
+    case Scalar::e_uint:
+    case Scalar::e_ulong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_uint128:
+    case Scalar::e_uint256:
+      if (b->m_integer != 0) {
+        result.m_integer = a->m_integer.udiv(b->m_integer);
+        return result;
+      }
+      break;
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      if (!b->m_float.isZero()) {
+        result.m_float = a->m_float / b->m_float;
+        return result;
+      }
+      break;
+    }
+  }
+  // For division only, the only way it should make it here is if a promotion
+  // failed, or if we are trying to do a divide by zero.
+  result.m_type = Scalar::e_void;
+  return result;
+}
+
+const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    case Scalar::e_void:
+      break;
+    case Scalar::e_sint:
+    case Scalar::e_uint:
+    case Scalar::e_slong:
+    case Scalar::e_ulong:
+    case Scalar::e_slonglong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_uint128:
+    case Scalar::e_sint256:
+    case Scalar::e_uint256:
+      result.m_integer = a->m_integer * b->m_integer;
+      break;
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      result.m_float = a->m_float * b->m_float;
+      break;
+    }
+  }
+  return result;
+}
+
+const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    case Scalar::e_sint:
+    case Scalar::e_uint:
+    case Scalar::e_slong:
+    case Scalar::e_ulong:
+    case Scalar::e_slonglong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_uint128:
+    case Scalar::e_sint256:
+    case Scalar::e_uint256:
+      result.m_integer = a->m_integer & b->m_integer;
+      break;
+    case Scalar::e_void:
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      // No bitwise AND on floats, doubles of long doubles
+      result.m_type = Scalar::e_void;
+      break;
+    }
+  }
+  return result;
+}
+
+const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    case Scalar::e_sint:
+    case Scalar::e_uint:
+    case Scalar::e_slong:
+    case Scalar::e_ulong:
+    case Scalar::e_slonglong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_uint128:
+    case Scalar::e_sint256:
+    case Scalar::e_uint256:
+      result.m_integer = a->m_integer | b->m_integer;
+      break;
+
+    case Scalar::e_void:
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      // No bitwise AND on floats, doubles of long doubles
+      result.m_type = Scalar::e_void;
+      break;
+    }
+  }
+  return result;
+}
+
+const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    default:
+      break;
+    case Scalar::e_void:
+      break;
+    case Scalar::e_sint:
+    case Scalar::e_slong:
+    case Scalar::e_slonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_sint256:
+      if (b->m_integer != 0) {
+        result.m_integer = a->m_integer.srem(b->m_integer);
+        return result;
+      }
+      break;
+    case Scalar::e_uint:
+    case Scalar::e_ulong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_uint128:
+    case Scalar::e_uint256:
+      if (b->m_integer != 0) {
+        result.m_integer = a->m_integer.urem(b->m_integer);
+        return result;
+      }
+      break;
+    }
+  }
+  result.m_type = Scalar::e_void;
+  return result;
+}
+
+const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result;
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+      Scalar::e_void) {
+    switch (result.m_type) {
+    case Scalar::e_sint:
+    case Scalar::e_uint:
+    case Scalar::e_slong:
+    case Scalar::e_ulong:
+    case Scalar::e_slonglong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_uint128:
+    case Scalar::e_sint256:
+    case Scalar::e_uint256:
+      result.m_integer = a->m_integer ^ b->m_integer;
+      break;
+
+    case Scalar::e_void:
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      // No bitwise AND on floats, doubles of long doubles
+      result.m_type = Scalar::e_void;
+      break;
+    }
+  }
+  return result;
+}
+
+const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result = lhs;
+  result <<= rhs;
+  return result;
+}
+
+const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
+  Scalar result = lhs;
+  result >>= rhs;
+  return result;
+}
+
+Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
+                                   size_t byte_size) {
+  Status error;
+  if (value_str == nullptr || value_str[0] == '\0') {
+    error.SetErrorString("Invalid c-string value string.");
+    return error;
+  }
+  switch (encoding) {
+  case eEncodingInvalid:
+    error.SetErrorString("Invalid encoding.");
+    break;
+
+  case eEncodingUint:
+    if (byte_size <= sizeof(uint64_t)) {
+      uint64_t uval64;
+      if (!llvm::to_integer(value_str, uval64))
+        error.SetErrorStringWithFormat(
+            "'%s' is not a valid unsigned integer string value", value_str);
+      else if (!UIntValueIsValidForSize(uval64, byte_size))
+        error.SetErrorStringWithFormat("value 0x%" PRIx64
+                                       " is too large to fit in a %" PRIu64
+                                       " byte unsigned integer value",
+                                       uval64, (uint64_t)byte_size);
+      else {
+        m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
+        switch (m_type) {
+        case e_uint:
+          m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
+          break;
+        case e_ulong:
+          m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
+          break;
+        case e_ulonglong:
+          m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
+          break;
+        default:
+          error.SetErrorStringWithFormat(
+              "unsupported unsigned integer byte size: %" PRIu64 "",
+              (uint64_t)byte_size);
+          break;
+        }
+      }
+    } else {
+      error.SetErrorStringWithFormat(
+          "unsupported unsigned integer byte size: %" PRIu64 "",
+          (uint64_t)byte_size);
+      return error;
+    }
+    break;
+
+  case eEncodingSint:
+    if (byte_size <= sizeof(int64_t)) {
+      int64_t sval64;
+      if (!llvm::to_integer(value_str, sval64))
+        error.SetErrorStringWithFormat(
+            "'%s' is not a valid signed integer string value", value_str);
+      else if (!SIntValueIsValidForSize(sval64, byte_size))
+        error.SetErrorStringWithFormat("value 0x%" PRIx64
+                                       " is too large to fit in a %" PRIu64
+                                       " byte signed integer value",
+                                       sval64, (uint64_t)byte_size);
+      else {
+        m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
+        switch (m_type) {
+        case e_sint:
+          m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
+          break;
+        case e_slong:
+          m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
+          break;
+        case e_slonglong:
+          m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
+          break;
+        default:
+          error.SetErrorStringWithFormat(
+              "unsupported signed integer byte size: %" PRIu64 "",
+              (uint64_t)byte_size);
+          break;
+        }
+      }
+    } else {
+      error.SetErrorStringWithFormat(
+          "unsupported signed integer byte size: %" PRIu64 "",
+          (uint64_t)byte_size);
+      return error;
+    }
+    break;
+
+  case eEncodingIEEE754:
+    static float f_val;
+    static double d_val;
+    static long double l_val;
+    if (byte_size == sizeof(float)) {
+      if (::sscanf(value_str, "%f", &f_val) == 1) {
+        m_float = llvm::APFloat(f_val);
+        m_type = e_float;
+      } else
+        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
+                                       value_str);
+    } else if (byte_size == sizeof(double)) {
+      if (::sscanf(value_str, "%lf", &d_val) == 1) {
+        m_float = llvm::APFloat(d_val);
+        m_type = e_double;
+      } else
+        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
+                                       value_str);
+    } else if (byte_size == sizeof(long double)) {
+      if (::sscanf(value_str, "%Lf", &l_val) == 1) {
+        m_float =
+            llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
+                          llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+                                      ((type128 *)&l_val)->x));
+        m_type = e_long_double;
+      } else
+        error.SetErrorStringWithFormat("'%s' is not a valid float string value",
+                                       value_str);
+    } else {
+      error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
+                                     (uint64_t)byte_size);
+      return error;
+    }
+    break;
+
+  case eEncodingVector:
+    error.SetErrorString("vector encoding unsupported.");
+    break;
+  }
+  if (error.Fail())
+    m_type = e_void;
+
+  return error;
+}
+
+Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
+                                size_t byte_size) {
+  Status error;
+
+  type128 int128;
+  type256 int256;
+  switch (encoding) {
+  case lldb::eEncodingInvalid:
+    error.SetErrorString("invalid encoding");
+    break;
+  case lldb::eEncodingVector:
+    error.SetErrorString("vector encoding unsupported");
+    break;
+  case lldb::eEncodingUint: {
+    lldb::offset_t offset = 0;
+
+    switch (byte_size) {
+    case 1:
+      operator=((uint8_t)data.GetU8(&offset));
+      break;
+    case 2:
+      operator=((uint16_t)data.GetU16(&offset));
+      break;
+    case 4:
+      operator=((uint32_t)data.GetU32(&offset));
+      break;
+    case 8:
+      operator=((uint64_t)data.GetU64(&offset));
+      break;
+    case 16:
+      if (data.GetByteOrder() == eByteOrderBig) {
+        int128.x[1] = (uint64_t)data.GetU64(&offset);
+        int128.x[0] = (uint64_t)data.GetU64(&offset);
+      } else {
+        int128.x[0] = (uint64_t)data.GetU64(&offset);
+        int128.x[1] = (uint64_t)data.GetU64(&offset);
+      }
+      operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
+      break;
+    case 32:
+      if (data.GetByteOrder() == eByteOrderBig) {
+        int256.x[3] = (uint64_t)data.GetU64(&offset);
+        int256.x[2] = (uint64_t)data.GetU64(&offset);
+        int256.x[1] = (uint64_t)data.GetU64(&offset);
+        int256.x[0] = (uint64_t)data.GetU64(&offset);
+      } else {
+        int256.x[0] = (uint64_t)data.GetU64(&offset);
+        int256.x[1] = (uint64_t)data.GetU64(&offset);
+        int256.x[2] = (uint64_t)data.GetU64(&offset);
+        int256.x[3] = (uint64_t)data.GetU64(&offset);
+      }
+      operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
+      break;
+    default:
+      error.SetErrorStringWithFormat(
+          "unsupported unsigned integer byte size: %" PRIu64 "",
+          (uint64_t)byte_size);
+      break;
+    }
+  } break;
+  case lldb::eEncodingSint: {
+    lldb::offset_t offset = 0;
+
+    switch (byte_size) {
+    case 1:
+      operator=((int8_t)data.GetU8(&offset));
+      break;
+    case 2:
+      operator=((int16_t)data.GetU16(&offset));
+      break;
+    case 4:
+      operator=((int32_t)data.GetU32(&offset));
+      break;
+    case 8:
+      operator=((int64_t)data.GetU64(&offset));
+      break;
+    case 16:
+      if (data.GetByteOrder() == eByteOrderBig) {
+        int128.x[1] = (uint64_t)data.GetU64(&offset);
+        int128.x[0] = (uint64_t)data.GetU64(&offset);
+      } else {
+        int128.x[0] = (uint64_t)data.GetU64(&offset);
+        int128.x[1] = (uint64_t)data.GetU64(&offset);
+      }
+      operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
+      break;
+    case 32:
+      if (data.GetByteOrder() == eByteOrderBig) {
+        int256.x[3] = (uint64_t)data.GetU64(&offset);
+        int256.x[2] = (uint64_t)data.GetU64(&offset);
+        int256.x[1] = (uint64_t)data.GetU64(&offset);
+        int256.x[0] = (uint64_t)data.GetU64(&offset);
+      } else {
+        int256.x[0] = (uint64_t)data.GetU64(&offset);
+        int256.x[1] = (uint64_t)data.GetU64(&offset);
+        int256.x[2] = (uint64_t)data.GetU64(&offset);
+        int256.x[3] = (uint64_t)data.GetU64(&offset);
+      }
+      operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
+      break;
+    default:
+      error.SetErrorStringWithFormat(
+          "unsupported signed integer byte size: %" PRIu64 "",
+          (uint64_t)byte_size);
+      break;
+    }
+  } break;
+  case lldb::eEncodingIEEE754: {
+    lldb::offset_t offset = 0;
+
+    if (byte_size == sizeof(float))
+      operator=((float)data.GetFloat(&offset));
+    else if (byte_size == sizeof(double))
+      operator=((double)data.GetDouble(&offset));
+    else if (byte_size == sizeof(long double))
+      operator=((long double)data.GetLongDouble(&offset));
+    else
+      error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
+                                     (uint64_t)byte_size);
+  } break;
+  }
+
+  return error;
+}
+
+bool Scalar::SignExtend(uint32_t sign_bit_pos) {
+  const uint32_t max_bit_pos = GetByteSize() * 8;
+
+  if (sign_bit_pos < max_bit_pos) {
+    switch (m_type) {
+    case Scalar::e_void:
+    case Scalar::e_float:
+    case Scalar::e_double:
+    case Scalar::e_long_double:
+      return false;
+
+    case Scalar::e_sint:
+    case Scalar::e_uint:
+    case Scalar::e_slong:
+    case Scalar::e_ulong:
+    case Scalar::e_slonglong:
+    case Scalar::e_ulonglong:
+    case Scalar::e_sint128:
+    case Scalar::e_uint128:
+    case Scalar::e_sint256:
+    case Scalar::e_uint256:
+      if (max_bit_pos == sign_bit_pos)
+        return true;
+      else if (sign_bit_pos < (max_bit_pos - 1)) {
+        llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
+        llvm::APInt bitwize_and = m_integer & sign_bit;
+        if (bitwize_and.getBoolValue()) {
+          const llvm::APInt mask =
+              ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
+          m_integer |= mask;
+        }
+        return true;
+      }
+      break;
+    }
+  }
+  return false;
+}
+
+size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
+                               lldb::ByteOrder dst_byte_order,
+                               Status &error) const {
+  // Get a data extractor that points to the native scalar data
+  DataExtractor data;
+  if (!GetData(data)) {
+    error.SetErrorString("invalid scalar value");
+    return 0;
+  }
+
+  const size_t src_len = data.GetByteSize();
+
+  // Prepare a memory buffer that contains some or all of the register value
+  const size_t bytes_copied =
+      data.CopyByteOrderedData(0,               // src offset
+                               src_len,         // src length
+                               dst,             // dst buffer
+                               dst_len,         // dst length
+                               dst_byte_order); // dst byte order
+  if (bytes_copied == 0)
+    error.SetErrorString("failed to copy data");
+
+  return bytes_copied;
+}
+
+bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
+  if (bit_size == 0)
+    return true;
+
+  switch (m_type) {
+  case Scalar::e_void:
+  case Scalar::e_float:
+  case Scalar::e_double:
+  case Scalar::e_long_double:
+    break;
+
+  case Scalar::e_sint:
+  case Scalar::e_slong:
+  case Scalar::e_slonglong:
+  case Scalar::e_sint128:
+  case Scalar::e_sint256:
+    m_integer = m_integer.ashr(bit_offset)
+                    .sextOrTrunc(bit_size)
+                    .sextOrSelf(8 * GetByteSize());
+    return true;
+
+  case Scalar::e_uint:
+  case Scalar::e_ulong:
+  case Scalar::e_ulonglong:
+  case Scalar::e_uint128:
+  case Scalar::e_uint256:
+    m_integer = m_integer.lshr(bit_offset)
+                    .zextOrTrunc(bit_size)
+                    .zextOrSelf(8 * GetByteSize());
+    return true;
+  }
+  return false;
+}
+
+bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
+  // If either entry is void then we can just compare the types
+  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
+    return lhs.m_type == rhs.m_type;
+
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  llvm::APFloat::cmpResult result;
+  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  case Scalar::e_void:
+    break;
+  case Scalar::e_sint:
+  case Scalar::e_uint:
+  case Scalar::e_slong:
+  case Scalar::e_ulong:
+  case Scalar::e_slonglong:
+  case Scalar::e_ulonglong:
+  case Scalar::e_sint128:
+  case Scalar::e_uint128:
+  case Scalar::e_sint256:
+  case Scalar::e_uint256:
+    return a->m_integer == b->m_integer;
+  case Scalar::e_float:
+  case Scalar::e_double:
+  case Scalar::e_long_double:
+    result = a->m_float.compare(b->m_float);
+    if (result == llvm::APFloat::cmpEqual)
+      return true;
+  }
+  return false;
+}
+
+bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
+  // If either entry is void then we can just compare the types
+  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
+    return lhs.m_type != rhs.m_type;
+
+  Scalar
+      temp_value; // A temp value that might get a copy of either promoted value
+  const Scalar *a;
+  const Scalar *b;
+  llvm::APFloat::cmpResult result;
+  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  case Scalar::e_void:
+    break;
+  case Scalar::e_sint:
+  case Scalar::e_uint:
+  case Scalar::e_slong:
+  case Scalar::e_ulong:
+  case Scalar::e_slonglong:
+  case Scalar::e_ulonglong:
+  case Scalar::e_sint128:
+  case Scalar::e_uint128:
+  case Scalar::e_sint256:
+  case Scalar::e_uint256:
+    return a->m_integer != b->m_integer;
+  case Scalar::e_float:
+  case Scalar::e_double:
+  case Scalar::e_long_double:
+    result = a->m_float.compare(b->m_float);
+    if (result != llvm::APFloat::cmpEqual)
+      return true;
+  }
+  return true;
+}
+
+bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
+  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
+    return false;
+
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  llvm::APFloat::cmpResult result;
+  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  case Scalar::e_void:
+    break;
+  case Scalar::e_sint:
+  case Scalar::e_slong:
+  case Scalar::e_slonglong:
+  case Scalar::e_sint128:
+  case Scalar::e_sint256:
+    return a->m_integer.slt(b->m_integer);
+  case Scalar::e_uint:
+  case Scalar::e_ulong:
+  case Scalar::e_ulonglong:
+  case Scalar::e_uint128:
+  case Scalar::e_uint256:
+    return a->m_integer.ult(b->m_integer);
+  case Scalar::e_float:
+  case Scalar::e_double:
+  case Scalar::e_long_double:
+    result = a->m_float.compare(b->m_float);
+    if (result == llvm::APFloat::cmpLessThan)
+      return true;
+  }
+  return false;
+}
+
+bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
+  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
+    return false;
+
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  llvm::APFloat::cmpResult result;
+  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  case Scalar::e_void:
+    break;
+  case Scalar::e_sint:
+  case Scalar::e_slong:
+  case Scalar::e_slonglong:
+  case Scalar::e_sint128:
+  case Scalar::e_sint256:
+    return a->m_integer.sle(b->m_integer);
+  case Scalar::e_uint:
+  case Scalar::e_ulong:
+  case Scalar::e_ulonglong:
+  case Scalar::e_uint128:
+  case Scalar::e_uint256:
+    return a->m_integer.ule(b->m_integer);
+  case Scalar::e_float:
+  case Scalar::e_double:
+  case Scalar::e_long_double:
+    result = a->m_float.compare(b->m_float);
+    if (result == llvm::APFloat::cmpLessThan ||
+        result == llvm::APFloat::cmpEqual)
+      return true;
+  }
+  return false;
+}
+
+bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
+  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
+    return false;
+
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  llvm::APFloat::cmpResult result;
+  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  case Scalar::e_void:
+    break;
+  case Scalar::e_sint:
+  case Scalar::e_slong:
+  case Scalar::e_slonglong:
+  case Scalar::e_sint128:
+  case Scalar::e_sint256:
+    return a->m_integer.sgt(b->m_integer);
+  case Scalar::e_uint:
+  case Scalar::e_ulong:
+  case Scalar::e_ulonglong:
+  case Scalar::e_uint128:
+  case Scalar::e_uint256:
+    return a->m_integer.ugt(b->m_integer);
+  case Scalar::e_float:
+  case Scalar::e_double:
+  case Scalar::e_long_double:
+    result = a->m_float.compare(b->m_float);
+    if (result == llvm::APFloat::cmpGreaterThan)
+      return true;
+  }
+  return false;
+}
+
+bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
+  if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
+    return false;
+
+  Scalar temp_value;
+  const Scalar *a;
+  const Scalar *b;
+  llvm::APFloat::cmpResult result;
+  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  case Scalar::e_void:
+    break;
+  case Scalar::e_sint:
+  case Scalar::e_slong:
+  case Scalar::e_slonglong:
+  case Scalar::e_sint128:
+  case Scalar::e_sint256:
+    return a->m_integer.sge(b->m_integer);
+  case Scalar::e_uint:
+  case Scalar::e_ulong:
+  case Scalar::e_ulonglong:
+  case Scalar::e_uint128:
+  case Scalar::e_uint256:
+    return a->m_integer.uge(b->m_integer);
+  case Scalar::e_float:
+  case Scalar::e_double:
+  case Scalar::e_long_double:
+    result = a->m_float.compare(b->m_float);
+    if (result == llvm::APFloat::cmpGreaterThan ||
+        result == llvm::APFloat::cmpEqual)
+      return true;
+  }
+  return false;
+}
+
+bool Scalar::ClearBit(uint32_t bit) {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    m_integer.clearBit(bit);
+    return true;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    break;
+  }
+  return false;
+}
+
+bool Scalar::SetBit(uint32_t bit) {
+  switch (m_type) {
+  case e_void:
+    break;
+  case e_sint:
+  case e_uint:
+  case e_slong:
+  case e_ulong:
+  case e_slonglong:
+  case e_ulonglong:
+  case e_sint128:
+  case e_uint128:
+  case e_sint256:
+  case e_uint256:
+    m_integer.setBit(bit);
+    return true;
+  case e_float:
+  case e_double:
+  case e_long_double:
+    break;
+  }
+  return false;
+}

lldb/trunk/source/Utility/State.cpp

+//===-- State.cpp -----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Utility/State.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+const char *lldb_private::StateAsCString(StateType state) {
+  switch (state) {
+  case eStateInvalid:
+    return "invalid";
+  case eStateUnloaded:
+    return "unloaded";
+  case eStateConnected:
+    return "connected";
+  case eStateAttaching:
+    return "attaching";
+  case eStateLaunching:
+    return "launching";
+  case eStateStopped:
+    return "stopped";
+  case eStateRunning:
+    return "running";
+  case eStateStepping:
+    return "stepping";
+  case eStateCrashed:
+    return "crashed";
+  case eStateDetached:
+    return "detached";
+  case eStateExited:
+    return "exited";
+  case eStateSuspended:
+    return "suspended";
+  }
+  return "unknown";
+}
+
+const char *lldb_private::GetPermissionsAsCString(uint32_t permissions) {
+  switch (permissions) {
+  case 0:
+    return "---";
+  case ePermissionsWritable:
+    return "-w-";
+  case ePermissionsReadable:
+    return "r--";
+  case ePermissionsExecutable:
+    return "--x";
+  case ePermissionsReadable | ePermissionsWritable:
+    return "rw-";
+  case ePermissionsReadable | ePermissionsExecutable:
+    return "r-x";
+  case ePermissionsWritable | ePermissionsExecutable:
+    return "-wx";
+  case ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable:
+    return "rwx";
+  default:
+    break;
+  }
+  return "???";
+}
+
+bool lldb_private::StateIsRunningState(StateType state) {
+  switch (state) {
+  case eStateAttaching:
+  case eStateLaunching:
+  case eStateRunning:
+  case eStateStepping:
+    return true;
+
+  case eStateConnected:
+  case eStateDetached:
+  case eStateInvalid:
+  case eStateUnloaded:
+  case eStateStopped:
+  case eStateCrashed:
+  case eStateExited:
+  case eStateSuspended:
+    break;
+  }
+  return false;
+}
+
+bool lldb_private::StateIsStoppedState(StateType state, bool must_exist) {
+  switch (state) {
+  case eStateInvalid:
+  case eStateConnected:
+  case eStateAttaching:
+  case eStateLaunching:
+  case eStateRunning:
+  case eStateStepping:
+  case eStateDetached:
+    break;
+
+  case eStateUnloaded:
+  case eStateExited:
+    return !must_exist;
+
+  case eStateStopped:
+  case eStateCrashed:
+  case eStateSuspended:
+    return true;
+  }
+  return false;
+}

lldb/trunk/unittests/Core/CMakeLists.txt

 add_lldb_unittest(LLDBCoreTests
   BroadcasterTest.cpp
   DataExtractorTest.cpp
   EventTest.cpp
   ListenerTest.cpp
   MangledTest.cpp
   ScalarTest.cpp
-  StateTest.cpp
   StreamCallbackTest.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbPluginObjectFileELF
     lldbPluginSymbolVendorELF

lldb/trunk/unittests/Core/ScalarTest.cpp

 //===-- ScalarTest.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
-#include "lldb/Core/Scalar.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
+#include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private;
 using namespace llvm;
 
 TEST(ScalarTest, RightShiftOperator) {

lldb/trunk/unittests/Core/StateTest.cpp

-//===-- StateTest.cpp -------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/State.h"
-#include "llvm/Support/FormatVariadic.h"
-#include "gtest/gtest.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-TEST(StateTest, Formatv) {
-  EXPECT_EQ("exited", llvm::formatv("{0}", eStateExited).str());
-  EXPECT_EQ("stopped", llvm::formatv("{0}", eStateStopped).str());
-  EXPECT_EQ("unknown", llvm::formatv("{0}", StateType(-1)).str());
-}

lldb/trunk/unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
   AnsiTerminalTest.cpp
   ArgsTest.cpp
   OptionsWithRawTest.cpp
   ArchSpecTest.cpp
   CleanUpTest.cpp
   ConstStringTest.cpp
   CompletionRequestTest.cpp
   EnvironmentTest.cpp
   FileSpecTest.cpp
   FlagsTest.cpp
   JSONTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
+  RegisterValueTest.cpp
+  StateTest.cpp
   StatusTest.cpp
   StreamTeeTest.cpp
   StreamTest.cpp
   StringExtractorTest.cpp
   StringListTest.cpp
   StructuredDataTest.cpp
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp

lldb/trunk/unittests/Utility/RegisterValueTest.cpp

+//===-- RegisterValueTest.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/RegisterValue.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+
+TEST(RegisterValueTest, GetSet8) {
+  RegisterValue R8(uint8_t(47));
+  EXPECT_EQ(47u, R8.GetAsUInt8());
+  R8 = uint8_t(42);
+  EXPECT_EQ(42u, R8.GetAsUInt8());
+  EXPECT_EQ(42u, R8.GetAsUInt16());
+  EXPECT_EQ(42u, R8.GetAsUInt32());
+  EXPECT_EQ(42u, R8.GetAsUInt64());
+}

lldb/trunk/unittests/Utility/StateTest.cpp

+//===-- StateTest.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/State.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "gtest/gtest.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+TEST(StateTest, Formatv) {
+  EXPECT_EQ("exited", llvm::formatv("{0}", eStateExited).str());
+  EXPECT_EQ("stopped", llvm::formatv("{0}", eStateStopped).str());
+  EXPECT_EQ("unknown", llvm::formatv("{0}", StateType(-1)).str());
+}

lldb/trunk/unittests/tools/lldb-server/tests/MessageObjects.h

 //===-- MessageObjects.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SERVER_TESTS_MESSAGEOBJECTS_H
 #define LLDB_SERVER_TESTS_MESSAGEOBJECTS_H
 
-#include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <string>