Blame - source/Core/Scalar.cpp - platform/external/lldb

blob: a34edd30e1455d4de5827bea8d4a34d1cd9ae3fc [file] [log] [blame]

Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1	//===-- Scalar.cpp ----------------------------------------------- C++ --===//
				2	//
				3	// The LLVM Compiler Infrastructure
				4	//
				5	// This file is distributed under the University of Illinois Open Source
				6	// License. See LICENSE.TXT for details.
				7	//
				8	//===----------------------------------------------------------------------===//
				9
				10	#include "lldb/Core/Scalar.h"
				11
				12	#include <math.h>
Daniel Malea	5f35a4b	2012-11-29 21:49:15 +0000	[diff] [blame]	13	#include <inttypes.h>
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	14
Jim Ingham	84cdc15	2010-06-15 19:49:27 +0000	[diff] [blame]	15	#include "lldb/Interpreter/Args.h"
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	16	#include "lldb/Core/Error.h"
				17	#include "lldb/Core/Stream.h"
				18	#include "lldb/Core/DataExtractor.h"
Greg Clayton	cd54803	2011-02-01 01:31:41 +0000	[diff] [blame]	19	#include "lldb/Host/Endian.h"
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	20
Greg Clayton	1716ad7	2011-12-29 01:26:56 +0000	[diff] [blame]	21	#include "Plugins/Process/Utility/InstructionUtils.h"
				22
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	23	using namespace lldb;
				24	using namespace lldb_private;
				25
				26	//----------------------------------------------------------------------
				27	// Promote to max type currently follows the ANSI C rule for type
				28	// promotion in expressions.
				29	//----------------------------------------------------------------------
				30	static Scalar::Type
				31	PromoteToMaxType
				32	(
				33	const Scalar& lhs, // The const left hand side object
				34	const Scalar& rhs, // The const right hand side object
				35	Scalar& temp_value, // A modifiable temp value than can be used to hold either the promoted lhs or rhs object
				36	const Scalar* &promoted_lhs_ptr, // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted)
				37	const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted)
				38	)
				39	{
				40	Scalar result;
				41	// Initialize the promoted values for both the right and left hand side values
				42	// to be the objects themselves. If no promotion is needed (both right and left
				43	// have the same type), then the temp_value will not get used.
				44	promoted_lhs_ptr = &lhs;
				45	promoted_rhs_ptr = &rhs;
				46	// Extract the types of both the right and left hand side values
				47	Scalar::Type lhs_type = lhs.GetType();
				48	Scalar::Type rhs_type = rhs.GetType();
				49
				50	if (lhs_type > rhs_type)
				51	{
				52	// Right hand side need to be promoted
				53	temp_value = rhs; // Copy right hand side into the temp value
				54	if (temp_value.Promote(lhs_type)) // Promote it
				55	promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side
				56	}
				57	else if (lhs_type < rhs_type)
				58	{
				59	// Left hand side need to be promoted
				60	temp_value = lhs; // Copy left hand side value into the temp value
				61	if (temp_value.Promote(rhs_type)) // Promote it
				62	promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
				63	}
				64
				65	// Make sure our type promotion worked as exptected
				66	if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
				67	return promoted_lhs_ptr->GetType(); // Return the resulting max type
				68
				69	// Return the void type (zero) if we fail to promote either of the values.
				70	return Scalar::e_void;
				71	}
				72
				73
				74	//----------------------------------------------------------------------
				75	// Scalar constructor
				76	//----------------------------------------------------------------------
				77	Scalar::Scalar() :
				78	m_type(e_void),
				79	m_data()
				80	{
				81	}
				82
				83	//----------------------------------------------------------------------
				84	// Scalar copy constructor
				85	//----------------------------------------------------------------------
				86	Scalar::Scalar(const Scalar& rhs) :
				87	m_type(rhs.m_type),
				88	m_data(rhs.m_data) // TODO: verify that for C++ this will correctly copy the union??
				89	{
				90	}
				91
				92	//Scalar::Scalar(const RegisterValue& reg) :
				93	// m_type(e_void),
				94	// m_data()
				95	//{
				96	// switch (reg.info.encoding)
				97	// {
				98	// case eEncodingUint: // unsigned integer
				99	// switch (reg.info.byte_size)
				100	// {
				101	// case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
				102	// case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
				103	// case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
				104	// case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break;
				105	// break;
				106	// }
				107	// break;
				108	//
				109	// case eEncodingSint: // signed integer
				110	// switch (reg.info.byte_size)
				111	// {
				112	// case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
				113	// case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
				114	// case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
				115	// case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break;
				116	// break;
				117	// }
				118	// break;
				119	//
				120	// case eEncodingIEEE754: // float
				121	// switch (reg.info.byte_size)
				122	// {
				123	// case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
				124	// case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
				125	// break;
				126	// }
				127	// break;
				128	// case eEncodingVector: // vector registers
				129	// break;
				130	// }
				131	//}
				132
				133	bool
				134	Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
				135	{
				136	size_t byte_size = GetByteSize();
				137	if (byte_size > 0)
				138	{
				139	if (limit_byte_size < byte_size)
				140	{
Greg Clayton	cd54803	2011-02-01 01:31:41 +0000	[diff] [blame]	141	if (lldb::endian::InlHostByteOrder() == eByteOrderLittle)
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	142	{
				143	// On little endian systems if we want fewer bytes from the
				144	// current type we just specify fewer bytes since the LSByte
				145	// is first...
Greg Clayton	cd54803	2011-02-01 01:31:41 +0000	[diff] [blame]	146	data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder());
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	147	}
Greg Clayton	cd54803	2011-02-01 01:31:41 +0000	[diff] [blame]	148	else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	149	{
				150	// On big endian systems if we want fewer bytes from the
				151	// current type have to advance our initial byte pointer and
				152	// trim down the number of bytes since the MSByte is first
Greg Clayton	cd54803	2011-02-01 01:31:41 +0000	[diff] [blame]	153	data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	154	}
				155	}
				156	else
				157	{
				158	// We want all of the data
Greg Clayton	cd54803	2011-02-01 01:31:41 +0000	[diff] [blame]	159	data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder());
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	160	}
				161	return true;
				162	}
				163	data.Clear();
				164	return false;
				165	}
				166
				167	size_t
				168	Scalar::GetByteSize() const
				169	{
				170	switch (m_type)
				171	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	172	case e_void:
				173	break;
				174	case e_sint: return sizeof(m_data.sint);
				175	case e_uint: return sizeof(m_data.uint);
				176	case e_slong: return sizeof(m_data.slong);
				177	case e_ulong: return sizeof(m_data.ulong);
				178	case e_slonglong: return sizeof(m_data.slonglong);
				179	case e_ulonglong: return sizeof(m_data.ulonglong);
				180	case e_float: return sizeof(m_data.flt);
				181	case e_double: return sizeof(m_data.dbl);
				182	case e_long_double: return sizeof(m_data.ldbl);
				183	}
				184	return 0;
				185	}
				186
				187	bool
				188	Scalar::IsZero() const
				189	{
				190	switch (m_type)
				191	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	192	case e_void:
				193	break;
				194	case e_sint: return m_data.sint == 0;
				195	case e_uint: return m_data.uint == 0;
				196	case e_slong: return m_data.slong == 0;
				197	case e_ulong: return m_data.ulong == 0;
				198	case e_slonglong: return m_data.slonglong == 0;
				199	case e_ulonglong: return m_data.ulonglong == 0;
				200	case e_float: return m_data.flt == 0.0f;
				201	case e_double: return m_data.dbl == 0.0;
				202	case e_long_double: return m_data.ldbl == 0.0;
				203	}
				204	return false;
				205	}
				206
				207	void
				208	Scalar::GetValue (Stream *s, bool show_type) const
				209	{
				210	if (show_type)
				211	s->Printf("(%s) ", GetTypeAsCString());
				212
				213	switch (m_type)
				214	{
				215	case e_void:
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	216	break;
				217	case e_sint: s->Printf("%i", m_data.sint); break;
				218	case e_uint: s->Printf("0x%8.8x", m_data.uint); break;
				219	case e_slong: s->Printf("%li", m_data.slong); break;
				220	case e_ulong: s->Printf("0x%8.8lx", m_data.ulong); break;
				221	case e_slonglong: s->Printf("%lli", m_data.slonglong); break;
				222	case e_ulonglong: s->Printf("0x%16.16llx", m_data.ulonglong); break;
				223	case e_float: s->Printf("%f", m_data.flt); break;
				224	case e_double: s->Printf("%g", m_data.dbl); break;
				225	case e_long_double: s->Printf("%Lg", m_data.ldbl); break;
				226	}
				227	}
				228
				229	const char *
				230	Scalar::GetTypeAsCString() const
				231	{
				232	switch (m_type)
				233	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	234	case e_void: return "void";
				235	case e_sint: return "int";
				236	case e_uint: return "unsigned int";
				237	case e_slong: return "long";
				238	case e_ulong: return "unsigned long";
				239	case e_slonglong: return "long long";
				240	case e_ulonglong: return "unsigned long long";
				241	case e_float: return "float";
				242	case e_double: return "double";
				243	case e_long_double: return "long double";
				244	}
				245	return "<invalid Scalar type>";
				246	}
				247
				248
				249
				250	//----------------------------------------------------------------------
				251	// Scalar copy constructor
				252	//----------------------------------------------------------------------
				253	Scalar&
				254	Scalar::operator=(const Scalar& rhs)
				255	{
				256	if (this != &rhs)
				257	{
				258	m_type = rhs.m_type;
				259	::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
				260	}
				261	return *this;
				262	}
				263
				264	Scalar&
				265	Scalar::operator= (const int v)
				266	{
				267	m_type = e_sint;
				268	m_data.sint = v;
				269	return *this;
				270	}
				271
				272
				273	Scalar&
				274	Scalar::operator= (unsigned int v)
				275	{
				276	m_type = e_uint;
				277	m_data.uint = v;
				278	return *this;
				279	}
				280
				281	Scalar&
				282	Scalar::operator= (long v)
				283	{
				284	m_type = e_slong;
				285	m_data.slong = v;
				286	return *this;
				287	}
				288
				289	Scalar&
				290	Scalar::operator= (unsigned long v)
				291	{
				292	m_type = e_ulong;
				293	m_data.ulong = v;
				294	return *this;
				295	}
				296
				297	Scalar&
				298	Scalar::operator= (long long v)
				299	{
				300	m_type = e_slonglong;
				301	m_data.slonglong = v;
				302	return *this;
				303	}
				304
				305	Scalar&
				306	Scalar::operator= (unsigned long long v)
				307	{
				308	m_type = e_ulonglong;
				309	m_data.ulonglong = v;
				310	return *this;
				311	}
				312
				313	Scalar&
				314	Scalar::operator= (float v)
				315	{
				316	m_type = e_float;
				317	m_data.flt = v;
				318	return *this;
				319	}
				320
				321	Scalar&
				322	Scalar::operator= (double v)
				323	{
				324	m_type = e_double;
				325	m_data.dbl = v;
				326	return *this;
				327	}
				328
				329	Scalar&
				330	Scalar::operator= (long double v)
				331	{
				332	m_type = e_long_double;
				333	m_data.ldbl = v;
				334	return *this;
				335	}
				336
				337	//----------------------------------------------------------------------
				338	// Destructor
				339	//----------------------------------------------------------------------
				340	Scalar::~Scalar()
				341	{
				342	}
				343
				344	bool
				345	Scalar::Promote(Scalar::Type type)
				346	{
				347	bool success = false;
				348	switch (m_type)
				349	{
				350	case e_void:
				351	break;
				352
				353	case e_sint:
				354	switch (type)
				355	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	356	case e_void: break;
				357	case e_sint: success = true; break;
				358	case e_uint: m_data.uint = m_data.sint; success = true; break;
				359	case e_slong: m_data.slong = m_data.sint; success = true; break;
				360	case e_ulong: m_data.ulong = m_data.sint; success = true; break;
				361	case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
				362	case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
				363	case e_float: m_data.flt = m_data.sint; success = true; break;
				364	case e_double: m_data.dbl = m_data.sint; success = true; break;
				365	case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
				366	}
				367	break;
				368
				369	case e_uint:
				370	switch (type)
				371	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	372	case e_void:
				373	case e_sint: break;
				374	case e_uint: success = true; break;
				375	case e_slong: m_data.slong = m_data.uint; success = true; break;
				376	case e_ulong: m_data.ulong = m_data.uint; success = true; break;
				377	case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
				378	case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
				379	case e_float: m_data.flt = m_data.uint; success = true; break;
				380	case e_double: m_data.dbl = m_data.uint; success = true; break;
				381	case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
				382	}
				383	break;
				384
				385	case e_slong:
				386	switch (type)
				387	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	388	case e_void:
				389	case e_sint:
				390	case e_uint: break;
				391	case e_slong: success = true; break;
				392	case e_ulong: m_data.ulong = m_data.slong; success = true; break;
				393	case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
				394	case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
				395	case e_float: m_data.flt = m_data.slong; success = true; break;
				396	case e_double: m_data.dbl = m_data.slong; success = true; break;
				397	case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
				398	}
				399	break;
				400
				401	case e_ulong:
				402	switch (type)
				403	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	404	case e_void:
				405	case e_sint:
				406	case e_uint:
				407	case e_slong: break;
				408	case e_ulong: success = true; break;
				409	case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
				410	case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
				411	case e_float: m_data.flt = m_data.ulong; success = true; break;
				412	case e_double: m_data.dbl = m_data.ulong; success = true; break;
				413	case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
				414	}
				415	break;
				416
				417	case e_slonglong:
				418	switch (type)
				419	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	420	case e_void:
				421	case e_sint:
				422	case e_uint:
				423	case e_slong:
				424	case e_ulong: break;
				425	case e_slonglong: success = true; break;
				426	case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
				427	case e_float: m_data.flt = m_data.slonglong; success = true; break;
				428	case e_double: m_data.dbl = m_data.slonglong; success = true; break;
				429	case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
				430	}
				431	break;
				432
				433	case e_ulonglong:
				434	switch (type)
				435	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	436	case e_void:
				437	case e_sint:
				438	case e_uint:
				439	case e_slong:
				440	case e_ulong:
				441	case e_slonglong: break;
				442	case e_ulonglong: success = true; break;
				443	case e_float: m_data.flt = m_data.ulonglong; success = true; break;
				444	case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
				445	case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
				446	}
				447	break;
				448
				449	case e_float:
				450	switch (type)
				451	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	452	case e_void:
				453	case e_sint:
				454	case e_uint:
				455	case e_slong:
				456	case e_ulong:
				457	case e_slonglong:
				458	case e_ulonglong: break;
				459	case e_float: success = true; break;
				460	case e_double: m_data.dbl = m_data.flt; success = true; break;
				461	case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
				462	}
				463	break;
				464
				465	case e_double:
				466	switch (type)
				467	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	468	case e_void:
				469	case e_sint:
				470	case e_uint:
				471	case e_slong:
				472	case e_ulong:
				473	case e_slonglong:
				474	case e_ulonglong:
				475	case e_float: break;
				476	case e_double: success = true; break;
				477	case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
				478	}
				479	break;
				480
				481	case e_long_double:
				482	switch (type)
				483	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	484	case e_void:
				485	case e_sint:
				486	case e_uint:
				487	case e_slong:
				488	case e_ulong:
				489	case e_slonglong:
				490	case e_ulonglong:
				491	case e_float:
				492	case e_double: break;
				493	case e_long_double: success = true; break;
				494	}
				495	break;
				496	}
				497
				498	if (success)
				499	m_type = type;
				500	return success;
				501	}
				502
				503	const char *
				504	Scalar::GetValueTypeAsCString (Scalar::Type type)
				505	{
				506	switch (type)
				507	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	508	case e_void: return "void";
				509	case e_sint: return "int";
				510	case e_uint: return "unsigned int";
				511	case e_slong: return "long";
				512	case e_ulong: return "unsigned long";
				513	case e_slonglong: return "long long";
				514	case e_ulonglong: return "unsigned long long";
				515	case e_float: return "float";
				516	case e_double: return "double";
				517	case e_long_double: return "long double";
				518	}
				519	return "???";
				520	}
				521
				522
				523	Scalar::Type
				524	Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
				525	{
				526	if (byte_size <= sizeof(int))
				527	return e_sint;
				528	if (byte_size <= sizeof(long))
				529	return e_slong;
				530	if (byte_size <= sizeof(long long))
				531	return e_slonglong;
				532	return e_void;
				533	}
				534
				535	Scalar::Type
				536	Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size)
				537	{
				538	if (byte_size <= sizeof(unsigned int))
				539	return e_uint;
				540	if (byte_size <= sizeof(unsigned long))
				541	return e_ulong;
				542	if (byte_size <= sizeof(unsigned long long))
				543	return e_ulonglong;
				544	return e_void;
				545	}
				546
				547	Scalar::Type
				548	Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size)
				549	{
				550	if (byte_size == sizeof(float))
				551	return e_float;
				552	if (byte_size == sizeof(double))
				553	return e_double;
				554	if (byte_size == sizeof(long double))
				555	return e_long_double;
				556	return e_void;
				557	}
				558
				559	bool
				560	Scalar::Cast(Scalar::Type type)
				561	{
				562	bool success = false;
				563	switch (m_type)
				564	{
				565	case e_void:
				566	break;
				567
				568	case e_sint:
				569	switch (type)
				570	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	571	case e_void: break;
				572	case e_sint: success = true; break;
				573	case e_uint: m_data.uint = m_data.sint; success = true; break;
				574	case e_slong: m_data.slong = m_data.sint; success = true; break;
				575	case e_ulong: m_data.ulong = m_data.sint; success = true; break;
				576	case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
				577	case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
				578	case e_float: m_data.flt = m_data.sint; success = true; break;
				579	case e_double: m_data.dbl = m_data.sint; success = true; break;
				580	case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
				581	}
				582	break;
				583
				584	case e_uint:
				585	switch (type)
				586	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	587	case e_void:
				588	case e_sint: m_data.sint = m_data.uint; success = true; break;
				589	case e_uint: success = true; break;
				590	case e_slong: m_data.slong = m_data.uint; success = true; break;
				591	case e_ulong: m_data.ulong = m_data.uint; success = true; break;
				592	case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
				593	case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
				594	case e_float: m_data.flt = m_data.uint; success = true; break;
				595	case e_double: m_data.dbl = m_data.uint; success = true; break;
				596	case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
				597	}
				598	break;
				599
				600	case e_slong:
				601	switch (type)
				602	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	603	case e_void:
				604	case e_sint: m_data.sint = m_data.slong; success = true; break;
				605	case e_uint: m_data.uint = m_data.slong; success = true; break;
				606	case e_slong: success = true; break;
				607	case e_ulong: m_data.ulong = m_data.slong; success = true; break;
				608	case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
				609	case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
				610	case e_float: m_data.flt = m_data.slong; success = true; break;
				611	case e_double: m_data.dbl = m_data.slong; success = true; break;
				612	case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
				613	}
				614	break;
				615
				616	case e_ulong:
				617	switch (type)
				618	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	619	case e_void:
				620	case e_sint: m_data.sint = m_data.ulong; success = true; break;
				621	case e_uint: m_data.uint = m_data.ulong; success = true; break;
				622	case e_slong: m_data.slong = m_data.ulong; success = true; break;
				623	case e_ulong: success = true; break;
				624	case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
				625	case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
				626	case e_float: m_data.flt = m_data.ulong; success = true; break;
				627	case e_double: m_data.dbl = m_data.ulong; success = true; break;
				628	case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
				629	}
				630	break;
				631
				632	case e_slonglong:
				633	switch (type)
				634	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	635	case e_void:
				636	case e_sint: m_data.sint = m_data.slonglong; success = true; break;
				637	case e_uint: m_data.uint = m_data.slonglong; success = true; break;
				638	case e_slong: m_data.slong = m_data.slonglong; success = true; break;
				639	case e_ulong: m_data.ulong = m_data.slonglong; success = true; break;
				640	case e_slonglong: success = true; break;
				641	case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
				642	case e_float: m_data.flt = m_data.slonglong; success = true; break;
				643	case e_double: m_data.dbl = m_data.slonglong; success = true; break;
				644	case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
				645	}
				646	break;
				647
				648	case e_ulonglong:
				649	switch (type)
				650	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	651	case e_void:
				652	case e_sint: m_data.sint = m_data.ulonglong; success = true; break;
				653	case e_uint: m_data.uint = m_data.ulonglong; success = true; break;
				654	case e_slong: m_data.slong = m_data.ulonglong; success = true; break;
				655	case e_ulong: m_data.ulong = m_data.ulonglong; success = true; break;
				656	case e_slonglong: m_data.slonglong = m_data.ulonglong; success = true; break;
				657	case e_ulonglong: success = true; break;
				658	case e_float: m_data.flt = m_data.ulonglong; success = true; break;
				659	case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
				660	case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
				661	}
				662	break;
				663
				664	case e_float:
				665	switch (type)
				666	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	667	case e_void:
				668	case e_sint: m_data.sint = m_data.flt; success = true; break;
				669	case e_uint: m_data.uint = m_data.flt; success = true; break;
				670	case e_slong: m_data.slong = m_data.flt; success = true; break;
				671	case e_ulong: m_data.ulong = m_data.flt; success = true; break;
				672	case e_slonglong: m_data.slonglong = m_data.flt; success = true; break;
				673	case e_ulonglong: m_data.ulonglong = m_data.flt; success = true; break;
				674	case e_float: success = true; break;
				675	case e_double: m_data.dbl = m_data.flt; success = true; break;
				676	case e_long_double: m_data.ldbl = m_data.flt; success = true; break;
				677	}
				678	break;
				679
				680	case e_double:
				681	switch (type)
				682	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	683	case e_void:
				684	case e_sint: m_data.sint = m_data.dbl; success = true; break;
				685	case e_uint: m_data.uint = m_data.dbl; success = true; break;
				686	case e_slong: m_data.slong = m_data.dbl; success = true; break;
				687	case e_ulong: m_data.ulong = m_data.dbl; success = true; break;
				688	case e_slonglong: m_data.slonglong = m_data.dbl; success = true; break;
				689	case e_ulonglong: m_data.ulonglong = m_data.dbl; success = true; break;
				690	case e_float: m_data.flt = m_data.dbl; success = true; break;
				691	case e_double: success = true; break;
				692	case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
				693	}
				694	break;
				695
				696	case e_long_double:
				697	switch (type)
				698	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	699	case e_void:
				700	case e_sint: m_data.sint = m_data.ldbl; success = true; break;
				701	case e_uint: m_data.uint = m_data.ldbl; success = true; break;
				702	case e_slong: m_data.slong = m_data.ldbl; success = true; break;
				703	case e_ulong: m_data.ulong = m_data.ldbl; success = true; break;
				704	case e_slonglong: m_data.slonglong = m_data.ldbl; success = true; break;
				705	case e_ulonglong: m_data.ulonglong = m_data.ldbl; success = true; break;
				706	case e_float: m_data.flt = m_data.ldbl; success = true; break;
				707	case e_double: m_data.dbl = m_data.ldbl; success = true; break;
				708	case e_long_double: success = true; break;
				709	}
				710	break;
				711	}
				712
				713	if (success)
				714	m_type = type;
				715	return success;
				716	}
				717
				718	int
				719	Scalar::SInt(int fail_value) const
				720	{
				721	switch (m_type)
				722	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	723	case e_void: break;
				724	case e_sint: return m_data.sint;
				725	case e_uint: return (int)m_data.uint;
				726	case e_slong: return (int)m_data.slong;
				727	case e_ulong: return (int)m_data.ulong;
				728	case e_slonglong: return (int)m_data.slonglong;
				729	case e_ulonglong: return (int)m_data.ulonglong;
				730	case e_float: return (int)m_data.flt;
				731	case e_double: return (int)m_data.dbl;
				732	case e_long_double: return (int)m_data.ldbl;
				733	}
				734	return fail_value;
				735	}
				736
				737	unsigned int
				738	Scalar::UInt(unsigned int fail_value) const
				739	{
				740	switch (m_type)
				741	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	742	case e_void: break;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	743	case e_sint: return (unsigned int)m_data.sint;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	744	case e_uint: return (unsigned int)m_data.uint;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	745	case e_slong: return (unsigned int)m_data.slong;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	746	case e_ulong: return (unsigned int)m_data.ulong;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	747	case e_slonglong: return (unsigned int)m_data.slonglong;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	748	case e_ulonglong: return (unsigned int)m_data.ulonglong;
				749	case e_float: return (unsigned int)m_data.flt;
				750	case e_double: return (unsigned int)m_data.dbl;
				751	case e_long_double: return (unsigned int)m_data.ldbl;
				752	}
				753	return fail_value;
				754	}
				755
				756
				757	long
				758	Scalar::SLong(long fail_value) const
				759	{
				760	switch (m_type)
				761	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	762	case e_void: break;
				763	case e_sint: return (long)m_data.sint;
				764	case e_uint: return (long)m_data.uint;
				765	case e_slong: return (long)m_data.slong;
				766	case e_ulong: return (long)m_data.ulong;
				767	case e_slonglong: return (long)m_data.slonglong;
				768	case e_ulonglong: return (long)m_data.ulonglong;
				769	case e_float: return (long)m_data.flt;
				770	case e_double: return (long)m_data.dbl;
				771	case e_long_double: return (long)m_data.ldbl;
				772	}
				773	return fail_value;
				774	}
				775
				776
				777
				778	unsigned long
				779	Scalar::ULong(unsigned long fail_value) const
				780	{
				781	switch (m_type)
				782	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	783	case e_void: break;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	784	case e_sint: return (unsigned long)m_data.sint;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	785	case e_uint: return (unsigned long)m_data.uint;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	786	case e_slong: return (unsigned long)m_data.slong;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	787	case e_ulong: return (unsigned long)m_data.ulong;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	788	case e_slonglong: return (unsigned long)m_data.slonglong;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	789	case e_ulonglong: return (unsigned long)m_data.ulonglong;
				790	case e_float: return (unsigned long)m_data.flt;
				791	case e_double: return (unsigned long)m_data.dbl;
				792	case e_long_double: return (unsigned long)m_data.ldbl;
				793	}
				794	return fail_value;
				795	}
				796
				797	uint64_t
				798	Scalar::GetRawBits64(uint64_t fail_value) const
				799	{
				800	switch (m_type)
				801	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	802	case e_void:
				803	break;
				804
				805	case e_sint:
				806	case e_uint:
				807	return m_data.uint;
				808
				809	case e_slong:
				810	case e_ulong:
				811	return m_data.ulong;
				812
				813	case e_slonglong:
				814	case e_ulonglong:
				815	return m_data.ulonglong;
				816
				817	case e_float:
				818	if (sizeof(m_data.flt) == sizeof(int))
				819	return m_data.uint;
				820	else if (sizeof(m_data.flt) == sizeof(unsigned long))
				821	return m_data.ulong;
				822	else if (sizeof(m_data.flt) == sizeof(unsigned long long))
				823	return m_data.ulonglong;
				824	break;
				825
				826	case e_double:
				827	if (sizeof(m_data.dbl) == sizeof(int))
				828	return m_data.uint;
				829	else if (sizeof(m_data.dbl) == sizeof(unsigned long))
				830	return m_data.ulong;
				831	else if (sizeof(m_data.dbl) == sizeof(unsigned long long))
				832	return m_data.ulonglong;
				833	break;
				834
				835	case e_long_double:
				836	if (sizeof(m_data.ldbl) == sizeof(int))
				837	return m_data.uint;
				838	else if (sizeof(m_data.ldbl) == sizeof(unsigned long))
				839	return m_data.ulong;
				840	else if (sizeof(m_data.ldbl) == sizeof(unsigned long long))
				841	return m_data.ulonglong;
				842	break;
				843	}
				844	return fail_value;
				845	}
				846
				847
				848
				849	long long
				850	Scalar::SLongLong(long long fail_value) const
				851	{
				852	switch (m_type)
				853	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	854	case e_void: break;
				855	case e_sint: return (long long)m_data.sint;
				856	case e_uint: return (long long)m_data.uint;
				857	case e_slong: return (long long)m_data.slong;
				858	case e_ulong: return (long long)m_data.ulong;
				859	case e_slonglong: return (long long)m_data.slonglong;
				860	case e_ulonglong: return (long long)m_data.ulonglong;
				861	case e_float: return (long long)m_data.flt;
				862	case e_double: return (long long)m_data.dbl;
				863	case e_long_double: return (long long)m_data.ldbl;
				864	}
				865	return fail_value;
				866	}
				867
				868
				869	unsigned long long
				870	Scalar::ULongLong(unsigned long long fail_value) const
				871	{
				872	switch (m_type)
				873	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	874	case e_void: break;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	875	case e_sint: return (unsigned long long)m_data.sint;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	876	case e_uint: return (unsigned long long)m_data.uint;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	877	case e_slong: return (unsigned long long)m_data.slong;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	878	case e_ulong: return (unsigned long long)m_data.ulong;
Enrico Granata	671dd55	2012-10-24 21:42:49 +0000	[diff] [blame]	879	case e_slonglong: return (unsigned long long)m_data.slonglong;
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	880	case e_ulonglong: return (unsigned long long)m_data.ulonglong;
				881	case e_float: return (unsigned long long)m_data.flt;
				882	case e_double: return (unsigned long long)m_data.dbl;
				883	case e_long_double: return (unsigned long long)m_data.ldbl;
				884	}
				885	return fail_value;
				886	}
				887
				888
				889	float
				890	Scalar::Float(float fail_value) const
				891	{
				892	switch (m_type)
				893	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	894	case e_void: break;
				895	case e_sint: return (float)m_data.sint;
				896	case e_uint: return (float)m_data.uint;
				897	case e_slong: return (float)m_data.slong;
				898	case e_ulong: return (float)m_data.ulong;
				899	case e_slonglong: return (float)m_data.slonglong;
				900	case e_ulonglong: return (float)m_data.ulonglong;
				901	case e_float: return (float)m_data.flt;
				902	case e_double: return (float)m_data.dbl;
				903	case e_long_double: return (float)m_data.ldbl;
				904	}
				905	return fail_value;
				906	}
				907
				908
				909	double
				910	Scalar::Double(double fail_value) const
				911	{
				912	switch (m_type)
				913	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	914	case e_void: break;
				915	case e_sint: return (double)m_data.sint;
				916	case e_uint: return (double)m_data.uint;
				917	case e_slong: return (double)m_data.slong;
				918	case e_ulong: return (double)m_data.ulong;
				919	case e_slonglong: return (double)m_data.slonglong;
				920	case e_ulonglong: return (double)m_data.ulonglong;
				921	case e_float: return (double)m_data.flt;
				922	case e_double: return (double)m_data.dbl;
				923	case e_long_double: return (double)m_data.ldbl;
				924	}
				925	return fail_value;
				926	}
				927
				928
				929	long double
				930	Scalar::LongDouble(long double fail_value) const
				931	{
				932	switch (m_type)
				933	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	934	case e_void: break;
				935	case e_sint: return (long double)m_data.sint;
				936	case e_uint: return (long double)m_data.uint;
				937	case e_slong: return (long double)m_data.slong;
				938	case e_ulong: return (long double)m_data.ulong;
				939	case e_slonglong: return (long double)m_data.slonglong;
				940	case e_ulonglong: return (long double)m_data.ulonglong;
				941	case e_float: return (long double)m_data.flt;
				942	case e_double: return (long double)m_data.dbl;
				943	case e_long_double: return (long double)m_data.ldbl;
				944	}
				945	return fail_value;
				946	}
				947
				948
				949	Scalar&
				950	Scalar::operator+= (const Scalar& rhs)
				951	{
				952	Scalar temp_value;
				953	const Scalar* a;
				954	const Scalar* b;
				955	if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
				956	{
				957	switch (m_type)
				958	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	959	case e_void: break;
				960	case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break;
				961	case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break;
				962	case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break;
				963	case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
				964	case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
				965	case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
				966	case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break;
				967	case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
				968	case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
				969	}
				970	}
				971	return *this;
				972	}
				973
				974	Scalar&
				975	Scalar::operator<<= (const Scalar& rhs)
				976	{
				977	switch (m_type)
				978	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	979	case e_void:
				980	case e_float:
				981	case e_double:
				982	case e_long_double:
				983	m_type = e_void;
				984	break;
				985
				986	case e_sint:
				987	switch (rhs.m_type)
				988	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	989	case e_void:
				990	case e_float:
				991	case e_double:
				992	case e_long_double:
				993	m_type = e_void;
				994	break;
				995	case e_sint: m_data.sint <<= rhs.m_data.sint; break;
				996	case e_uint: m_data.sint <<= rhs.m_data.uint; break;
				997	case e_slong: m_data.sint <<= rhs.m_data.slong; break;
				998	case e_ulong: m_data.sint <<= rhs.m_data.ulong; break;
				999	case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break;
				1000	case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break;
				1001	}
				1002	break;
				1003
				1004	case e_uint:
				1005	switch (rhs.m_type)
				1006	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1007	case e_void:
				1008	case e_float:
				1009	case e_double:
				1010	case e_long_double:
				1011	m_type = e_void;
				1012	break;
				1013	case e_sint: m_data.uint <<= rhs.m_data.sint; break;
				1014	case e_uint: m_data.uint <<= rhs.m_data.uint; break;
				1015	case e_slong: m_data.uint <<= rhs.m_data.slong; break;
				1016	case e_ulong: m_data.uint <<= rhs.m_data.ulong; break;
				1017	case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break;
				1018	case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break;
				1019	}
				1020	break;
				1021
				1022	case e_slong:
				1023	switch (rhs.m_type)
				1024	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1025	case e_void:
				1026	case e_float:
				1027	case e_double:
				1028	case e_long_double:
				1029	m_type = e_void;
				1030	break;
				1031	case e_sint: m_data.slong <<= rhs.m_data.sint; break;
				1032	case e_uint: m_data.slong <<= rhs.m_data.uint; break;
				1033	case e_slong: m_data.slong <<= rhs.m_data.slong; break;
				1034	case e_ulong: m_data.slong <<= rhs.m_data.ulong; break;
				1035	case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break;
				1036	case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break;
				1037	}
				1038	break;
				1039
				1040	case e_ulong:
				1041	switch (rhs.m_type)
				1042	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1043	case e_void:
				1044	case e_float:
				1045	case e_double:
				1046	case e_long_double:
				1047	m_type = e_void;
				1048	break;
				1049	case e_sint: m_data.ulong <<= rhs.m_data.sint; break;
				1050	case e_uint: m_data.ulong <<= rhs.m_data.uint; break;
				1051	case e_slong: m_data.ulong <<= rhs.m_data.slong; break;
				1052	case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break;
				1053	case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break;
				1054	case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break;
				1055	}
				1056	break;
				1057	case e_slonglong:
				1058	switch (rhs.m_type)
				1059	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1060	case e_void:
				1061	case e_float:
				1062	case e_double:
				1063	case e_long_double:
				1064	m_type = e_void;
				1065	break;
				1066	case e_sint: m_data.slonglong <<= rhs.m_data.sint; break;
				1067	case e_uint: m_data.slonglong <<= rhs.m_data.uint; break;
				1068	case e_slong: m_data.slonglong <<= rhs.m_data.slong; break;
				1069	case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break;
				1070	case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break;
				1071	case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break;
				1072	}
				1073	break;
				1074
				1075	case e_ulonglong:
				1076	switch (rhs.m_type)
				1077	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1078	case e_void:
				1079	case e_float:
				1080	case e_double:
				1081	case e_long_double:
				1082	m_type = e_void;
				1083	break;
				1084	case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break;
				1085	case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break;
				1086	case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break;
				1087	case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break;
				1088	case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break;
				1089	case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break;
				1090	}
				1091	break;
				1092	}
				1093	return *this;
				1094	}
				1095
				1096	bool
				1097	Scalar::ShiftRightLogical(const Scalar& rhs)
				1098	{
				1099	switch (m_type)
				1100	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1101	case e_void:
				1102	case e_float:
				1103	case e_double:
				1104	case e_long_double:
				1105	m_type = e_void;
				1106	break;
				1107
				1108	case e_sint:
				1109	case e_uint:
				1110	switch (rhs.m_type)
				1111	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1112	case e_void:
				1113	case e_float:
				1114	case e_double:
				1115	case e_long_double:
				1116	m_type = e_void;
				1117	break;
				1118	case e_sint: m_data.uint >>= rhs.m_data.sint; break;
				1119	case e_uint: m_data.uint >>= rhs.m_data.uint; break;
				1120	case e_slong: m_data.uint >>= rhs.m_data.slong; break;
				1121	case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
				1122	case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
				1123	case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
				1124	}
				1125	break;
				1126
				1127	case e_slong:
				1128	case e_ulong:
				1129	switch (rhs.m_type)
				1130	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1131	case e_void:
				1132	case e_float:
				1133	case e_double:
				1134	case e_long_double:
				1135	m_type = e_void;
				1136	break;
				1137	case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
				1138	case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
				1139	case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
				1140	case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
				1141	case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
				1142	case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
				1143	}
				1144	break;
				1145
				1146	case e_slonglong:
				1147	case e_ulonglong:
				1148	switch (rhs.m_type)
				1149	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1150	case e_void:
				1151	case e_float:
				1152	case e_double:
				1153	case e_long_double:
				1154	m_type = e_void;
				1155	break;
				1156	case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
				1157	case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
				1158	case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
				1159	case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
				1160	case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
				1161	case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
				1162	}
				1163	break;
				1164	}
				1165	return m_type != e_void;
				1166	}
				1167
				1168
				1169	Scalar&
				1170	Scalar::operator>>= (const Scalar& rhs)
				1171	{
				1172	switch (m_type)
				1173	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1174	case e_void:
				1175	case e_float:
				1176	case e_double:
				1177	case e_long_double:
				1178	m_type = e_void;
				1179	break;
				1180
				1181	case e_sint:
				1182	switch (rhs.m_type)
				1183	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1184	case e_void:
				1185	case e_float:
				1186	case e_double:
				1187	case e_long_double:
				1188	m_type = e_void;
				1189	break;
				1190	case e_sint: m_data.sint >>= rhs.m_data.sint; break;
				1191	case e_uint: m_data.sint >>= rhs.m_data.uint; break;
				1192	case e_slong: m_data.sint >>= rhs.m_data.slong; break;
				1193	case e_ulong: m_data.sint >>= rhs.m_data.ulong; break;
				1194	case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break;
				1195	case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break;
				1196	}
				1197	break;
				1198
				1199	case e_uint:
				1200	switch (rhs.m_type)
				1201	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1202	case e_void:
				1203	case e_float:
				1204	case e_double:
				1205	case e_long_double:
				1206	m_type = e_void;
				1207	break;
				1208	case e_sint: m_data.uint >>= rhs.m_data.sint; break;
				1209	case e_uint: m_data.uint >>= rhs.m_data.uint; break;
				1210	case e_slong: m_data.uint >>= rhs.m_data.slong; break;
				1211	case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
				1212	case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
				1213	case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
				1214	}
				1215	break;
				1216
				1217	case e_slong:
				1218	switch (rhs.m_type)
				1219	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1220	case e_void:
				1221	case e_float:
				1222	case e_double:
				1223	case e_long_double:
				1224	m_type = e_void;
				1225	break;
				1226	case e_sint: m_data.slong >>= rhs.m_data.sint; break;
				1227	case e_uint: m_data.slong >>= rhs.m_data.uint; break;
				1228	case e_slong: m_data.slong >>= rhs.m_data.slong; break;
				1229	case e_ulong: m_data.slong >>= rhs.m_data.ulong; break;
				1230	case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break;
				1231	case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break;
				1232	}
				1233	break;
				1234
				1235	case e_ulong:
				1236	switch (rhs.m_type)
				1237	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1238	case e_void:
				1239	case e_float:
				1240	case e_double:
				1241	case e_long_double:
				1242	m_type = e_void;
				1243	break;
				1244	case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
				1245	case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
				1246	case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
				1247	case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
				1248	case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
				1249	case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
				1250	}
				1251	break;
				1252	case e_slonglong:
				1253	switch (rhs.m_type)
				1254	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1255	case e_void:
				1256	case e_float:
				1257	case e_double:
				1258	case e_long_double:
				1259	m_type = e_void;
				1260	break;
				1261	case e_sint: m_data.slonglong >>= rhs.m_data.sint; break;
				1262	case e_uint: m_data.slonglong >>= rhs.m_data.uint; break;
				1263	case e_slong: m_data.slonglong >>= rhs.m_data.slong; break;
				1264	case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break;
				1265	case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break;
				1266	case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break;
				1267	}
				1268	break;
				1269
				1270	case e_ulonglong:
				1271	switch (rhs.m_type)
				1272	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1273	case e_void:
				1274	case e_float:
				1275	case e_double:
				1276	case e_long_double:
				1277	m_type = e_void;
				1278	break;
				1279	case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
				1280	case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
				1281	case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
				1282	case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
				1283	case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
				1284	case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
				1285	}
				1286	break;
				1287	}
				1288	return *this;
				1289	}
				1290
				1291
				1292	Scalar&
				1293	Scalar::operator&= (const Scalar& rhs)
				1294	{
				1295	switch (m_type)
				1296	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1297	case e_void:
				1298	case e_float:
				1299	case e_double:
				1300	case e_long_double:
				1301	m_type = e_void;
				1302	break;
				1303
				1304	case e_sint:
				1305	switch (rhs.m_type)
				1306	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1307	case e_void:
				1308	case e_float:
				1309	case e_double:
				1310	case e_long_double:
				1311	m_type = e_void;
				1312	break;
				1313	case e_sint: m_data.sint &= rhs.m_data.sint; break;
				1314	case e_uint: m_data.sint &= rhs.m_data.uint; break;
				1315	case e_slong: m_data.sint &= rhs.m_data.slong; break;
				1316	case e_ulong: m_data.sint &= rhs.m_data.ulong; break;
				1317	case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break;
				1318	case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break;
				1319	}
				1320	break;
				1321
				1322	case e_uint:
				1323	switch (rhs.m_type)
				1324	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1325	case e_void:
				1326	case e_float:
				1327	case e_double:
				1328	case e_long_double:
				1329	m_type = e_void;
				1330	break;
				1331	case e_sint: m_data.uint &= rhs.m_data.sint; break;
				1332	case e_uint: m_data.uint &= rhs.m_data.uint; break;
				1333	case e_slong: m_data.uint &= rhs.m_data.slong; break;
				1334	case e_ulong: m_data.uint &= rhs.m_data.ulong; break;
				1335	case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break;
				1336	case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break;
				1337	}
				1338	break;
				1339
				1340	case e_slong:
				1341	switch (rhs.m_type)
				1342	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1343	case e_void:
				1344	case e_float:
				1345	case e_double:
				1346	case e_long_double:
				1347	m_type = e_void;
				1348	break;
				1349	case e_sint: m_data.slong &= rhs.m_data.sint; break;
				1350	case e_uint: m_data.slong &= rhs.m_data.uint; break;
				1351	case e_slong: m_data.slong &= rhs.m_data.slong; break;
				1352	case e_ulong: m_data.slong &= rhs.m_data.ulong; break;
				1353	case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break;
				1354	case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break;
				1355	}
				1356	break;
				1357
				1358	case e_ulong:
				1359	switch (rhs.m_type)
				1360	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1361	case e_void:
				1362	case e_float:
				1363	case e_double:
				1364	case e_long_double:
				1365	m_type = e_void;
				1366	break;
				1367	case e_sint: m_data.ulong &= rhs.m_data.sint; break;
				1368	case e_uint: m_data.ulong &= rhs.m_data.uint; break;
				1369	case e_slong: m_data.ulong &= rhs.m_data.slong; break;
				1370	case e_ulong: m_data.ulong &= rhs.m_data.ulong; break;
				1371	case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break;
				1372	case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break;
				1373	}
				1374	break;
				1375	case e_slonglong:
				1376	switch (rhs.m_type)
				1377	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1378	case e_void:
				1379	case e_float:
				1380	case e_double:
				1381	case e_long_double:
				1382	m_type = e_void;
				1383	break;
				1384	case e_sint: m_data.slonglong &= rhs.m_data.sint; break;
				1385	case e_uint: m_data.slonglong &= rhs.m_data.uint; break;
				1386	case e_slong: m_data.slonglong &= rhs.m_data.slong; break;
				1387	case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break;
				1388	case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break;
				1389	case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break;
				1390	}
				1391	break;
				1392
				1393	case e_ulonglong:
				1394	switch (rhs.m_type)
				1395	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1396	case e_void:
				1397	case e_float:
				1398	case e_double:
				1399	case e_long_double:
				1400	m_type = e_void;
				1401	break;
				1402	case e_sint: m_data.ulonglong &= rhs.m_data.sint; break;
				1403	case e_uint: m_data.ulonglong &= rhs.m_data.uint; break;
				1404	case e_slong: m_data.ulonglong &= rhs.m_data.slong; break;
				1405	case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break;
				1406	case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break;
				1407	case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break;
				1408	}
				1409	break;
				1410	}
				1411	return *this;
				1412	}
				1413
				1414
				1415
				1416	bool
				1417	Scalar::AbsoluteValue()
				1418	{
				1419	switch (m_type)
				1420	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1421	case e_void:
				1422	break;
				1423
				1424	case e_sint:
				1425	if (m_data.sint < 0)
				1426	m_data.sint = -m_data.sint;
				1427	return true;
				1428
				1429	case e_slong:
				1430	if (m_data.slong < 0)
				1431	m_data.slong = -m_data.slong;
				1432	return true;
				1433
				1434	case e_slonglong:
				1435	if (m_data.slonglong < 0)
				1436	m_data.slonglong = -m_data.slonglong;
				1437	return true;
				1438
				1439	case e_uint:
				1440	case e_ulong:
				1441	case e_ulonglong: return true;
				1442	case e_float: m_data.flt = fabsf(m_data.flt); return true;
				1443	case e_double: m_data.dbl = fabs(m_data.dbl); return true;
				1444	case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true;
				1445	}
				1446	return false;
				1447	}
				1448
				1449
				1450	bool
				1451	Scalar::UnaryNegate()
				1452	{
				1453	switch (m_type)
				1454	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1455	case e_void: break;
				1456	case e_sint: m_data.sint = -m_data.sint; return true;
				1457	case e_uint: m_data.uint = -m_data.uint; return true;
				1458	case e_slong: m_data.slong = -m_data.slong; return true;
				1459	case e_ulong: m_data.ulong = -m_data.ulong; return true;
				1460	case e_slonglong: m_data.slonglong = -m_data.slonglong; return true;
				1461	case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true;
				1462	case e_float: m_data.flt = -m_data.flt; return true;
				1463	case e_double: m_data.dbl = -m_data.dbl; return true;
				1464	case e_long_double: m_data.ldbl = -m_data.ldbl; return true;
				1465	}
				1466	return false;
				1467	}
				1468
				1469	bool
				1470	Scalar::OnesComplement()
				1471	{
				1472	switch (m_type)
				1473	{
				1474	case e_sint: m_data.sint = ~m_data.sint; return true;
				1475	case e_uint: m_data.uint = ~m_data.uint; return true;
				1476	case e_slong: m_data.slong = ~m_data.slong; return true;
				1477	case e_ulong: m_data.ulong = ~m_data.ulong; return true;
				1478	case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true;
				1479	case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true;
				1480
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1481	case e_void:
				1482	case e_float:
				1483	case e_double:
				1484	case e_long_double:
				1485	break;
				1486	}
				1487	return false;
				1488	}
				1489
				1490
				1491	const Scalar
				1492	lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
				1493	{
				1494	Scalar result;
				1495	Scalar temp_value;
				1496	const Scalar* a;
				1497	const Scalar* b;
				1498	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1499	{
				1500	switch (result.m_type)
				1501	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1502	case Scalar::e_void: break;
				1503	case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break;
				1504	case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break;
				1505	case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break;
				1506	case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
				1507	case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
				1508	case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
				1509	case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break;
				1510	case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
				1511	case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
				1512	}
				1513	}
				1514	return result;
				1515	}
				1516
				1517
				1518	const Scalar
				1519	lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
				1520	{
				1521	Scalar result;
				1522	Scalar temp_value;
				1523	const Scalar* a;
				1524	const Scalar* b;
				1525	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1526	{
				1527	switch (result.m_type)
				1528	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1529	case Scalar::e_void: break;
				1530	case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break;
				1531	case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break;
				1532	case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break;
				1533	case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break;
				1534	case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break;
				1535	case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break;
				1536	case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break;
				1537	case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break;
				1538	case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break;
				1539	}
				1540	}
				1541	return result;
				1542	}
				1543
				1544	const Scalar
				1545	lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
				1546	{
				1547	Scalar result;
				1548	Scalar temp_value;
				1549	const Scalar* a;
				1550	const Scalar* b;
				1551	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1552	{
				1553	switch (result.m_type)
				1554	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1555	case Scalar::e_void: break;
				1556
				1557	case Scalar::e_sint: if (b->m_data.sint != 0) { result.m_data.sint = a->m_data.sint/ b->m_data.sint; return result; } break;
				1558	case Scalar::e_uint: if (b->m_data.uint != 0) { result.m_data.uint = a->m_data.uint / b->m_data.uint; return result; } break;
				1559	case Scalar::e_slong: if (b->m_data.slong != 0) { result.m_data.slong = a->m_data.slong / b->m_data.slong; return result; } break;
				1560	case Scalar::e_ulong: if (b->m_data.ulong != 0) { result.m_data.ulong = a->m_data.ulong / b->m_data.ulong; return result; } break;
				1561	case Scalar::e_slonglong: if (b->m_data.slonglong != 0) { result.m_data.slonglong = a->m_data.slonglong / b->m_data.slonglong; return result; } break;
				1562	case Scalar::e_ulonglong: if (b->m_data.ulonglong != 0) { result.m_data.ulonglong = a->m_data.ulonglong / b->m_data.ulonglong; return result; } break;
				1563	case Scalar::e_float: if (b->m_data.flt != 0.0f) { result.m_data.flt = a->m_data.flt / b->m_data.flt; return result; } break;
				1564	case Scalar::e_double: if (b->m_data.dbl != 0.0) { result.m_data.dbl = a->m_data.dbl / b->m_data.dbl; return result; } break;
				1565	case Scalar::e_long_double: if (b->m_data.ldbl != 0.0) { result.m_data.ldbl = a->m_data.ldbl / b->m_data.ldbl; return result; } break;
				1566	}
				1567	}
				1568	// For division only, the only way it should make it here is if a promotion failed,
				1569	// or if we are trying to do a divide by zero.
				1570	result.m_type = Scalar::e_void;
				1571	return result;
				1572	}
				1573
				1574	const Scalar
				1575	lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
				1576	{
				1577	Scalar result;
				1578	Scalar temp_value;
				1579	const Scalar* a;
				1580	const Scalar* b;
				1581	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1582	{
				1583	switch (result.m_type)
				1584	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1585	case Scalar::e_void: break;
				1586	case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break;
				1587	case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break;
				1588	case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break;
				1589	case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break;
				1590	case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break;
				1591	case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break;
				1592	case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break;
				1593	case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break;
				1594	case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break;
				1595	}
				1596	}
				1597	return result;
				1598	}
				1599
				1600	const Scalar
				1601	lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
				1602	{
				1603	Scalar result;
				1604	Scalar temp_value;
				1605	const Scalar* a;
				1606	const Scalar* b;
				1607	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1608	{
				1609	switch (result.m_type)
				1610	{
				1611	case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break;
				1612	case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break;
				1613	case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break;
				1614	case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break;
				1615	case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break;
				1616	case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break;
				1617
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1618	case Scalar::e_void:
				1619	case Scalar::e_float:
				1620	case Scalar::e_double:
				1621	case Scalar::e_long_double:
				1622	// No bitwise AND on floats, doubles of long doubles
				1623	result.m_type = Scalar::e_void;
				1624	break;
				1625	}
				1626	}
				1627	return result;
				1628	}
				1629
				1630	const Scalar
				1631	lldb_private::operator\| (const Scalar& lhs, const Scalar& rhs)
				1632	{
				1633	Scalar result;
				1634	Scalar temp_value;
				1635	const Scalar* a;
				1636	const Scalar* b;
				1637	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1638	{
				1639	switch (result.m_type)
				1640	{
				1641	case Scalar::e_sint: result.m_data.sint = a->m_data.sint \| b->m_data.sint; break;
				1642	case Scalar::e_uint: result.m_data.uint = a->m_data.uint \| b->m_data.uint; break;
				1643	case Scalar::e_slong: result.m_data.slong = a->m_data.slong \| b->m_data.slong; break;
				1644	case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong \| b->m_data.ulong; break;
				1645	case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong \| b->m_data.slonglong; break;
				1646	case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong \| b->m_data.ulonglong; break;
				1647
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1648	case Scalar::e_void:
				1649	case Scalar::e_float:
				1650	case Scalar::e_double:
				1651	case Scalar::e_long_double:
				1652	// No bitwise AND on floats, doubles of long doubles
				1653	result.m_type = Scalar::e_void;
				1654	break;
				1655	}
				1656	}
				1657	return result;
				1658	}
				1659
				1660	const Scalar
				1661	lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
				1662	{
				1663	Scalar result;
				1664	Scalar temp_value;
				1665	const Scalar* a;
				1666	const Scalar* b;
				1667	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1668	{
				1669	switch (result.m_type)
				1670	{
				1671	case Scalar::e_sint: result.m_data.sint = a->m_data.sint % b->m_data.sint; break;
				1672	case Scalar::e_uint: result.m_data.uint = a->m_data.uint % b->m_data.uint; break;
				1673	case Scalar::e_slong: result.m_data.slong = a->m_data.slong % b->m_data.slong; break;
				1674	case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong % b->m_data.ulong; break;
				1675	case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong % b->m_data.slonglong; break;
				1676	case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong % b->m_data.ulonglong; break;
				1677
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1678	case Scalar::e_void:
				1679	case Scalar::e_float:
				1680	case Scalar::e_double:
				1681	case Scalar::e_long_double:
				1682	// No bitwise AND on floats, doubles of long doubles
				1683	result.m_type = Scalar::e_void;
				1684	break;
				1685	}
				1686	}
				1687	return result;
				1688	}
				1689
				1690	const Scalar
				1691	lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
				1692	{
				1693	Scalar result;
				1694	Scalar temp_value;
				1695	const Scalar* a;
				1696	const Scalar* b;
				1697	if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
				1698	{
				1699	switch (result.m_type)
				1700	{
				1701	case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break;
				1702	case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break;
				1703	case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break;
				1704	case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break;
				1705	case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break;
				1706	case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break;
				1707
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1708	case Scalar::e_void:
				1709	case Scalar::e_float:
				1710	case Scalar::e_double:
				1711	case Scalar::e_long_double:
				1712	// No bitwise AND on floats, doubles of long doubles
				1713	result.m_type = Scalar::e_void;
				1714	break;
				1715	}
				1716	}
				1717	return result;
				1718	}
				1719
				1720	// Return the raw unsigned integer without any casting or conversion
				1721	unsigned int
				1722	Scalar::RawUInt () const
				1723	{
				1724	return m_data.uint;
				1725	}
				1726
				1727	// Return the raw unsigned long without any casting or conversion
				1728	unsigned long
				1729	Scalar::RawULong () const
				1730	{
				1731	return m_data.ulong;
				1732	}
				1733
				1734	// Return the raw unsigned long long without any casting or conversion
				1735	unsigned long long
				1736	Scalar::RawULongLong () const
				1737	{
				1738	return m_data.ulonglong;
				1739	}
				1740
				1741
				1742	Error
				1743	Scalar::SetValueFromCString (const char *value_str, Encoding encoding, uint32_t byte_size)
				1744	{
				1745	Error error;
Johnny Chen	b822658	2011-08-11 19:12:10 +0000	[diff] [blame]	1746	if (value_str == NULL \|\| value_str[0] == '\0')
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1747	{
				1748	error.SetErrorString ("Invalid c-string value string.");
				1749	return error;
				1750	}
				1751	bool success = false;
				1752	switch (encoding)
				1753	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1754	case eEncodingInvalid:
				1755	error.SetErrorString ("Invalid encoding.");
				1756	break;
				1757
				1758	case eEncodingUint:
				1759	if (byte_size <= sizeof (unsigned long long))
				1760	{
				1761	uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
				1762	if (!success)
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1763	error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1764	else if (!UIntValueIsValidForSize (uval64, byte_size))
Daniel Malea	5f35a4b	2012-11-29 21:49:15 +0000	[diff] [blame]	1765	error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte unsigned integer value", uval64, byte_size);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1766	else
				1767	{
				1768	m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
				1769	switch (m_type)
				1770	{
				1771	case e_uint: m_data.uint = uval64; break;
				1772	case e_ulong: m_data.ulong = uval64; break;
				1773	case e_ulonglong: m_data.ulonglong = uval64; break;
				1774	default:
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1775	error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1776	break;
				1777	}
				1778	}
				1779	}
				1780	else
				1781	{
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1782	error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1783	return error;
				1784	}
				1785	break;
				1786
				1787	case eEncodingSint:
				1788	if (byte_size <= sizeof (long long))
				1789	{
				1790	uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
				1791	if (!success)
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1792	error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1793	else if (!SIntValueIsValidForSize (sval64, byte_size))
Daniel Malea	5f35a4b	2012-11-29 21:49:15 +0000	[diff] [blame]	1794	error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte signed integer value", sval64, byte_size);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1795	else
				1796	{
				1797	m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
				1798	switch (m_type)
				1799	{
				1800	case e_sint: m_data.sint = sval64; break;
				1801	case e_slong: m_data.slong = sval64; break;
				1802	case e_slonglong: m_data.slonglong = sval64; break;
				1803	default:
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1804	error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1805	break;
				1806	}
				1807	}
				1808	}
				1809	else
				1810	{
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1811	error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1812	return error;
				1813	}
				1814	break;
				1815
				1816	case eEncodingIEEE754:
				1817	if (byte_size == sizeof (float))
				1818	{
				1819	if (::sscanf (value_str, "%f", &m_data.flt) == 1)
				1820	m_type = e_float;
				1821	else
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1822	error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1823	}
				1824	else if (byte_size == sizeof (double))
				1825	{
				1826	if (::sscanf (value_str, "%lf", &m_data.dbl) == 1)
				1827	m_type = e_double;
				1828	else
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1829	error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1830	}
				1831	else if (byte_size == sizeof (long double))
				1832	{
				1833	if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1)
				1834	m_type = e_long_double;
				1835	else
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1836	error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1837	}
				1838	else
				1839	{
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1840	error.SetErrorStringWithFormat ("unsupported float byte size: %u", byte_size);
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1841	return error;
				1842	}
				1843	break;
				1844
				1845	case eEncodingVector:
Greg Clayton	9c23673	2011-10-26 00:56:27 +0000	[diff] [blame]	1846	error.SetErrorString ("vector encoding unsupported.");
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	1847	break;
				1848	}
				1849	if (error.Fail())
				1850	m_type = e_void;
				1851
				1852	return error;
				1853	}
				1854
				1855	bool
Greg Clayton	5fba9ee	2011-05-19 00:17:26 +0000	[diff] [blame]	1856	Scalar::SignExtend (uint32_t sign_bit_pos)
				1857	{
				1858	const uint32_t max_bit_pos = GetByteSize() * 8;
				1859
				1860	if (sign_bit_pos < max_bit_pos)
				1861	{
				1862	switch (m_type)
				1863	{
Greg Clayton	5fba9ee	2011-05-19 00:17:26 +0000	[diff] [blame]	1864	case Scalar::e_void:
				1865	case Scalar::e_float:
				1866	case Scalar::e_double:
				1867	case Scalar::e_long_double:
				1868	return false;
				1869
				1870	case Scalar::e_sint:
				1871	case Scalar::e_uint:
				1872	if (max_bit_pos == sign_bit_pos)
				1873	return true;
				1874	else if (sign_bit_pos < (max_bit_pos-1))
				1875	{
				1876	unsigned int sign_bit = 1u << sign_bit_pos;
				1877	if (m_data.uint & sign_bit)
				1878	{
				1879	const unsigned int mask = ~(sign_bit) + 1u;
				1880	m_data.uint \|= mask;
				1881	}
				1882	return true;
				1883	}
				1884	break;
				1885
				1886	case Scalar::e_slong:
				1887	case Scalar::e_ulong:
				1888	if (max_bit_pos == sign_bit_pos)
				1889	return true;
				1890	else if (sign_bit_pos < (max_bit_pos-1))
				1891	{
				1892	unsigned long sign_bit = 1ul << sign_bit_pos;
Greg Clayton	4e56cd9	2011-05-19 00:55:50 +0000	[diff] [blame]	1893	if (m_data.ulong & sign_bit)
Greg Clayton	5fba9ee	2011-05-19 00:17:26 +0000	[diff] [blame]	1894	{
				1895	const unsigned long mask = ~(sign_bit) + 1ul;
Greg Clayton	4e56cd9	2011-05-19 00:55:50 +0000	[diff] [blame]	1896	m_data.ulong \|= mask;
Greg Clayton	5fba9ee	2011-05-19 00:17:26 +0000	[diff] [blame]	1897	}
				1898	return true;
				1899	}
				1900	break;
				1901
				1902	case Scalar::e_slonglong:
				1903	case Scalar::e_ulonglong:
				1904	if (max_bit_pos == sign_bit_pos)
				1905	return true;
				1906	else if (sign_bit_pos < (max_bit_pos-1))
				1907	{
				1908	unsigned long long sign_bit = 1ull << sign_bit_pos;
Greg Clayton	4e56cd9	2011-05-19 00:55:50 +0000	[diff] [blame]	1909	if (m_data.ulonglong & sign_bit)
Greg Clayton	5fba9ee	2011-05-19 00:17:26 +0000	[diff] [blame]	1910	{
				1911	const unsigned long long mask = ~(sign_bit) + 1ull;
Greg Clayton	4e56cd9	2011-05-19 00:55:50 +0000	[diff] [blame]	1912	m_data.ulonglong \|= mask;
Greg Clayton	5fba9ee	2011-05-19 00:17:26 +0000	[diff] [blame]	1913	}
				1914	return true;
				1915	}
				1916	break;
				1917	}
				1918	}
				1919	return false;
				1920	}
				1921
Greg Clayton	c0fa533	2011-05-22 22:46:53 +0000	[diff] [blame]	1922	uint32_t
				1923	Scalar::GetAsMemoryData (void *dst,
				1924	uint32_t dst_len,
				1925	lldb::ByteOrder dst_byte_order,
				1926	Error &error) const
				1927	{
				1928	// Get a data extractor that points to the native scalar data
				1929	DataExtractor data;
				1930	if (!GetData(data))
				1931	{
				1932	error.SetErrorString ("invalid scalar value");
				1933	return 0;
				1934	}
				1935
				1936	const size_t src_len = data.GetByteSize();
				1937
				1938	// Prepare a memory buffer that contains some or all of the register value
				1939	const uint32_t bytes_copied = data.CopyByteOrderedData (0, // src offset
				1940	src_len, // src length
				1941	dst, // dst buffer
				1942	dst_len, // dst length
				1943	dst_byte_order); // dst byte order
				1944	if (bytes_copied == 0)
				1945	error.SetErrorString ("failed to copy data");
				1946
				1947	return bytes_copied;
				1948	}
				1949
Greg Clayton	5fba9ee	2011-05-19 00:17:26 +0000	[diff] [blame]	1950	bool
Greg Clayton	1716ad7	2011-12-29 01:26:56 +0000	[diff] [blame]	1951	Scalar::ExtractBitfield (uint32_t bit_size,
				1952	uint32_t bit_offset)
				1953	{
				1954	if (bit_size == 0)
				1955	return true;
				1956
				1957	uint32_t msbit = bit_offset + bit_size - 1;
				1958	uint32_t lsbit = bit_offset;
				1959	switch (m_type)
				1960	{
Greg Clayton	1716ad7	2011-12-29 01:26:56 +0000	[diff] [blame]	1961	case Scalar::e_void:
				1962	break;
				1963
				1964	case e_float:
				1965	if (sizeof(m_data.flt) == sizeof(int))
				1966	m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
				1967	else if (sizeof(m_data.flt) == sizeof(unsigned long))
				1968	m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
				1969	else if (sizeof(m_data.flt) == sizeof(unsigned long long))
				1970	m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
				1971	else
				1972	return false;
				1973	return true;
				1974
				1975	case e_double:
				1976	if (sizeof(m_data.dbl) == sizeof(int))
				1977	m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
				1978	else if (sizeof(m_data.dbl) == sizeof(unsigned long))
				1979	m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
				1980	else if (sizeof(m_data.dbl) == sizeof(unsigned long long))
				1981	m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
				1982	else
				1983	return false;
				1984	return true;
				1985
				1986	case e_long_double:
				1987	if (sizeof(m_data.ldbl) == sizeof(int))
				1988	m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
				1989	else if (sizeof(m_data.ldbl) == sizeof(unsigned long))
				1990	m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
				1991	else if (sizeof(m_data.ldbl) == sizeof(unsigned long long))
				1992	m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
				1993	else
				1994	return false;
				1995	return true;
				1996
				1997	case Scalar::e_sint:
				1998	m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
				1999	return true;
				2000
				2001	case Scalar::e_uint:
				2002	m_data.uint = UnsignedBits (m_data.uint, msbit, lsbit);
				2003	return true;
				2004
				2005	case Scalar::e_slong:
				2006	m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
				2007	return true;
				2008
				2009	case Scalar::e_ulong:
				2010	m_data.ulong = SignedBits (m_data.ulong, msbit, lsbit);
				2011	return true;
				2012
				2013	case Scalar::e_slonglong:
				2014	m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
				2015	return true;
				2016
				2017	case Scalar::e_ulonglong:
				2018	m_data.ulonglong = SignedBits (m_data.ulonglong, msbit, lsbit);
				2019	return true;
				2020	}
				2021	return false;
				2022	}
				2023
				2024
				2025
				2026
				2027
				2028	bool
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	2029	lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
				2030	{
				2031	// If either entry is void then we can just compare the types
				2032	if (lhs.m_type == Scalar::e_void \|\| rhs.m_type == Scalar::e_void)
				2033	return lhs.m_type == rhs.m_type;
				2034
				2035	Scalar temp_value;
				2036	const Scalar* a;
				2037	const Scalar* b;
				2038	switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
				2039	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	2040	case Scalar::e_void: break;
				2041	case Scalar::e_sint: return a->m_data.sint == b->m_data.sint;
				2042	case Scalar::e_uint: return a->m_data.uint == b->m_data.uint;
				2043	case Scalar::e_slong: return a->m_data.slong == b->m_data.slong;
				2044	case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong;
				2045	case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong;
				2046	case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong;
				2047	case Scalar::e_float: return a->m_data.flt == b->m_data.flt;
				2048	case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl;
				2049	case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl;
				2050	}
				2051	return false;
				2052	}
				2053
				2054	bool
				2055	lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
				2056	{
				2057	// If either entry is void then we can just compare the types
				2058	if (lhs.m_type == Scalar::e_void \|\| rhs.m_type == Scalar::e_void)
				2059	return lhs.m_type != rhs.m_type;
				2060
				2061	Scalar temp_value; // A temp value that might get a copy of either promoted value
				2062	const Scalar* a;
				2063	const Scalar* b;
				2064	switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
				2065	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	2066	case Scalar::e_void: break;
				2067	case Scalar::e_sint: return a->m_data.sint != b->m_data.sint;
				2068	case Scalar::e_uint: return a->m_data.uint != b->m_data.uint;
				2069	case Scalar::e_slong: return a->m_data.slong != b->m_data.slong;
				2070	case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong;
				2071	case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong;
				2072	case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong;
				2073	case Scalar::e_float: return a->m_data.flt != b->m_data.flt;
				2074	case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl;
				2075	case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl;
				2076	}
				2077	return true;
				2078	}
				2079
				2080	bool
				2081	lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
				2082	{
				2083	if (lhs.m_type == Scalar::e_void \|\| rhs.m_type == Scalar::e_void)
				2084	return false;
				2085
				2086	Scalar temp_value;
				2087	const Scalar* a;
				2088	const Scalar* b;
				2089	switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
				2090	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	2091	case Scalar::e_void: break;
				2092	case Scalar::e_sint: return a->m_data.sint < b->m_data.sint;
				2093	case Scalar::e_uint: return a->m_data.uint < b->m_data.uint;
				2094	case Scalar::e_slong: return a->m_data.slong < b->m_data.slong;
				2095	case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong;
				2096	case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong;
				2097	case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong;
				2098	case Scalar::e_float: return a->m_data.flt < b->m_data.flt;
				2099	case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl;
				2100	case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl;
				2101	}
				2102	return false;
				2103	}
				2104
				2105	bool
				2106	lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
				2107	{
				2108	if (lhs.m_type == Scalar::e_void \|\| rhs.m_type == Scalar::e_void)
				2109	return false;
				2110
				2111	Scalar temp_value;
				2112	const Scalar* a;
				2113	const Scalar* b;
				2114	switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
				2115	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	2116	case Scalar::e_void: break;
				2117	case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint;
				2118	case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint;
				2119	case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong;
				2120	case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong;
				2121	case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong;
				2122	case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong;
				2123	case Scalar::e_float: return a->m_data.flt <= b->m_data.flt;
				2124	case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl;
				2125	case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl;
				2126	}
				2127	return false;
				2128	}
				2129
				2130
				2131	bool
				2132	lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
				2133	{
				2134	if (lhs.m_type == Scalar::e_void \|\| rhs.m_type == Scalar::e_void)
				2135	return false;
				2136
				2137	Scalar temp_value;
				2138	const Scalar* a;
				2139	const Scalar* b;
				2140	switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
				2141	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	2142	case Scalar::e_void: break;
				2143	case Scalar::e_sint: return a->m_data.sint > b->m_data.sint;
				2144	case Scalar::e_uint: return a->m_data.uint > b->m_data.uint;
				2145	case Scalar::e_slong: return a->m_data.slong > b->m_data.slong;
				2146	case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong;
				2147	case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong;
				2148	case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong;
				2149	case Scalar::e_float: return a->m_data.flt > b->m_data.flt;
				2150	case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl;
				2151	case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl;
				2152	}
				2153	return false;
				2154	}
				2155
				2156	bool
				2157	lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
				2158	{
				2159	if (lhs.m_type == Scalar::e_void \|\| rhs.m_type == Scalar::e_void)
				2160	return false;
				2161
				2162	Scalar temp_value;
				2163	const Scalar* a;
				2164	const Scalar* b;
				2165	switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
				2166	{
Chris Lattner	24943d2	2010-06-08 16:52:24 +0000	[diff] [blame]	2167	case Scalar::e_void: break;
				2168	case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint;
				2169	case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint;
				2170	case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong;
				2171	case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong;
				2172	case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong;
				2173	case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong;
				2174	case Scalar::e_float: return a->m_data.flt >= b->m_data.flt;
				2175	case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl;
				2176	case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl;
				2177	}
				2178	return false;
				2179	}
				2180
				2181
				2182
				2183