This is an archive of the discontinued LLVM Phabricator instance.

Remove Go debugger plugin
ClosedPublic

Authored by JDevlieghere on Nov 2 2018, 4:21 PM.

Download Raw Diff

Details

Reviewers

davide
labath
zturner
tberghammer
ribrdb

Commits

rG77198bc79b54: Remove Go debugger plugin
rLLDB346157: Remove Go debugger plugin
rL346157: Remove Go debugger plugin

Summary

In January Davide sent an e-mail to the mailing list to suggest removing support for Go and Java. The plan was to have some cool down period to allow users to speak up. However, the actual removal never took place. After having the Go test fail on my machine since forever I decided to move forward and start the removal process.

Discussion on the mailing list: http://lists.llvm.org/pipermail/lldb-dev/2018-January/013171.html

Diff Detail

Event Timeline

JDevlieghere created this revision.Nov 2 2018, 4:21 PM

Herald added subscribers: teemperor, jfb, mgorny. · View Herald TranscriptNov 2 2018, 4:21 PM

Missed some files.

JDevlieghere mentioned this in D54059: Remove Java debugger plugin.Nov 3 2018, 8:25 AM

LGTM. Adding Ryan as a reviewer as he was the original implementer but I am not sure if his account (and the linked e-mail) is still active.

This revision is now accepted and ready to land.Nov 5 2018, 1:49 AM

LGTM. Thanks for picking up the slack.

Closed by commit rL346157: Remove Go debugger plugin (authored by JDevlieghere). · Explain WhyNov 5 2018, 11:36 AM

This revision was automatically updated to reflect the committed changes.

Herald added a subscriber: llvm-commits. · View Herald TranscriptNov 5 2018, 11:36 AM

kastiglione mentioned this in rGf3b07f9c5d97: [lldb] Remove unused StackFrame::TrackGlobalVariable.Mar 12 2021, 8:51 AM

Revision Contents

Path

Size

include/

lldb/

Symbol/

GoASTContext.h

lldb-forward.h

2 lines

packages/

Python/

lldbsuite/

test/

decorators.py

22 lines

lang/

go/

expressions/

formatters/

goroutines/

runtime/

TestGoLanguageRuntime

types/

18 lines

source/

API/

SystemInitializerFull.cpp

13 lines

Plugins/

ExpressionParser/

CMakeLists.txt

1 line

Go/

Language/

1 line

Go/

CMakeLists.txt

GoFormatterFunctions.h

GoFormatterFunctions.cpp

GoLanguage.h

GoLanguage.cpp

LanguageRuntime/

CMakeLists.txt

1 line

Go/

CMakeLists.txt

2 lines

GoLanguageRuntime.h

GoLanguageRuntime.cpp

OperatingSystem/

CMakeLists.txt

1 line

Go/

CMakeLists.txt

OperatingSystemGo.h

OperatingSystemGo.cpp

SymbolFile/

DWARF/

1 line

Symbol/

4 lines

tools/

lldb-test/

SystemInitializerTest.cpp

11 lines

unittests/

Expression/

CMakeLists.txt

2 lines

GoParserTest.cpp

Language/

Highlighting/

CMakeLists.txt

1 line

HighlighterTest.cpp

3 lines

Symbol/

TestClangASTContext.cpp

6 lines

Diff 172458

include/lldb/Symbol/GoASTContext.h

This file was deleted.

	//===-- GoASTContext.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_GoASTContext_h_
	#define liblldb_GoASTContext_h_

	// C Includes
	// C++ Includes
	#include <map>
	#include <memory>
	#include <set>
	#include <string>
	#include <vector>

	// Other libraries and framework includes
	// Project includes
	#include "lldb/Symbol/CompilerType.h"
	#include "lldb/Symbol/TypeSystem.h"
	#include "lldb/Utility/ConstString.h"

	namespace lldb_private {

	class Declaration;
	class GoType;

	class GoASTContext : public TypeSystem {
	public:
	GoASTContext();
	~GoASTContext() override;

	//------------------------------------------------------------------
	// PluginInterface functions
	//------------------------------------------------------------------
	ConstString GetPluginName() override;

	uint32_t GetPluginVersion() override;

	static ConstString GetPluginNameStatic();

	static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
	Module module, Target target);

	static void EnumerateSupportedLanguages(
	std::set<lldb::LanguageType> &languages_for_types,
	std::set<lldb::LanguageType> &languages_for_expressions);

	static void Initialize();

	static void Terminate();

	DWARFASTParser *GetDWARFParser() override;

	void SetAddressByteSize(int byte_size) { m_pointer_byte_size = byte_size; }

	//------------------------------------------------------------------
	// llvm casting support
	//------------------------------------------------------------------
	static bool classof(const TypeSystem *ts) {
	return ts->getKind() == TypeSystem::eKindGo;
	}

	//----------------------------------------------------------------------
	// CompilerDecl functions
	//----------------------------------------------------------------------
	ConstString DeclGetName(void *opaque_decl) override { return ConstString(); }

	//----------------------------------------------------------------------
	// CompilerDeclContext functions
	//----------------------------------------------------------------------

	bool DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) override {
	return false;
	}

	ConstString DeclContextGetName(void *opaque_decl_ctx) override {
	return ConstString();
	}

	ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override {
	return ConstString();
	}

	bool
	DeclContextIsClassMethod(void *opaque_decl_ctx,
	lldb::LanguageType *language_ptr,
	bool *is_instance_method_ptr,
	ConstString *language_object_name_ptr) override {
	return false;
	}

	//----------------------------------------------------------------------
	// Creating Types
	//----------------------------------------------------------------------

	CompilerType CreateArrayType(const ConstString &name,
	const CompilerType &element_type,
	uint64_t length);

	CompilerType CreateBaseType(int go_kind,
	const ConstString &type_name_const_str,
	uint64_t byte_size);

	// For interface, map, chan.
	CompilerType CreateTypedefType(int kind, const ConstString &name,
	CompilerType impl);

	CompilerType CreateVoidType(const ConstString &name);
	CompilerType CreateFunctionType(const lldb_private::ConstString &name,
	CompilerType *params, size_t params_count,
	bool is_variadic);

	CompilerType CreateStructType(int kind, const ConstString &name,
	uint32_t byte_size);

	void CompleteStructType(const CompilerType &type);

	void AddFieldToStruct(const CompilerType &struct_type,
	const ConstString &name, const CompilerType &field_type,
	uint32_t byte_offset);

	//----------------------------------------------------------------------
	// Tests
	//----------------------------------------------------------------------

	static bool IsGoString(const CompilerType &type);
	static bool IsGoSlice(const CompilerType &type);
	static bool IsGoInterface(const CompilerType &type);
	static bool IsDirectIface(uint8_t kind);
	static bool IsPointerKind(uint8_t kind);

	bool IsArrayType(lldb::opaque_compiler_type_t type,
	CompilerType element_type, uint64_t size,
	bool *is_incomplete) override;

	bool IsAggregateType(lldb::opaque_compiler_type_t type) override;

	bool IsCharType(lldb::opaque_compiler_type_t type) override;

	bool IsCompleteType(lldb::opaque_compiler_type_t type) override;

	bool IsDefined(lldb::opaque_compiler_type_t type) override;

	bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count,
	bool &is_complex) override;

	bool IsFunctionType(lldb::opaque_compiler_type_t type,
	bool *is_variadic_ptr = nullptr) override;

	size_t
	GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override;

	CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
	const size_t index) override;

	bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override;

	bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
	CompilerType *function_pointer_type_ptr) override;

	bool IsIntegerType(lldb::opaque_compiler_type_t type,
	bool &is_signed) override;

	bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
	CompilerType *target_type, // Can pass nullptr
	bool check_cplusplus, bool check_objc) override;

	bool IsPointerType(lldb::opaque_compiler_type_t type,
	CompilerType *pointee_type = nullptr) override;

	bool IsScalarType(lldb::opaque_compiler_type_t type) override;

	bool IsVoidType(lldb::opaque_compiler_type_t type) override;

	bool SupportsLanguage(lldb::LanguageType language) override;

	//----------------------------------------------------------------------
	// Type Completion
	//----------------------------------------------------------------------

	bool GetCompleteType(lldb::opaque_compiler_type_t type) override;

	//----------------------------------------------------------------------
	// AST related queries
	//----------------------------------------------------------------------

	uint32_t GetPointerByteSize() override;

	//----------------------------------------------------------------------
	// Accessors
	//----------------------------------------------------------------------

	ConstString GetTypeName(lldb::opaque_compiler_type_t type) override;

	uint32_t GetTypeInfo(
	lldb::opaque_compiler_type_t type,
	CompilerType *pointee_or_element_compiler_type = nullptr) override;

	lldb::LanguageType
	GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;

	lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;

	//----------------------------------------------------------------------
	// Creating related types
	//----------------------------------------------------------------------

	CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type,
	uint64_t *stride = nullptr) override;

	CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;

	// Returns -1 if this isn't a function of if the function doesn't have a
	// prototype Returns a value >= 0 if there is a prototype.
	int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;

	CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
	size_t idx) override;

	CompilerType
	GetFunctionReturnType(lldb::opaque_compiler_type_t type) override;

	size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override;

	TypeMemberFunctionImpl
	GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
	size_t idx) override;

	CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override;

	CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;

	//----------------------------------------------------------------------
	// Exploring the type
	//----------------------------------------------------------------------

	uint64_t GetBitSize(lldb::opaque_compiler_type_t type,
	ExecutionContextScope *exe_scope) override;

	lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
	uint64_t &count) override;

	lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;

	uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
	bool omit_empty_base_classes) override;

	lldb::BasicType
	GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;

	CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
	size_t bit_size) override;

	uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;

	CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
	std::string &name, uint64_t *bit_offset_ptr,
	uint32_t *bitfield_bit_size_ptr,
	bool *is_bitfield_ptr) override;

	uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override {
	return 0;
	}

	uint32_t
	GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override {
	return 0;
	}

	CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type,
	size_t idx,
	uint32_t *bit_offset_ptr) override {
	return CompilerType();
	}

	CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type,
	size_t idx,
	uint32_t *bit_offset_ptr) override {
	return CompilerType();
	}

	CompilerType GetChildCompilerTypeAtIndex(
	lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
	bool transparent_pointers, bool omit_empty_base_classes,
	bool ignore_array_bounds, std::string &child_name,
	uint32_t &child_byte_size, int32_t &child_byte_offset,
	uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
	bool &child_is_base_class, bool &child_is_deref_of_parent,
	ValueObject *valobj, uint64_t &language_flags) override;

	// Lookup a child given a name. This function will match base class names and
	// member member names in "clang_type" only, not descendants.
	uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
	const char *name,
	bool omit_empty_base_classes) override;

	// Lookup a child member given a name. This function will match member names
	// only and will descend into "clang_type" children in search for the first
	// member in this class, or any base class that matches "name".
	// TODO: Return all matches for a given name by returning a
	// vector<vector<uint32_t>>
	// so we catch all names that match a given child name, not just the first.
	size_t
	GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
	const char *name, bool omit_empty_base_classes,
	std::vector<uint32_t> &child_indexes) override;

	//----------------------------------------------------------------------
	// Dumping types
	//----------------------------------------------------------------------
	void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
	Stream *s, lldb::Format format, const DataExtractor &data,
	lldb::offset_t data_offset, size_t data_byte_size,
	uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
	bool show_types, bool show_summary, bool verbose,
	uint32_t depth) override;

	bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
	lldb::Format format, const DataExtractor &data,
	lldb::offset_t data_offset, size_t data_byte_size,
	uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
	ExecutionContextScope *exe_scope) override;

	void DumpTypeDescription(
	lldb::opaque_compiler_type_t type) override; // Dump to stdout

	void DumpTypeDescription(lldb::opaque_compiler_type_t type,
	Stream *s) override;

	//----------------------------------------------------------------------
	// TODO: These methods appear unused. Should they be removed?
	//----------------------------------------------------------------------

	bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override;

	void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
	Stream *s, const DataExtractor &data,
	lldb::offset_t data_offset, size_t data_byte_size) override;

	// Converts "s" to a floating point value and place resulting floating point
	// bytes in the "dst" buffer.
	size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
	const char s, uint8_t dst,
	size_t dst_size) override;

	//----------------------------------------------------------------------
	// TODO: Determine if these methods should move to ClangASTContext.
	//----------------------------------------------------------------------

	bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
	CompilerType *pointee_type = nullptr) override;

	unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;

	bool IsCStringType(lldb::opaque_compiler_type_t type,
	uint32_t &length) override;

	size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override;

	CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;

	bool IsBeingDefined(lldb::opaque_compiler_type_t type) override;

	bool IsConst(lldb::opaque_compiler_type_t type) override;

	uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
	CompilerType *base_type_ptr) override;

	bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override;

	bool IsTypedefType(lldb::opaque_compiler_type_t type) override;

	// If the current object represents a typedef type, get the underlying type
	CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;

	bool IsVectorType(lldb::opaque_compiler_type_t type,
	CompilerType element_type, uint64_t size) override;

	CompilerType
	GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override;

	CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override;

	bool IsReferenceType(lldb::opaque_compiler_type_t type,
	CompilerType *pointee_type = nullptr,
	bool *is_rvalue = nullptr) override;

	private:
	typedef std::map<ConstString, std::unique_ptr<GoType>> TypeMap;
	int m_pointer_byte_size;
	int m_int_byte_size;
	std::unique_ptr<TypeMap> m_types;
	std::unique_ptr<DWARFASTParser> m_dwarf_ast_parser_ap;

	GoASTContext(const GoASTContext &) = delete;
	const GoASTContext &operator=(const GoASTContext &) = delete;
	};

	class GoASTContextForExpr : public GoASTContext {
	public:
	GoASTContextForExpr(lldb::TargetSP target) : m_target_wp(target) {}
	UserExpression *
	GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
	lldb::LanguageType language,
	Expression::ResultType desired_type,
	const EvaluateExpressionOptions &options) override;

	private:
	lldb::TargetWP m_target_wp;
	};
	}
	#endif // liblldb_GoASTContext_h_

include/lldb/lldb-forward.h

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
class Expression;		class Expression;
class ExpressionVariable;		class ExpressionVariable;
class ExpressionVariableList;		class ExpressionVariableList;
class ExpressionTypeSystemHelper;		class ExpressionTypeSystemHelper;
class File;		class File;
class FileSpec;		class FileSpec;
class FileSpecList;		class FileSpecList;
class Flags;		class Flags;
class GoASTContext;
class TypeCategoryImpl;		class TypeCategoryImpl;
class FormatManager;		class FormatManager;
class FormattersMatchCandidate;		class FormattersMatchCandidate;
class FuncUnwinders;		class FuncUnwinders;
class Function;		class Function;
class FunctionInfo;		class FunctionInfo;
class InlineFunctionInfo;		class InlineFunctionInfo;
class Instruction;		class Instruction;
▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Lines	typedef std::shared_ptr<lldb_private::EventDataStructuredData>
EventDataStructuredDataSP;		EventDataStructuredDataSP;
typedef std::shared_ptr<lldb_private::ExecutionContextRef>		typedef std::shared_ptr<lldb_private::ExecutionContextRef>
ExecutionContextRefSP;		ExecutionContextRefSP;
typedef std::shared_ptr<lldb_private::ExpressionVariable> ExpressionVariableSP;		typedef std::shared_ptr<lldb_private::ExpressionVariable> ExpressionVariableSP;
typedef std::shared_ptr<lldb_private::File> FileSP;		typedef std::shared_ptr<lldb_private::File> FileSP;
typedef std::shared_ptr<lldb_private::Function> FunctionSP;		typedef std::shared_ptr<lldb_private::Function> FunctionSP;
typedef std::shared_ptr<lldb_private::FunctionCaller> FunctionCallerSP;		typedef std::shared_ptr<lldb_private::FunctionCaller> FunctionCallerSP;
typedef std::shared_ptr<lldb_private::FuncUnwinders> FuncUnwindersSP;		typedef std::shared_ptr<lldb_private::FuncUnwinders> FuncUnwindersSP;
typedef std::unique_ptr<lldb_private::GoASTContext> GoASTContextUP;
typedef std::shared_ptr<lldb_private::InlineFunctionInfo> InlineFunctionInfoSP;		typedef std::shared_ptr<lldb_private::InlineFunctionInfo> InlineFunctionInfoSP;
typedef std::shared_ptr<lldb_private::Instruction> InstructionSP;		typedef std::shared_ptr<lldb_private::Instruction> InstructionSP;
typedef std::shared_ptr<lldb_private::InstrumentationRuntime>		typedef std::shared_ptr<lldb_private::InstrumentationRuntime>
InstrumentationRuntimeSP;		InstrumentationRuntimeSP;
typedef std::shared_ptr<lldb_private::IOHandler> IOHandlerSP;		typedef std::shared_ptr<lldb_private::IOHandler> IOHandlerSP;
typedef std::shared_ptr<lldb_private::IOObject> IOObjectSP;		typedef std::shared_ptr<lldb_private::IOObject> IOObjectSP;
typedef std::shared_ptr<lldb_private::IRExecutionUnit> IRExecutionUnitSP;		typedef std::shared_ptr<lldb_private::IRExecutionUnit> IRExecutionUnitSP;
typedef std::shared_ptr<lldb_private::JITLoader> JITLoaderSP;		typedef std::shared_ptr<lldb_private::JITLoader> JITLoaderSP;
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/decorators.py

Show First 20 Lines • Show All 594 Lines • ▼ Show 20 Lines	def skipUnlessWindows(func):
return skipUnlessPlatform(["windows"])(func)		return skipUnlessPlatform(["windows"])(func)


def skipUnlessDarwin(func):		def skipUnlessDarwin(func):
"""Decorate the item to skip tests that should be skipped on any non Darwin platform."""		"""Decorate the item to skip tests that should be skipped on any non Darwin platform."""
return skipUnlessPlatform(lldbplatformutil.getDarwinOSTriples())(func)		return skipUnlessPlatform(lldbplatformutil.getDarwinOSTriples())(func)


def skipUnlessGoInstalled(func):
"""Decorate the item to skip tests when no Go compiler is available."""

def is_go_missing(self):
compiler = self.getGoCompilerVersion()
if not compiler:
return "skipping because go compiler not found"
match_version = re.search(r"(\d+\.\d+(\.\d+)?)", compiler)
if not match_version:
# Couldn't determine version.
return "skipping because go version could not be parsed out of {}".format(
compiler)
else:
min_strict_version = StrictVersion("1.4.0")
compiler_strict_version = StrictVersion(match_version.group(1))
if compiler_strict_version < min_strict_version:
return "skipping because available version ({}) does not meet minimum required version ({})".format(
compiler_strict_version, min_strict_version)
return None
return skipTestIfFn(is_go_missing)(func)


def skipIfHostIncompatibleWithRemote(func):		def skipIfHostIncompatibleWithRemote(func):
"""Decorate the item to skip tests if binaries built on this host are incompatible."""		"""Decorate the item to skip tests if binaries built on this host are incompatible."""

def is_host_incompatible_with_remote(self):		def is_host_incompatible_with_remote(self):
host_arch = self.getLldbArchitecture()		host_arch = self.getLldbArchitecture()
host_platform = lldbplatformutil.getHostPlatform()		host_platform = lldbplatformutil.getHostPlatform()
target_arch = self.getArchitecture()		target_arch = self.getArchitecture()
target_platform = 'darwin' if self.platformIsDarwin() else self.getPlatform()		target_platform = 'darwin' if self.platformIsDarwin() else self.getPlatform()
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/go/expressions/TestExpressions.py

This file was deleted.

	"""Test the go expression parser/interpreter."""

	import os
	import time
	import unittest2
	import lldb
	from lldbsuite.test.decorators import *
	from lldbsuite.test.lldbtest import *
	from lldbsuite.test import lldbutil


	class TestGoUserExpression(TestBase):

	mydir = TestBase.compute_mydir(__file__)

	@add_test_categories(['pyapi'])
	@skipIfRemote # Not remote test suit ready
	@skipIfFreeBSD # Test hanging on FreeBSD - llvm.org/pr37194
	@skipUnlessGoInstalled
	def test_with_dsym_and_python_api(self):
	"""Test GoASTUserExpress."""
	self.buildGo()
	self.launchProcess()
	self.go_expressions()

	def setUp(self):
	# Call super's setUp().
	TestBase.setUp(self)
	# Find the line numbers to break inside main().
	self.main_source = "main.go"
	self.break_line = line_number(
	self.main_source, '// Set breakpoint here.')

	def check_builtin(self, name, size=0, typeclass=lldb.eTypeClassBuiltin):
	tl = self.target().FindTypes(name)
	self.assertEqual(1, len(tl))
	t = list(tl)[0]
	self.assertEqual(name, t.name)
	self.assertEqual(typeclass, t.type)
	if size > 0:
	self.assertEqual(size, t.size)

	def launchProcess(self):
	exe = self.getBuildArtifact("a.out")

	target = self.dbg.CreateTarget(exe)
	self.assertTrue(target, VALID_TARGET)

	bpt = target.BreakpointCreateByLocation(
	self.main_source, self.break_line)
	self.assertTrue(bpt, VALID_BREAKPOINT)

	# Now launch the process, and do not stop at entry point.
	process = target.LaunchSimple(
	None, None, self.get_process_working_directory())

	self.assertTrue(process, PROCESS_IS_VALID)

	# The stop reason of the thread should be breakpoint.
	thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)

	# Make sure we stopped at the first breakpoint.
	self.assertTrue(
	len(thread_list) != 0,
	"No thread stopped at our breakpoint.")
	self.assertTrue(len(thread_list) == 1,
	"More than one thread stopped at our breakpoint.")

	frame = thread_list[0].GetFrameAtIndex(0)
	self.assertTrue(frame, "Got a valid frame 0 frame.")

	def go_expressions(self):
	frame = self.frame()
	v = frame.EvaluateExpression("1")
	self.assertEqual(1, v.GetValueAsSigned())
	x = frame.EvaluateExpression("x")
	self.assertEqual(22, x.GetValueAsSigned())

	a = frame.EvaluateExpression("a")
	self.assertEqual(3, a.GetNumChildren())
	a0 = a.GetChildAtIndex(0)
	self.assertEqual(8, a0.GetValueAsSigned())

	# Array indexing
	a0 = frame.EvaluateExpression("a[0]")
	self.assertEqual(8, a0.GetValueAsSigned())

	# Slice indexing
	b1 = frame.EvaluateExpression("b[1]")
	self.assertEqual(9, b1.GetValueAsSigned())

	# Test global in this package
	g = frame.EvaluateExpression("myGlobal")
	self.assertEqual(17, g.GetValueAsSigned(), str(g))

	# Global with package name
	g = frame.EvaluateExpression("main.myGlobal")
	self.assertEqual(17, g.GetValueAsSigned(), str(g))

	# Global with quoted package name
	g = frame.EvaluateExpression('"main".myGlobal')
	self.assertEqual(17, g.GetValueAsSigned(), str(g))

	# Casting with package local type
	s = frame.EvaluateExpression("(myStruct)(i.data)")
	sb = s.GetChildMemberWithName("a")
	self.assertEqual(2, sb.GetValueAsSigned())

	# casting with explicit package
	s = frame.EvaluateExpression("(main.myStruct)(i.data)")
	sb = s.GetChildMemberWithName("a")
	self.assertEqual(2, sb.GetValueAsSigned())

	# Casting quoted package
	s = frame.EvaluateExpression('("main".myStruct)(i.data)')
	sb = s.GetChildMemberWithName("b")
	self.assertEqual(-1, sb.GetValueAsSigned())

	if __name__ == '__main__':
	import atexit
	lldb.SBDebugger.Initialize()
	atexit.register(lambda: lldb.SBDebugger.Terminate())
	unittest2.main()

packages/Python/lldbsuite/test/lang/go/expressions/main.go

This file was deleted.

	package main

	import "fmt"

	type myStruct struct {
	a, b int
	}

	var myGlobal = 17

	func myFunc(i interface{}) {
	a := [...]int{8, 9, 10}
	b := a[:]
	x := 22
	fmt.Println(a, b, x, i, myGlobal) // Set breakpoint here.
	}

	func main() {
	s := myStruct {2, -1}
	myFunc(s)
	}
	No newline at end of file

packages/Python/lldbsuite/test/lang/go/formatters/TestGoFormatters.py

This file was deleted.

	"""Test the Go Data Formatter Plugin."""

	import os
	import time
	import unittest2
	import lldb
	from lldbsuite.test.decorators import *
	from lldbsuite.test.lldbtest import *
	from lldbsuite.test import lldbutil


	class TestGoLanguage(TestBase):

	mydir = TestBase.compute_mydir(__file__)

	@skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure
	@skipIfRemote # Not remote test suite ready
	@no_debug_info_test
	@skipUnlessGoInstalled
	def test_go_formatter_plugin(self):
	"""Test go data formatters."""
	self.buildGo()
	self.launchProcess()
	self.check_formatters()

	def setUp(self):
	# Call super's setUp().
	TestBase.setUp(self)
	# Find the line numbers to break inside main().
	self.main_source = "main.go"
	self.break_line = line_number(self.main_source, '// stop here')

	def launchProcess(self):
	exe = self.getBuildArtifact("a.out")

	target = self.dbg.CreateTarget(exe)
	self.assertTrue(target, VALID_TARGET)

	self.bpt = target.BreakpointCreateByLocation(
	self.main_source, self.break_line)
	self.assertTrue(self.bpt, VALID_BREAKPOINT)

	# Now launch the process, and do not stop at entry point.
	process = target.LaunchSimple(
	None, None, self.get_process_working_directory())

	self.assertTrue(process, PROCESS_IS_VALID)

	# The stop reason of the thread should be breakpoint.
	thread_list = lldbutil.get_threads_stopped_at_breakpoint(
	process, self.bpt)

	# Make sure we stopped at the first breakpoint.
	self.assertTrue(
	len(thread_list) != 0,
	"No thread stopped at our breakpoint.")
	self.assertTrue(len(thread_list) == 1,
	"More than one thread stopped at our breakpoint.")

	frame = thread_list[0].GetFrameAtIndex(0)
	self.assertTrue(frame, "Got a valid frame 0 frame.")

	def check_formatters(self):
	a = self.frame().FindVariable('a')
	self.assertEqual('(string) a = "my string"', str(a))
	b = self.frame().FindVariable('b')
	self.assertEqual(
	"([]int) b = (len 2, cap 7) {\n [0] = 0\n [1] = 0\n}",
	str(b))


	if __name__ == '__main__':
	import atexit
	lldb.SBDebugger.Initialize()
	atexit.register(lambda: lldb.SBDebugger.Terminate())
	unittest2.main()

packages/Python/lldbsuite/test/lang/go/formatters/main.go

This file was deleted.

	package main

	import "fmt"

	func main() {
	a := "my string"
	b := make([]int, 2, 7)
	fmt.Println(a, b) // stop here
	}
	No newline at end of file

packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py

This file was deleted.

	"""Test the Go OS Plugin."""

	from __future__ import print_function


	import os
	import time
	import lldb
	from lldbsuite.test.decorators import *
	from lldbsuite.test.lldbtest import *
	from lldbsuite.test import lldbutil


	class TestGoASTContext(TestBase):

	mydir = TestBase.compute_mydir(__file__)

	@add_test_categories(['pyapi'])
	@skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure
	@skipIfRemote # Not remote test suite ready
	@no_debug_info_test
	@skipUnlessGoInstalled
	def test_goroutine_plugin(self):
	"""Test goroutine as threads support."""
	self.buildGo()
	self.launchProcess()
	self.check_goroutines()

	def setUp(self):
	# Call super's setUp().
	TestBase.setUp(self)
	# Find the line numbers to break inside main().
	self.main_source = "main.go"
	self.break_line1 = line_number(self.main_source, '// stop1')
	self.break_line2 = line_number(self.main_source, '// stop2')
	self.break_line3 = line_number(self.main_source, '// stop3')

	def launchProcess(self):
	exe = self.getBuildArtifact("a.out")

	target = self.dbg.CreateTarget(exe)
	self.assertTrue(target, VALID_TARGET)

	self.bpt1 = target.BreakpointCreateByLocation(
	self.main_source, self.break_line1)
	self.assertTrue(self.bpt1, VALID_BREAKPOINT)
	self.bpt2 = target.BreakpointCreateByLocation(
	self.main_source, self.break_line2)
	self.assertTrue(self.bpt2, VALID_BREAKPOINT)
	self.bpt3 = target.BreakpointCreateByLocation(
	self.main_source, self.break_line3)
	self.assertTrue(self.bpt3, VALID_BREAKPOINT)

	# Now launch the process, and do not stop at entry point.
	process = target.LaunchSimple(
	None, None, self.get_process_working_directory())

	self.assertTrue(process, PROCESS_IS_VALID)

	# The stop reason of the thread should be breakpoint.
	thread_list = lldbutil.get_threads_stopped_at_breakpoint(
	process, self.bpt1)

	# Make sure we stopped at the first breakpoint.
	self.assertTrue(
	len(thread_list) != 0,
	"No thread stopped at our breakpoint.")
	self.assertTrue(len(thread_list) == 1,
	"More than one thread stopped at our breakpoint.")

	frame = thread_list[0].GetFrameAtIndex(0)
	self.assertTrue(frame, "Got a valid frame 0 frame.")

	def check_goroutines(self):
	self.assertLess(len(self.process().threads), 20)
	self.process().Continue()

	# Make sure we stopped at the 2nd breakpoint
	thread_list = lldbutil.get_threads_stopped_at_breakpoint(
	self.process(), self.bpt2)
	self.assertTrue(
	len(thread_list) != 0,
	"No thread stopped at our breakpoint.")
	self.assertTrue(len(thread_list) == 1,
	"More than one thread stopped at our breakpoint.")

	# There's (at least) 21 goroutines.
	self.assertGreater(len(self.process().threads), 20)
	# self.dbg.HandleCommand("log enable lldb os")

	# Now test that stepping works if the memory thread moves to a
	# different backing thread.
	for i in list(range(11)):
	self.thread().StepOver()
	self.assertEqual(
	lldb.eStopReasonPlanComplete,
	self.thread().GetStopReason(),
	self.thread().GetStopDescription(100))

	# Disable the plugin and make sure the goroutines disappear
	self.dbg.HandleCommand(
	"settings set plugin.os.goroutines.enable false")
	self.thread().StepInstruction(False)
	self.assertLess(len(self.process().threads), 20)

packages/Python/lldbsuite/test/lang/go/goroutines/main.go

This file was deleted.

	package main

	import (
	"fmt"
	"runtime"
	)

	type philosopher struct {
	i int
	forks [2]chan bool
	eating chan int
	done chan struct{}
	}

	func (p philosopher) run() {
	for {
	select {
	case <-p.done:
	return
	case <-p.forks[0]:
	p.eat()
	}
	}
	}

	func (p philosopher) eat() {
	select {
	case <-p.done:
	return
	case <-p.forks[1]:
	p.eating <- p.i
	p.forks[0] <- true
	p.forks[1] <- true
	runtime.Gosched()
	}
	}

	func startPhilosophers(n int) (chan struct{}, chan int) {
	philosophers := make([]*philosopher, n)
	chans := make([]chan bool, n)
	for i := range chans {
	chans[i] = make(chan bool, 1)
	chans[i] <- true
	}
	eating := make(chan int, n)
	done := make(chan struct{})
	for i := range philosophers {
	var min, max int
	if i == n - 1 {
	min = 0
	max = i
	} else {
	min = i
	max = i + 1
	}
	philosophers[i] = &philosopher{i: i, forks: [2]chan bool{chans[min], chans[max]}, eating: eating, done: done}
	go philosophers[i].run()
	}
	return done, eating
	}

	func wait(c chan int) {
	fmt.Println(<- c)
	runtime.Gosched()
	}

	func main() {
	// Restrict go to 1 real thread so we can be sure we're seeing goroutines
	// and not threads.
	runtime.GOMAXPROCS(1)
	// Create a bunch of goroutines
	done, eating := startPhilosophers(20) // stop1
	// Now turn up the number of threads so this goroutine is likely to get
	// scheduled on a different thread.
	runtime.GOMAXPROCS(runtime.NumCPU()) // stop2
	// Now let things run. Hopefully we'll bounce around
	wait(eating)
	wait(eating)
	wait(eating)
	wait(eating)
	wait(eating)
	wait(eating)
	wait(eating)
	wait(eating)
	wait(eating)
	wait(eating)
	close(done)
	fmt.Println("done") // stop3
	}

packages/Python/lldbsuite/test/lang/go/runtime/TestGoLanguageRuntime

This file was deleted.

	"""Test the go dynamic type handling."""

	import os, time
	import unittest2
	import lldb
	import lldbutil
	from lldbtest import *

	class TestGoLanguageRuntime(TestBase):

	mydir = TestBase.compute_mydir(__file__)

	@python_api_test
	@expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr24895')
	@skipIfRemote # Not remote test suite ready
	@skipUnlessGoInstalled
	def test_with_dsym_and_python_api(self):
	"""Test GoASTContext dwarf parsing."""
	self.buildGo()
	self.launchProcess()
	self.go_interface_types()

	def setUp(self):
	# Call super's setUp().
	TestBase.setUp(self)
	# Find the line numbers to break inside main().
	self.main_source = "main.go"
	self.break_line1 = line_number(self.main_source, '// Set breakpoint 1')
	self.break_line2 = line_number(self.main_source, '// Set breakpoint 2')


	def launchProcess(self):
	exe = self.getBuildArtifact("a.out")

	target = self.dbg.CreateTarget(exe)
	self.assertTrue(target, VALID_TARGET)

	bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1)
	self.assertTrue(bpt1, VALID_BREAKPOINT)
	bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2)
	self.assertTrue(bpt2, VALID_BREAKPOINT)

	# Now launch the process, and do not stop at entry point.
	process = target.LaunchSimple (None, None, self.get_process_working_directory())

	self.assertTrue(process, PROCESS_IS_VALID)

	# The stop reason of the thread should be breakpoint.
	thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt1)

	# Make sure we stopped at the first breakpoint.
	self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.")
	self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.")

	frame = thread_list[0].GetFrameAtIndex(0)
	self.assertTrue (frame, "Got a valid frame 0 frame.")

	def go_interface_types(self):
	f = self.frame()
	v = f.FindVariable("a", lldb.eDynamicCanRunTarget)
	self.assertEqual("*int", v.GetType().name)
	self.assertEqual(1, v.Dereference().GetValueAsSigned())
	v = f.FindVariable("b", lldb.eDynamicCanRunTarget)
	self.assertEqual("*float64", v.GetType().name)
	err = lldb.SBError()
	self.assertEqual(2.0, v.Dereference().GetData().GetDouble(err, 0))
	v = f.FindVariable("c", lldb.eDynamicCanRunTarget)
	self.assertEqual("*main.SomeFooer", v.GetType().name)
	self.assertEqual(9, v.Dereference().GetChildAtIndex(0).GetValueAsSigned())
	v = f.FindVariable("d", lldb.eDynamicCanRunTarget)
	self.assertEqual("*main.AnotherFooer", v.GetType().name)
	self.assertEqual(-1, v.Dereference().GetChildAtIndex(0).GetValueAsSigned())
	self.assertEqual(-2, v.Dereference().GetChildAtIndex(1).GetValueAsSigned())
	self.assertEqual(-3, v.Dereference().GetChildAtIndex(2).GetValueAsSigned())

	if __name__ == '__main__':
	import atexit
	lldb.SBDebugger.Initialize()
	atexit.register(lambda: lldb.SBDebugger.Terminate())
	unittest2.main()

packages/Python/lldbsuite/test/lang/go/runtime/main.go

This file was deleted.

	package main

	import "fmt"

	type Fooer interface {
	Foo() int
	}

	type SomeFooer struct {
	val int
	}

	func (s SomeFooer) Foo() int {
	return s.val
	}

	type AnotherFooer struct {
	a, b, c int
	}

	func (s AnotherFooer) Foo() int {
	return s.a
	}


	func printEface(a, b, c, d interface{}) {
	fmt.Println(a, b, c, d) // Set breakpoint 1
	}

	func printIface(a, b Fooer) {
	fmt.Println(a, b) // Set breakpoint 2
	}
	func main() {
	sf := SomeFooer{9}
	af := AnotherFooer{-1, -2, -3}
	printEface(1,2.0, sf, af)
	printIface(sf, af)
	}
	No newline at end of file

packages/Python/lldbsuite/test/lang/go/types/TestGoASTContext.py

This file was deleted.

	"""Test the go DWARF type parsing."""

	from __future__ import print_function


	import os
	import time
	import lldb
	from lldbsuite.test.decorators import *
	from lldbsuite.test.lldbtest import *
	from lldbsuite.test import lldbutil


	class TestGoASTContext(TestBase):

	mydir = TestBase.compute_mydir(__file__)

	@add_test_categories(['pyapi'])
	@skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure
	@skipIfRemote # Not remote test suit ready
	@no_debug_info_test
	@skipUnlessGoInstalled
	@expectedFailureAll(bugnumber="llvm.org/pr33643")
	def test_with_dsym_and_python_api(self):
	"""Test GoASTContext dwarf parsing."""
	self.buildGo()
	self.launchProcess()
	self.go_builtin_types()
	self.check_main_vars()

	def setUp(self):
	# Call super's setUp().
	TestBase.setUp(self)
	# Find the line numbers to break inside main().
	self.main_source = "main.go"
	self.break_line = line_number(
	self.main_source, '// Set breakpoint here.')

	def check_builtin(self, name, size=0, typeclass=lldb.eTypeClassBuiltin):
	tl = self.target().FindTypes(name)
	self.assertEqual(1, len(tl))
	t = list(tl)[0]
	self.assertEqual(name, t.name)
	self.assertEqual(typeclass, t.type)
	if size > 0:
	self.assertEqual(size, t.size)

	def launchProcess(self):
	exe = self.getBuildArtifact("a.out")

	target = self.dbg.CreateTarget(exe)
	self.assertTrue(target, VALID_TARGET)

	bpt = target.BreakpointCreateByLocation(
	self.main_source, self.break_line)
	self.assertTrue(bpt, VALID_BREAKPOINT)

	# Now launch the process, and do not stop at entry point.
	process = target.LaunchSimple(
	None, None, self.get_process_working_directory())

	self.assertTrue(process, PROCESS_IS_VALID)

	# The stop reason of the thread should be breakpoint.
	thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)

	# Make sure we stopped at the first breakpoint.
	self.assertTrue(
	len(thread_list) != 0,
	"No thread stopped at our breakpoint.")
	self.assertTrue(len(thread_list) == 1,
	"More than one thread stopped at our breakpoint.")

	frame = thread_list[0].GetFrameAtIndex(0)
	self.assertTrue(frame, "Got a valid frame 0 frame.")

	def go_builtin_types(self):
	address_size = self.target().GetAddressByteSize()
	self.check_builtin('bool')
	self.check_builtin('uint8', 1)
	self.check_builtin('int8', 1)
	self.check_builtin('uint16', 2)
	self.check_builtin('int16', 2)
	self.check_builtin('uint32', 4)
	self.check_builtin('int32', 4)
	self.check_builtin('uint64', 8)
	self.check_builtin('int64', 8)
	self.check_builtin('uintptr', address_size)
	self.check_builtin('int', address_size)
	self.check_builtin('uint', address_size)
	self.check_builtin('float32', 4)
	self.check_builtin('float64', 8)
	self.check_builtin('complex64', 8, lldb.eTypeClassComplexFloat)
	self.check_builtin('complex128', 16, lldb.eTypeClassComplexFloat)

	def var(self, name):
	var = self.frame().FindVariable(name)
	self.assertTrue(var.IsValid(), "%s %s" % (VALID_VARIABLE, name))
	return var

	def check_main_vars(self):
	v = self.var('theBool')
	self.assertEqual('true', v.value)

	v = self.var('theInt')
	self.assertEqual('-7', v.value)

	v = self.var('theComplex')
	self.assertEqual('1 + 2i', v.value)

	v = self.var('thePointer')
	self.assertTrue(v.TypeIsPointerType())
	self.assertEqual('-10', v.Dereference().value)
	self.assertEqual(1, v.GetNumChildren())
	self.assertEqual('-10', v.GetChildAtIndex(0).value)

	# print()
	# print(os.getpid())
	# time.sleep(60)
	v = self.var('theStruct')
	if v.TypeIsPointerType():
	v = v.Dereference()
	self.assertEqual(2, v.GetNumChildren())
	self.assertEqual('7', v.GetChildAtIndex(0).value)
	self.assertEqual('7', v.GetChildMemberWithName('myInt').value)
	self.assertEqual(
	v.load_addr,
	v.GetChildAtIndex(1).GetValueAsUnsigned())
	self.assertEqual(v.load_addr, v.GetChildMemberWithName(
	'myPointer').GetValueAsUnsigned())

	# Test accessing struct fields through pointers.
	v = v.GetChildMemberWithName('myPointer')
	self.assertTrue(v.TypeIsPointerType())
	self.assertEqual(2, v.GetNumChildren())
	self.assertEqual('7', v.GetChildAtIndex(0).value)
	c = v.GetChildMemberWithName('myPointer')
	self.assertTrue(c.TypeIsPointerType())
	self.assertEqual(2, c.GetNumChildren())
	self.assertEqual('7', c.GetChildAtIndex(0).value)

	v = self.var('theArray')
	self.assertEqual(5, v.GetNumChildren())
	for i in list(range(5)):
	self.assertEqual(str(i + 1), v.GetChildAtIndex(i).value)

packages/Python/lldbsuite/test/lang/go/types/main.go

This file was deleted.

	package main

	import "fmt"

	type Fooer interface {
	Foo() int
	}

	type SomeFooer struct {
	val int
	}

	func (s SomeFooer) Foo() int {
	return s.val
	}

	type mystruct struct {
	myInt int
	myPointer *mystruct
	}

	func main() {
	theBool := true
	theInt := -7
	theComplex := 1 + 2i
	pointee := -10
	thePointer := &pointee
	theStruct := &mystruct { myInt: 7}
	theStruct.myPointer = theStruct
	theArray := [5]byte{1, 2, 3, 4, 5}
	theSlice := theArray[1:2]
	theString := "abc"

	f := SomeFooer {9}
	var theEface interface{} = f
	var theFooer Fooer = f

	theChan := make(chan int)
	theMap := make(map[int]string)
	theMap[1] = "1"

	fmt.Println(theBool) // Set breakpoint here.
	// Reference all the variables so the compiler is happy.
	fmt.Println(theInt, theComplex, thePointer, theStruct.myInt)
	fmt.Println(theArray[0], theSlice[0], theString)
	fmt.Println(theEface, theFooer, theChan, theMap)
	}
	No newline at end of file

packages/Python/lldbsuite/test/lldbtest.py

Show First 20 Lines • Show All 1,301 Lines • ▼ Show 20 Lines	def getCompilerVersion(self):
compiler = self.getCompilerBinary()		compiler = self.getCompilerBinary()
version_output = system([[compiler, "-v"]])[1]		version_output = system([[compiler, "-v"]])[1]
for line in version_output.split(os.linesep):		for line in version_output.split(os.linesep):
m = re.search('version ([0-9\.]+)', line)		m = re.search('version ([0-9\.]+)', line)
if m:		if m:
version = m.group(1)		version = m.group(1)
return version		return version

def getGoCompilerVersion(self):
""" Returns a string that represents the go compiler version, or None if go is not found.
"""
compiler = which("go")
if compiler:
version_output = system([[compiler, "version"]])[0]
for line in version_output.split(os.linesep):
m = re.search('go version (devel\|go\\S+)', line)
if m:
return m.group(1)
return None

def platformIsDarwin(self):		def platformIsDarwin(self):
"""Returns true if the OS triple for the selected platform is any valid apple OS"""		"""Returns true if the OS triple for the selected platform is any valid apple OS"""
return lldbplatformutil.platformIsDarwin()		return lldbplatformutil.platformIsDarwin()

def hasDarwinFramework(self):		def hasDarwinFramework(self):
return self.darwinWithFramework		return self.darwinWithFramework

def getPlatform(self):		def getPlatform(self):
▲ Show 20 Lines • Show All 252 Lines • ▼ Show 20 Lines	def buildGModules(
raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")		raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")

module = builder_module()		module = builder_module()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)		dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
if not module.buildGModules(self, architecture, compiler,		if not module.buildGModules(self, architecture, compiler,
dictionary, testdir, testname):		dictionary, testdir, testname):
raise Exception("Don't know how to build binary with gmodules")		raise Exception("Don't know how to build binary with gmodules")

def buildGo(self):
"""Build the default go binary.
"""
exe = self.getBuildArtifact("a.out")
system([[which('go'), 'build -gcflags "-N -l" -o %s main.go' % exe]])

def signBinary(self, binary_path):		def signBinary(self, binary_path):
if sys.platform.startswith("darwin"):		if sys.platform.startswith("darwin"):
codesign_cmd = "codesign --force --sign \"%s\" %s" % (		codesign_cmd = "codesign --force --sign \"%s\" %s" % (
lldbtest_config.codesign_identity, binary_path)		lldbtest_config.codesign_identity, binary_path)
call(codesign_cmd, shell=True)		call(codesign_cmd, shell=True)

def findBuiltClang(self):		def findBuiltClang(self):
"""Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""		"""Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
▲ Show 20 Lines • Show All 894 Lines • Show Last 20 Lines

source/API/SystemInitializerFull.cpp

Show All 18 Lines
#include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"		#include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
#endif		#endif

#include "lldb/Core/Debugger.h"		#include "lldb/Core/Debugger.h"
#include "lldb/Host/Host.h"		#include "lldb/Host/Host.h"
#include "lldb/Initialization/SystemInitializerCommon.h"		#include "lldb/Initialization/SystemInitializerCommon.h"
#include "lldb/Interpreter/CommandInterpreter.h"		#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/ClangASTContext.h"		#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/GoASTContext.h"
#include "lldb/Symbol/JavaASTContext.h"		#include "lldb/Symbol/JavaASTContext.h"
#include "lldb/Symbol/OCamlASTContext.h"		#include "lldb/Symbol/OCamlASTContext.h"
#include "lldb/Utility/Timer.h"		#include "lldb/Utility/Timer.h"

#include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"		#include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"
#include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h"		#include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h"
#include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"		#include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"
#include "Plugins/ABI/SysV-arm/ABISysV_arm.h"		#include "Plugins/ABI/SysV-arm/ABISysV_arm.h"
Show All 17 Lines
#include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"		#include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"
#include "Plugins/Instruction/PPC64/EmulateInstructionPPC64.h"		#include "Plugins/Instruction/PPC64/EmulateInstructionPPC64.h"
#include "Plugins/InstrumentationRuntime/ASan/ASanRuntime.h"		#include "Plugins/InstrumentationRuntime/ASan/ASanRuntime.h"
#include "Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.h"		#include "Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.h"
#include "Plugins/InstrumentationRuntime/TSan/TSanRuntime.h"		#include "Plugins/InstrumentationRuntime/TSan/TSanRuntime.h"
#include "Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h"		#include "Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h"
#include "Plugins/JITLoader/GDB/JITLoaderGDB.h"		#include "Plugins/JITLoader/GDB/JITLoaderGDB.h"
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"		#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
#include "Plugins/Language/Go/GoLanguage.h"
#include "Plugins/Language/Java/JavaLanguage.h"		#include "Plugins/Language/Java/JavaLanguage.h"
#include "Plugins/Language/OCaml/OCamlLanguage.h"		#include "Plugins/Language/OCaml/OCamlLanguage.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h"		#include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"		#include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"
#include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"		#include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"
#include "Plugins/LanguageRuntime/Go/GoLanguageRuntime.h"
#include "Plugins/LanguageRuntime/Java/JavaLanguageRuntime.h"		#include "Plugins/LanguageRuntime/Java/JavaLanguageRuntime.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"		#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"		#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"
#include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"		#include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"
#include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"		#include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"
#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"		#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
#include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"		#include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"		#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
#include "Plugins/OperatingSystem/Go/OperatingSystemGo.h"
#include "Plugins/OperatingSystem/Python/OperatingSystemPython.h"		#include "Plugins/OperatingSystem/Python/OperatingSystemPython.h"
#include "Plugins/Platform/Android/PlatformAndroid.h"		#include "Plugins/Platform/Android/PlatformAndroid.h"
#include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"		#include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"
#include "Plugins/Platform/Kalimba/PlatformKalimba.h"		#include "Plugins/Platform/Kalimba/PlatformKalimba.h"
#include "Plugins/Platform/Linux/PlatformLinux.h"		#include "Plugins/Platform/Linux/PlatformLinux.h"
#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"		#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"		#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
#include "Plugins/Platform/NetBSD/PlatformNetBSD.h"		#include "Plugins/Platform/NetBSD/PlatformNetBSD.h"
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines

extern "C" void *LLDBSwigPythonCreateScriptedThreadPlan(		extern "C" void *LLDBSwigPythonCreateScriptedThreadPlan(
const char python_class_name, const char session_dictionary_name,		const char python_class_name, const char session_dictionary_name,
const lldb::ThreadPlanSP &thread_plan_sp);		const lldb::ThreadPlanSP &thread_plan_sp);

extern "C" bool LLDBSWIGPythonCallThreadPlan(void *implementor,		extern "C" bool LLDBSWIGPythonCallThreadPlan(void *implementor,
const char *method_name,		const char *method_name,
Event *event_sp, bool &got_error);		Event *event_sp, bool &got_error);

extern "C" void *LLDBSwigPythonCreateScriptedBreakpointResolver(		extern "C" void *LLDBSwigPythonCreateScriptedBreakpointResolver(
const char *python_class_name,		const char *python_class_name,
const char *session_dictionary_name,		const char *session_dictionary_name,
lldb_private::StructuredDataImpl *args,		lldb_private::StructuredDataImpl *args,
lldb::BreakpointSP &bkpt_sp);		lldb::BreakpointSP &bkpt_sp);

extern "C" unsigned int LLDBSwigPythonCallBreakpointResolver(		extern "C" unsigned int LLDBSwigPythonCallBreakpointResolver(
void *implementor,		void *implementor,
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines	void SystemInitializerFull::Initialize() {
ObjectFileMachO::Initialize();		ObjectFileMachO::Initialize();
ObjectFilePECOFF::Initialize();		ObjectFilePECOFF::Initialize();

ScriptInterpreterNone::Initialize();		ScriptInterpreterNone::Initialize();

#ifndef LLDB_DISABLE_PYTHON		#ifndef LLDB_DISABLE_PYTHON
OperatingSystemPython::Initialize();		OperatingSystemPython::Initialize();
#endif		#endif
OperatingSystemGo::Initialize();

#if !defined(LLDB_DISABLE_PYTHON)		#if !defined(LLDB_DISABLE_PYTHON)
InitializeSWIG();		InitializeSWIG();

// ScriptInterpreterPython::Initialize() depends on things like HostInfo		// ScriptInterpreterPython::Initialize() depends on things like HostInfo
// being initialized so it can compute the python directory etc, so we need		// being initialized so it can compute the python directory etc, so we need
// to do this after SystemInitializerCommon::Initialize().		// to do this after SystemInitializerCommon::Initialize().
ScriptInterpreterPython::Initialize();		ScriptInterpreterPython::Initialize();
Show All 15 Lines	#endif

// Initialize LLVM and Clang		// Initialize LLVM and Clang
llvm::InitializeAllTargets();		llvm::InitializeAllTargets();
llvm::InitializeAllAsmPrinters();		llvm::InitializeAllAsmPrinters();
llvm::InitializeAllTargetMCs();		llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();		llvm::InitializeAllDisassemblers();

ClangASTContext::Initialize();		ClangASTContext::Initialize();
GoASTContext::Initialize();
JavaASTContext::Initialize();		JavaASTContext::Initialize();
OCamlASTContext::Initialize();		OCamlASTContext::Initialize();

ABIMacOSX_i386::Initialize();		ABIMacOSX_i386::Initialize();
ABIMacOSX_arm::Initialize();		ABIMacOSX_arm::Initialize();
ABIMacOSX_arm64::Initialize();		ABIMacOSX_arm64::Initialize();
ABISysV_arm::Initialize();		ABISysV_arm::Initialize();
ABISysV_arm64::Initialize();		ABISysV_arm64::Initialize();
Show All 30 Lines	#endif
EmulateInstructionARM64::Initialize();		EmulateInstructionARM64::Initialize();
EmulateInstructionPPC64::Initialize();		EmulateInstructionPPC64::Initialize();
SymbolFileDWARFDebugMap::Initialize();		SymbolFileDWARFDebugMap::Initialize();
ItaniumABILanguageRuntime::Initialize();		ItaniumABILanguageRuntime::Initialize();
AppleObjCRuntimeV2::Initialize();		AppleObjCRuntimeV2::Initialize();
AppleObjCRuntimeV1::Initialize();		AppleObjCRuntimeV1::Initialize();
SystemRuntimeMacOSX::Initialize();		SystemRuntimeMacOSX::Initialize();
RenderScriptRuntime::Initialize();		RenderScriptRuntime::Initialize();
GoLanguageRuntime::Initialize();
JavaLanguageRuntime::Initialize();		JavaLanguageRuntime::Initialize();

CPlusPlusLanguage::Initialize();		CPlusPlusLanguage::Initialize();
GoLanguage::Initialize();
JavaLanguage::Initialize();		JavaLanguage::Initialize();
ObjCLanguage::Initialize();		ObjCLanguage::Initialize();
ObjCPlusPlusLanguage::Initialize();		ObjCPlusPlusLanguage::Initialize();
OCamlLanguage::Initialize();		OCamlLanguage::Initialize();

#if defined(_WIN32)		#if defined(_WIN32)
ProcessWindows::Initialize();		ProcessWindows::Initialize();
#endif		#endif
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines	void SystemInitializerFull::Terminate() {
Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);		Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);

Debugger::SettingsTerminate();		Debugger::SettingsTerminate();

// Terminate and unload and loaded system or user LLDB plug-ins		// Terminate and unload and loaded system or user LLDB plug-ins
PluginManager::Terminate();		PluginManager::Terminate();

ClangASTContext::Terminate();		ClangASTContext::Terminate();
GoASTContext::Terminate();
JavaASTContext::Terminate();		JavaASTContext::Terminate();
OCamlASTContext::Terminate();		OCamlASTContext::Terminate();

ABIMacOSX_i386::Terminate();		ABIMacOSX_i386::Terminate();
ABIMacOSX_arm::Terminate();		ABIMacOSX_arm::Terminate();
ABIMacOSX_arm64::Terminate();		ABIMacOSX_arm64::Terminate();
ABISysV_arm::Terminate();		ABISysV_arm::Terminate();
ABISysV_arm64::Terminate();		ABISysV_arm64::Terminate();
Show All 28 Lines	void SystemInitializerFull::Terminate() {
ItaniumABILanguageRuntime::Terminate();		ItaniumABILanguageRuntime::Terminate();
AppleObjCRuntimeV2::Terminate();		AppleObjCRuntimeV2::Terminate();
AppleObjCRuntimeV1::Terminate();		AppleObjCRuntimeV1::Terminate();
SystemRuntimeMacOSX::Terminate();		SystemRuntimeMacOSX::Terminate();
RenderScriptRuntime::Terminate();		RenderScriptRuntime::Terminate();
JavaLanguageRuntime::Terminate();		JavaLanguageRuntime::Terminate();

CPlusPlusLanguage::Terminate();		CPlusPlusLanguage::Terminate();
GoLanguage::Terminate();
JavaLanguage::Terminate();		JavaLanguage::Terminate();
ObjCLanguage::Terminate();		ObjCLanguage::Terminate();
ObjCPlusPlusLanguage::Terminate();		ObjCPlusPlusLanguage::Terminate();
OCamlLanguage::Terminate();		OCamlLanguage::Terminate();

#if defined(__APPLE__)		#if defined(__APPLE__)
DynamicLoaderDarwinKernel::Terminate();		DynamicLoaderDarwinKernel::Terminate();
ProcessKDP::Terminate();		ProcessKDP::Terminate();
Show All 18 Lines	#endif
DynamicLoaderMacOS::Terminate();		DynamicLoaderMacOS::Terminate();
DynamicLoaderPOSIXDYLD::Terminate();		DynamicLoaderPOSIXDYLD::Terminate();
DynamicLoaderStatic::Terminate();		DynamicLoaderStatic::Terminate();
DynamicLoaderWindowsDYLD::Terminate();		DynamicLoaderWindowsDYLD::Terminate();

#ifndef LLDB_DISABLE_PYTHON		#ifndef LLDB_DISABLE_PYTHON
OperatingSystemPython::Terminate();		OperatingSystemPython::Terminate();
#endif		#endif
OperatingSystemGo::Terminate();

platform_freebsd::PlatformFreeBSD::Terminate();		platform_freebsd::PlatformFreeBSD::Terminate();
platform_linux::PlatformLinux::Terminate();		platform_linux::PlatformLinux::Terminate();
platform_netbsd::PlatformNetBSD::Terminate();		platform_netbsd::PlatformNetBSD::Terminate();
platform_openbsd::PlatformOpenBSD::Terminate();		platform_openbsd::PlatformOpenBSD::Terminate();
PlatformWindows::Terminate();		PlatformWindows::Terminate();
PlatformKalimba::Terminate();		PlatformKalimba::Terminate();
platform_android::PlatformAndroid::Terminate();		platform_android::PlatformAndroid::Terminate();
Show All 14 Lines

source/Plugins/ExpressionParser/CMakeLists.txt

	add_subdirectory(Clang)			add_subdirectory(Clang)
	add_subdirectory(Go)

source/Plugins/ExpressionParser/Go/CMakeLists.txt

This file was deleted.

	add_lldb_library(lldbPluginExpressionParserGo PLUGIN
	GoLexer.cpp
	GoParser.cpp
	GoUserExpression.cpp

	LINK_LIBS
	lldbCore
	lldbExpression
	lldbSymbol
	lldbTarget
	LINK_COMPONENTS
	Support
	)

source/Plugins/ExpressionParser/Go/GoAST.h

This file was deleted.

	//===-- GoAST.h -------------------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	// DO NOT EDIT.
	// Generated by gen_go_ast.py

	#ifndef liblldb_GoAST_h
	#define liblldb_GoAST_h

	#include "Plugins/ExpressionParser/Go/GoLexer.h"
	#include "lldb/lldb-forward.h"
	#include "lldb/lldb-private.h"
	#include "llvm/Support/Casting.h"

	namespace lldb_private {

	class GoASTNode {
	public:
	typedef GoLexer::TokenType TokenType;
	typedef GoLexer::Token Token;
	enum ChanDir {
	eChanBidir,
	eChanSend,
	eChanRecv,
	};
	enum NodeKind {
	eBadDecl,
	eFuncDecl,
	eGenDecl,
	eArrayType,
	eBadExpr,
	eBasicLit,
	eBinaryExpr,
	eIdent,
	eCallExpr,
	eChanType,
	eCompositeLit,
	eEllipsis,
	eFuncType,
	eFuncLit,
	eIndexExpr,
	eInterfaceType,
	eKeyValueExpr,
	eMapType,
	eParenExpr,
	eSelectorExpr,
	eSliceExpr,
	eStarExpr,
	eStructType,
	eTypeAssertExpr,
	eUnaryExpr,
	eImportSpec,
	eTypeSpec,
	eValueSpec,
	eAssignStmt,
	eBadStmt,
	eBlockStmt,
	eBranchStmt,
	eCaseClause,
	eCommClause,
	eDeclStmt,
	eDeferStmt,
	eEmptyStmt,
	eExprStmt,
	eForStmt,
	eGoStmt,
	eIfStmt,
	eIncDecStmt,
	eLabeledStmt,
	eRangeStmt,
	eReturnStmt,
	eSelectStmt,
	eSendStmt,
	eSwitchStmt,
	eTypeSwitchStmt,
	eField,
	eFieldList,
	};

	virtual ~GoASTNode() = default;

	NodeKind GetKind() const { return m_kind; }

	virtual const char *GetKindName() const = 0;

	template <typename V> void WalkChildren(V &v);

	protected:
	explicit GoASTNode(NodeKind kind) : m_kind(kind) {}

	private:
	const NodeKind m_kind;

	GoASTNode(const GoASTNode &) = delete;
	const GoASTNode &operator=(const GoASTNode &) = delete;
	};

	class GoASTDecl : public GoASTNode {
	public:
	template <typename R, typename V> R Visit(V *v) const;

	static bool classof(const GoASTNode *n) {
	return n->GetKind() >= eBadDecl && n->GetKind() <= eGenDecl;
	}

	protected:
	explicit GoASTDecl(NodeKind kind) : GoASTNode(kind) {}

	private:
	GoASTDecl(const GoASTDecl &) = delete;
	const GoASTDecl &operator=(const GoASTDecl &) = delete;
	};

	class GoASTExpr : public GoASTNode {
	public:
	template <typename R, typename V> R Visit(V *v) const;

	static bool classof(const GoASTNode *n) {
	return n->GetKind() >= eArrayType && n->GetKind() <= eUnaryExpr;
	}

	protected:
	explicit GoASTExpr(NodeKind kind) : GoASTNode(kind) {}

	private:
	GoASTExpr(const GoASTExpr &) = delete;
	const GoASTExpr &operator=(const GoASTExpr &) = delete;
	};

	class GoASTSpec : public GoASTNode {
	public:
	template <typename R, typename V> R Visit(V *v) const;

	static bool classof(const GoASTNode *n) {
	return n->GetKind() >= eImportSpec && n->GetKind() <= eValueSpec;
	}

	protected:
	explicit GoASTSpec(NodeKind kind) : GoASTNode(kind) {}

	private:
	GoASTSpec(const GoASTSpec &) = delete;
	const GoASTSpec &operator=(const GoASTSpec &) = delete;
	};

	class GoASTStmt : public GoASTNode {
	public:
	template <typename R, typename V> R Visit(V *v) const;

	static bool classof(const GoASTNode *n) {
	return n->GetKind() >= eAssignStmt && n->GetKind() <= eTypeSwitchStmt;
	}

	protected:
	explicit GoASTStmt(NodeKind kind) : GoASTNode(kind) {}

	private:
	GoASTStmt(const GoASTStmt &) = delete;
	const GoASTStmt &operator=(const GoASTStmt &) = delete;
	};

	class GoASTArrayType : public GoASTExpr {
	public:
	GoASTArrayType(GoASTExpr len, GoASTExpr elt)
	: GoASTExpr(eArrayType), m_len_up(len), m_elt_up(elt) {}
	~GoASTArrayType() override = default;

	const char *GetKindName() const override { return "ArrayType"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eArrayType; }

	const GoASTExpr *GetLen() const { return m_len_up.get(); }
	void SetLen(GoASTExpr *len) { m_len_up.reset(len); }

	const GoASTExpr *GetElt() const { return m_elt_up.get(); }
	void SetElt(GoASTExpr *elt) { m_elt_up.reset(elt); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_len_up;
	std::unique_ptr<GoASTExpr> m_elt_up;

	GoASTArrayType(const GoASTArrayType &) = delete;
	const GoASTArrayType &operator=(const GoASTArrayType &) = delete;
	};

	class GoASTAssignStmt : public GoASTStmt {
	public:
	explicit GoASTAssignStmt(bool define)
	: GoASTStmt(eAssignStmt), m_define(define) {}
	~GoASTAssignStmt() override = default;

	const char *GetKindName() const override { return "AssignStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eAssignStmt;
	}

	size_t NumLhs() const { return m_lhs.size(); }
	const GoASTExpr *GetLhs(int i) const { return m_lhs[i].get(); }
	void AddLhs(GoASTExpr *lhs) {
	m_lhs.push_back(std::unique_ptr<GoASTExpr>(lhs));
	}

	size_t NumRhs() const { return m_rhs.size(); }
	const GoASTExpr *GetRhs(int i) const { return m_rhs[i].get(); }
	void AddRhs(GoASTExpr *rhs) {
	m_rhs.push_back(std::unique_ptr<GoASTExpr>(rhs));
	}

	bool GetDefine() const { return m_define; }
	void SetDefine(bool define) { m_define = define; }

	private:
	friend class GoASTNode;
	std::vector<std::unique_ptr<GoASTExpr>> m_lhs;
	std::vector<std::unique_ptr<GoASTExpr>> m_rhs;
	bool m_define;

	GoASTAssignStmt(const GoASTAssignStmt &) = delete;
	const GoASTAssignStmt &operator=(const GoASTAssignStmt &) = delete;
	};

	class GoASTBadDecl : public GoASTDecl {
	public:
	GoASTBadDecl() : GoASTDecl(eBadDecl) {}
	~GoASTBadDecl() override = default;

	const char *GetKindName() const override { return "BadDecl"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eBadDecl; }

	GoASTBadDecl(const GoASTBadDecl &) = delete;
	const GoASTBadDecl &operator=(const GoASTBadDecl &) = delete;
	};

	class GoASTBadExpr : public GoASTExpr {
	public:
	GoASTBadExpr() : GoASTExpr(eBadExpr) {}
	~GoASTBadExpr() override = default;

	const char *GetKindName() const override { return "BadExpr"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eBadExpr; }

	GoASTBadExpr(const GoASTBadExpr &) = delete;
	const GoASTBadExpr &operator=(const GoASTBadExpr &) = delete;
	};

	class GoASTBadStmt : public GoASTStmt {
	public:
	GoASTBadStmt() : GoASTStmt(eBadStmt) {}
	~GoASTBadStmt() override = default;

	const char *GetKindName() const override { return "BadStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eBadStmt; }

	GoASTBadStmt(const GoASTBadStmt &) = delete;
	const GoASTBadStmt &operator=(const GoASTBadStmt &) = delete;
	};

	class GoASTBasicLit : public GoASTExpr {
	public:
	explicit GoASTBasicLit(Token value) : GoASTExpr(eBasicLit), m_value(value) {}
	~GoASTBasicLit() override = default;

	const char *GetKindName() const override { return "BasicLit"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eBasicLit; }

	Token GetValue() const { return m_value; }
	void SetValue(Token value) { m_value = value; }

	private:
	friend class GoASTNode;
	Token m_value;

	GoASTBasicLit(const GoASTBasicLit &) = delete;
	const GoASTBasicLit &operator=(const GoASTBasicLit &) = delete;
	};

	class GoASTBinaryExpr : public GoASTExpr {
	public:
	GoASTBinaryExpr(GoASTExpr x, GoASTExpr y, TokenType op)
	: GoASTExpr(eBinaryExpr), m_x_up(x), m_y_up(y), m_op(op) {}
	~GoASTBinaryExpr() override = default;

	const char *GetKindName() const override { return "BinaryExpr"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eBinaryExpr;
	}

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	const GoASTExpr *GetY() const { return m_y_up.get(); }
	void SetY(GoASTExpr *y) { m_y_up.reset(y); }

	TokenType GetOp() const { return m_op; }
	void SetOp(TokenType op) { m_op = op; }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;
	std::unique_ptr<GoASTExpr> m_y_up;
	TokenType m_op;

	GoASTBinaryExpr(const GoASTBinaryExpr &) = delete;
	const GoASTBinaryExpr &operator=(const GoASTBinaryExpr &) = delete;
	};

	class GoASTBlockStmt : public GoASTStmt {
	public:
	GoASTBlockStmt() : GoASTStmt(eBlockStmt) {}
	~GoASTBlockStmt() override = default;

	const char *GetKindName() const override { return "BlockStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eBlockStmt; }

	size_t NumList() const { return m_list.size(); }
	const GoASTStmt *GetList(int i) const { return m_list[i].get(); }
	void AddList(GoASTStmt *list) {
	m_list.push_back(std::unique_ptr<GoASTStmt>(list));
	}

	private:
	friend class GoASTNode;
	std::vector<std::unique_ptr<GoASTStmt>> m_list;

	GoASTBlockStmt(const GoASTBlockStmt &) = delete;
	const GoASTBlockStmt &operator=(const GoASTBlockStmt &) = delete;
	};

	class GoASTIdent : public GoASTExpr {
	public:
	explicit GoASTIdent(Token name) : GoASTExpr(eIdent), m_name(name) {}
	~GoASTIdent() override = default;

	const char *GetKindName() const override { return "Ident"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eIdent; }

	Token GetName() const { return m_name; }
	void SetName(Token name) { m_name = name; }

	private:
	friend class GoASTNode;
	Token m_name;

	GoASTIdent(const GoASTIdent &) = delete;
	const GoASTIdent &operator=(const GoASTIdent &) = delete;
	};

	class GoASTBranchStmt : public GoASTStmt {
	public:
	GoASTBranchStmt(GoASTIdent *label, TokenType tok)
	: GoASTStmt(eBranchStmt), m_label_up(label), m_tok(tok) {}
	~GoASTBranchStmt() override = default;

	const char *GetKindName() const override { return "BranchStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eBranchStmt;
	}

	const GoASTIdent *GetLabel() const { return m_label_up.get(); }
	void SetLabel(GoASTIdent *label) { m_label_up.reset(label); }

	TokenType GetTok() const { return m_tok; }
	void SetTok(TokenType tok) { m_tok = tok; }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTIdent> m_label_up;
	TokenType m_tok;

	GoASTBranchStmt(const GoASTBranchStmt &) = delete;
	const GoASTBranchStmt &operator=(const GoASTBranchStmt &) = delete;
	};

	class GoASTCallExpr : public GoASTExpr {
	public:
	explicit GoASTCallExpr(bool ellipsis)
	: GoASTExpr(eCallExpr), m_ellipsis(ellipsis) {}
	~GoASTCallExpr() override = default;

	const char *GetKindName() const override { return "CallExpr"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eCallExpr; }

	const GoASTExpr *GetFun() const { return m_fun_up.get(); }
	void SetFun(GoASTExpr *fun) { m_fun_up.reset(fun); }

	size_t NumArgs() const { return m_args.size(); }
	const GoASTExpr *GetArgs(int i) const { return m_args[i].get(); }
	void AddArgs(GoASTExpr *args) {
	m_args.push_back(std::unique_ptr<GoASTExpr>(args));
	}

	bool GetEllipsis() const { return m_ellipsis; }
	void SetEllipsis(bool ellipsis) { m_ellipsis = ellipsis; }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_fun_up;
	std::vector<std::unique_ptr<GoASTExpr>> m_args;
	bool m_ellipsis;

	GoASTCallExpr(const GoASTCallExpr &) = delete;
	const GoASTCallExpr &operator=(const GoASTCallExpr &) = delete;
	};

	class GoASTCaseClause : public GoASTStmt {
	public:
	GoASTCaseClause() : GoASTStmt(eCaseClause) {}
	~GoASTCaseClause() override = default;

	const char *GetKindName() const override { return "CaseClause"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eCaseClause;
	}

	size_t NumList() const { return m_list.size(); }
	const GoASTExpr *GetList(int i) const { return m_list[i].get(); }
	void AddList(GoASTExpr *list) {
	m_list.push_back(std::unique_ptr<GoASTExpr>(list));
	}

	size_t NumBody() const { return m_body.size(); }
	const GoASTStmt *GetBody(int i) const { return m_body[i].get(); }
	void AddBody(GoASTStmt *body) {
	m_body.push_back(std::unique_ptr<GoASTStmt>(body));
	}

	private:
	friend class GoASTNode;
	std::vector<std::unique_ptr<GoASTExpr>> m_list;
	std::vector<std::unique_ptr<GoASTStmt>> m_body;

	GoASTCaseClause(const GoASTCaseClause &) = delete;
	const GoASTCaseClause &operator=(const GoASTCaseClause &) = delete;
	};

	class GoASTChanType : public GoASTExpr {
	public:
	GoASTChanType(ChanDir dir, GoASTExpr *value)
	: GoASTExpr(eChanType), m_dir(dir), m_value_up(value) {}
	~GoASTChanType() override = default;

	const char *GetKindName() const override { return "ChanType"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eChanType; }

	ChanDir GetDir() const { return m_dir; }
	void SetDir(ChanDir dir) { m_dir = dir; }

	const GoASTExpr *GetValue() const { return m_value_up.get(); }
	void SetValue(GoASTExpr *value) { m_value_up.reset(value); }

	private:
	friend class GoASTNode;
	ChanDir m_dir;
	std::unique_ptr<GoASTExpr> m_value_up;

	GoASTChanType(const GoASTChanType &) = delete;
	const GoASTChanType &operator=(const GoASTChanType &) = delete;
	};

	class GoASTCommClause : public GoASTStmt {
	public:
	GoASTCommClause() : GoASTStmt(eCommClause) {}
	~GoASTCommClause() override = default;

	const char *GetKindName() const override { return "CommClause"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eCommClause;
	}

	const GoASTStmt *GetComm() const { return m_comm_up.get(); }
	void SetComm(GoASTStmt *comm) { m_comm_up.reset(comm); }

	size_t NumBody() const { return m_body.size(); }
	const GoASTStmt *GetBody(int i) const { return m_body[i].get(); }
	void AddBody(GoASTStmt *body) {
	m_body.push_back(std::unique_ptr<GoASTStmt>(body));
	}

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTStmt> m_comm_up;
	std::vector<std::unique_ptr<GoASTStmt>> m_body;

	GoASTCommClause(const GoASTCommClause &) = delete;
	const GoASTCommClause &operator=(const GoASTCommClause &) = delete;
	};

	class GoASTCompositeLit : public GoASTExpr {
	public:
	GoASTCompositeLit() : GoASTExpr(eCompositeLit) {}
	~GoASTCompositeLit() override = default;

	const char *GetKindName() const override { return "CompositeLit"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eCompositeLit;
	}

	const GoASTExpr *GetType() const { return m_type_up.get(); }
	void SetType(GoASTExpr *type) { m_type_up.reset(type); }

	size_t NumElts() const { return m_elts.size(); }
	const GoASTExpr *GetElts(int i) const { return m_elts[i].get(); }
	void AddElts(GoASTExpr *elts) {
	m_elts.push_back(std::unique_ptr<GoASTExpr>(elts));
	}

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_type_up;
	std::vector<std::unique_ptr<GoASTExpr>> m_elts;

	GoASTCompositeLit(const GoASTCompositeLit &) = delete;
	const GoASTCompositeLit &operator=(const GoASTCompositeLit &) = delete;
	};

	class GoASTDeclStmt : public GoASTStmt {
	public:
	explicit GoASTDeclStmt(GoASTDecl *decl)
	: GoASTStmt(eDeclStmt), m_decl_up(decl) {}
	~GoASTDeclStmt() override = default;

	const char *GetKindName() const override { return "DeclStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eDeclStmt; }

	const GoASTDecl *GetDecl() const { return m_decl_up.get(); }
	void SetDecl(GoASTDecl *decl) { m_decl_up.reset(decl); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTDecl> m_decl_up;

	GoASTDeclStmt(const GoASTDeclStmt &) = delete;
	const GoASTDeclStmt &operator=(const GoASTDeclStmt &) = delete;
	};

	class GoASTDeferStmt : public GoASTStmt {
	public:
	explicit GoASTDeferStmt(GoASTCallExpr *call)
	: GoASTStmt(eDeferStmt), m_call_up(call) {}
	~GoASTDeferStmt() override = default;

	const char *GetKindName() const override { return "DeferStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eDeferStmt; }

	const GoASTCallExpr *GetCall() const { return m_call_up.get(); }
	void SetCall(GoASTCallExpr *call) { m_call_up.reset(call); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTCallExpr> m_call_up;

	GoASTDeferStmt(const GoASTDeferStmt &) = delete;
	const GoASTDeferStmt &operator=(const GoASTDeferStmt &) = delete;
	};

	class GoASTEllipsis : public GoASTExpr {
	public:
	explicit GoASTEllipsis(GoASTExpr *elt)
	: GoASTExpr(eEllipsis), m_elt_up(elt) {}
	~GoASTEllipsis() override = default;

	const char *GetKindName() const override { return "Ellipsis"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eEllipsis; }

	const GoASTExpr *GetElt() const { return m_elt_up.get(); }
	void SetElt(GoASTExpr *elt) { m_elt_up.reset(elt); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_elt_up;

	GoASTEllipsis(const GoASTEllipsis &) = delete;
	const GoASTEllipsis &operator=(const GoASTEllipsis &) = delete;
	};

	class GoASTEmptyStmt : public GoASTStmt {
	public:
	GoASTEmptyStmt() : GoASTStmt(eEmptyStmt) {}
	~GoASTEmptyStmt() override = default;

	const char *GetKindName() const override { return "EmptyStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eEmptyStmt; }

	GoASTEmptyStmt(const GoASTEmptyStmt &) = delete;
	const GoASTEmptyStmt &operator=(const GoASTEmptyStmt &) = delete;
	};

	class GoASTExprStmt : public GoASTStmt {
	public:
	explicit GoASTExprStmt(GoASTExpr *x) : GoASTStmt(eExprStmt), m_x_up(x) {}
	~GoASTExprStmt() override = default;

	const char *GetKindName() const override { return "ExprStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eExprStmt; }

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;

	GoASTExprStmt(const GoASTExprStmt &) = delete;
	const GoASTExprStmt &operator=(const GoASTExprStmt &) = delete;
	};

	class GoASTField : public GoASTNode {
	public:
	GoASTField() : GoASTNode(eField) {}
	~GoASTField() override = default;

	const char *GetKindName() const override { return "Field"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eField; }

	size_t NumNames() const { return m_names.size(); }
	const GoASTIdent *GetNames(int i) const { return m_names[i].get(); }
	void AddNames(GoASTIdent *names) {
	m_names.push_back(std::unique_ptr<GoASTIdent>(names));
	}

	const GoASTExpr *GetType() const { return m_type_up.get(); }
	void SetType(GoASTExpr *type) { m_type_up.reset(type); }

	const GoASTBasicLit *GetTag() const { return m_tag_up.get(); }
	void SetTag(GoASTBasicLit *tag) { m_tag_up.reset(tag); }

	private:
	friend class GoASTNode;
	std::vector<std::unique_ptr<GoASTIdent>> m_names;
	std::unique_ptr<GoASTExpr> m_type_up;
	std::unique_ptr<GoASTBasicLit> m_tag_up;

	GoASTField(const GoASTField &) = delete;
	const GoASTField &operator=(const GoASTField &) = delete;
	};

	class GoASTFieldList : public GoASTNode {
	public:
	GoASTFieldList() : GoASTNode(eFieldList) {}
	~GoASTFieldList() override = default;

	const char *GetKindName() const override { return "FieldList"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eFieldList; }

	size_t NumList() const { return m_list.size(); }
	const GoASTField *GetList(int i) const { return m_list[i].get(); }
	void AddList(GoASTField *list) {
	m_list.push_back(std::unique_ptr<GoASTField>(list));
	}

	private:
	friend class GoASTNode;
	std::vector<std::unique_ptr<GoASTField>> m_list;

	GoASTFieldList(const GoASTFieldList &) = delete;
	const GoASTFieldList &operator=(const GoASTFieldList &) = delete;
	};

	class GoASTForStmt : public GoASTStmt {
	public:
	GoASTForStmt(GoASTStmt init, GoASTExpr cond, GoASTStmt *post,
	GoASTBlockStmt *body)
	: GoASTStmt(eForStmt), m_init_up(init), m_cond_up(cond), m_post_up(post),
	m_body_up(body) {}
	~GoASTForStmt() override = default;

	const char *GetKindName() const override { return "ForStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eForStmt; }

	const GoASTStmt *GetInit() const { return m_init_up.get(); }
	void SetInit(GoASTStmt *init) { m_init_up.reset(init); }

	const GoASTExpr *GetCond() const { return m_cond_up.get(); }
	void SetCond(GoASTExpr *cond) { m_cond_up.reset(cond); }

	const GoASTStmt *GetPost() const { return m_post_up.get(); }
	void SetPost(GoASTStmt *post) { m_post_up.reset(post); }

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTStmt> m_init_up;
	std::unique_ptr<GoASTExpr> m_cond_up;
	std::unique_ptr<GoASTStmt> m_post_up;
	std::unique_ptr<GoASTBlockStmt> m_body_up;

	GoASTForStmt(const GoASTForStmt &) = delete;
	const GoASTForStmt &operator=(const GoASTForStmt &) = delete;
	};

	class GoASTFuncType : public GoASTExpr {
	public:
	GoASTFuncType(GoASTFieldList params, GoASTFieldList results)
	: GoASTExpr(eFuncType), m_params_up(params), m_results_up(results) {}
	~GoASTFuncType() override = default;

	const char *GetKindName() const override { return "FuncType"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eFuncType; }

	const GoASTFieldList *GetParams() const { return m_params_up.get(); }
	void SetParams(GoASTFieldList *params) { m_params_up.reset(params); }

	const GoASTFieldList *GetResults() const { return m_results_up.get(); }
	void SetResults(GoASTFieldList *results) { m_results_up.reset(results); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTFieldList> m_params_up;
	std::unique_ptr<GoASTFieldList> m_results_up;

	GoASTFuncType(const GoASTFuncType &) = delete;
	const GoASTFuncType &operator=(const GoASTFuncType &) = delete;
	};

	class GoASTFuncDecl : public GoASTDecl {
	public:
	GoASTFuncDecl(GoASTFieldList recv, GoASTIdent name, GoASTFuncType *type,
	GoASTBlockStmt *body)
	: GoASTDecl(eFuncDecl), m_recv_up(recv), m_name_up(name), m_type_up(type),
	m_body_up(body) {}
	~GoASTFuncDecl() override = default;

	const char *GetKindName() const override { return "FuncDecl"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eFuncDecl; }

	const GoASTFieldList *GetRecv() const { return m_recv_up.get(); }
	void SetRecv(GoASTFieldList *recv) { m_recv_up.reset(recv); }

	const GoASTIdent *GetName() const { return m_name_up.get(); }
	void SetName(GoASTIdent *name) { m_name_up.reset(name); }

	const GoASTFuncType *GetType() const { return m_type_up.get(); }
	void SetType(GoASTFuncType *type) { m_type_up.reset(type); }

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTFieldList> m_recv_up;
	std::unique_ptr<GoASTIdent> m_name_up;
	std::unique_ptr<GoASTFuncType> m_type_up;
	std::unique_ptr<GoASTBlockStmt> m_body_up;

	GoASTFuncDecl(const GoASTFuncDecl &) = delete;
	const GoASTFuncDecl &operator=(const GoASTFuncDecl &) = delete;
	};

	class GoASTFuncLit : public GoASTExpr {
	public:
	GoASTFuncLit(GoASTFuncType type, GoASTBlockStmt body)
	: GoASTExpr(eFuncLit), m_type_up(type), m_body_up(body) {}
	~GoASTFuncLit() override = default;

	const char *GetKindName() const override { return "FuncLit"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eFuncLit; }

	const GoASTFuncType *GetType() const { return m_type_up.get(); }
	void SetType(GoASTFuncType *type) { m_type_up.reset(type); }

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTFuncType> m_type_up;
	std::unique_ptr<GoASTBlockStmt> m_body_up;

	GoASTFuncLit(const GoASTFuncLit &) = delete;
	const GoASTFuncLit &operator=(const GoASTFuncLit &) = delete;
	};

	class GoASTGenDecl : public GoASTDecl {
	public:
	explicit GoASTGenDecl(TokenType tok) : GoASTDecl(eGenDecl), m_tok(tok) {}
	~GoASTGenDecl() override = default;

	const char *GetKindName() const override { return "GenDecl"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eGenDecl; }

	TokenType GetTok() const { return m_tok; }
	void SetTok(TokenType tok) { m_tok = tok; }

	size_t NumSpecs() const { return m_specs.size(); }
	const GoASTSpec *GetSpecs(int i) const { return m_specs[i].get(); }
	void AddSpecs(GoASTSpec *specs) {
	m_specs.push_back(std::unique_ptr<GoASTSpec>(specs));
	}

	private:
	friend class GoASTNode;
	TokenType m_tok;
	std::vector<std::unique_ptr<GoASTSpec>> m_specs;

	GoASTGenDecl(const GoASTGenDecl &) = delete;
	const GoASTGenDecl &operator=(const GoASTGenDecl &) = delete;
	};

	class GoASTGoStmt : public GoASTStmt {
	public:
	explicit GoASTGoStmt(GoASTCallExpr *call)
	: GoASTStmt(eGoStmt), m_call_up(call) {}
	~GoASTGoStmt() override = default;

	const char *GetKindName() const override { return "GoStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eGoStmt; }

	const GoASTCallExpr *GetCall() const { return m_call_up.get(); }
	void SetCall(GoASTCallExpr *call) { m_call_up.reset(call); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTCallExpr> m_call_up;

	GoASTGoStmt(const GoASTGoStmt &) = delete;
	const GoASTGoStmt &operator=(const GoASTGoStmt &) = delete;
	};

	class GoASTIfStmt : public GoASTStmt {
	public:
	GoASTIfStmt(GoASTStmt init, GoASTExpr cond, GoASTBlockStmt *body,
	GoASTStmt *els)
	: GoASTStmt(eIfStmt), m_init_up(init), m_cond_up(cond), m_body_up(body),
	m_els_up(els) {}
	~GoASTIfStmt() override = default;

	const char *GetKindName() const override { return "IfStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eIfStmt; }

	const GoASTStmt *GetInit() const { return m_init_up.get(); }
	void SetInit(GoASTStmt *init) { m_init_up.reset(init); }

	const GoASTExpr *GetCond() const { return m_cond_up.get(); }
	void SetCond(GoASTExpr *cond) { m_cond_up.reset(cond); }

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	const GoASTStmt *GetEls() const { return m_els_up.get(); }
	void SetEls(GoASTStmt *els) { m_els_up.reset(els); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTStmt> m_init_up;
	std::unique_ptr<GoASTExpr> m_cond_up;
	std::unique_ptr<GoASTBlockStmt> m_body_up;
	std::unique_ptr<GoASTStmt> m_els_up;

	GoASTIfStmt(const GoASTIfStmt &) = delete;
	const GoASTIfStmt &operator=(const GoASTIfStmt &) = delete;
	};

	class GoASTImportSpec : public GoASTSpec {
	public:
	GoASTImportSpec(GoASTIdent name, GoASTBasicLit path)
	: GoASTSpec(eImportSpec), m_name_up(name), m_path_up(path) {}
	~GoASTImportSpec() override = default;

	const char *GetKindName() const override { return "ImportSpec"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eImportSpec;
	}

	const GoASTIdent *GetName() const { return m_name_up.get(); }
	void SetName(GoASTIdent *name) { m_name_up.reset(name); }

	const GoASTBasicLit *GetPath() const { return m_path_up.get(); }
	void SetPath(GoASTBasicLit *path) { m_path_up.reset(path); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTIdent> m_name_up;
	std::unique_ptr<GoASTBasicLit> m_path_up;

	GoASTImportSpec(const GoASTImportSpec &) = delete;
	const GoASTImportSpec &operator=(const GoASTImportSpec &) = delete;
	};

	class GoASTIncDecStmt : public GoASTStmt {
	public:
	GoASTIncDecStmt(GoASTExpr *x, TokenType tok)
	: GoASTStmt(eIncDecStmt), m_x_up(x), m_tok(tok) {}
	~GoASTIncDecStmt() override = default;

	const char *GetKindName() const override { return "IncDecStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eIncDecStmt;
	}

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	TokenType GetTok() const { return m_tok; }
	void SetTok(TokenType tok) { m_tok = tok; }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;
	TokenType m_tok;

	GoASTIncDecStmt(const GoASTIncDecStmt &) = delete;
	const GoASTIncDecStmt &operator=(const GoASTIncDecStmt &) = delete;
	};

	class GoASTIndexExpr : public GoASTExpr {
	public:
	GoASTIndexExpr(GoASTExpr x, GoASTExpr index)
	: GoASTExpr(eIndexExpr), m_x_up(x), m_index_up(index) {}
	~GoASTIndexExpr() override = default;

	const char *GetKindName() const override { return "IndexExpr"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eIndexExpr; }

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	const GoASTExpr *GetIndex() const { return m_index_up.get(); }
	void SetIndex(GoASTExpr *index) { m_index_up.reset(index); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;
	std::unique_ptr<GoASTExpr> m_index_up;

	GoASTIndexExpr(const GoASTIndexExpr &) = delete;
	const GoASTIndexExpr &operator=(const GoASTIndexExpr &) = delete;
	};

	class GoASTInterfaceType : public GoASTExpr {
	public:
	explicit GoASTInterfaceType(GoASTFieldList *methods)
	: GoASTExpr(eInterfaceType), m_methods_up(methods) {}
	~GoASTInterfaceType() override = default;

	const char *GetKindName() const override { return "InterfaceType"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eInterfaceType;
	}

	const GoASTFieldList *GetMethods() const { return m_methods_up.get(); }
	void SetMethods(GoASTFieldList *methods) { m_methods_up.reset(methods); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTFieldList> m_methods_up;

	GoASTInterfaceType(const GoASTInterfaceType &) = delete;
	const GoASTInterfaceType &operator=(const GoASTInterfaceType &) = delete;
	};

	class GoASTKeyValueExpr : public GoASTExpr {
	public:
	GoASTKeyValueExpr(GoASTExpr key, GoASTExpr value)
	: GoASTExpr(eKeyValueExpr), m_key_up(key), m_value_up(value) {}
	~GoASTKeyValueExpr() override = default;

	const char *GetKindName() const override { return "KeyValueExpr"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eKeyValueExpr;
	}

	const GoASTExpr *GetKey() const { return m_key_up.get(); }
	void SetKey(GoASTExpr *key) { m_key_up.reset(key); }

	const GoASTExpr *GetValue() const { return m_value_up.get(); }
	void SetValue(GoASTExpr *value) { m_value_up.reset(value); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_key_up;
	std::unique_ptr<GoASTExpr> m_value_up;

	GoASTKeyValueExpr(const GoASTKeyValueExpr &) = delete;
	const GoASTKeyValueExpr &operator=(const GoASTKeyValueExpr &) = delete;
	};

	class GoASTLabeledStmt : public GoASTStmt {
	public:
	GoASTLabeledStmt(GoASTIdent label, GoASTStmt stmt)
	: GoASTStmt(eLabeledStmt), m_label_up(label), m_stmt_up(stmt) {}
	~GoASTLabeledStmt() override = default;

	const char *GetKindName() const override { return "LabeledStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eLabeledStmt;
	}

	const GoASTIdent *GetLabel() const { return m_label_up.get(); }
	void SetLabel(GoASTIdent *label) { m_label_up.reset(label); }

	const GoASTStmt *GetStmt() const { return m_stmt_up.get(); }
	void SetStmt(GoASTStmt *stmt) { m_stmt_up.reset(stmt); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTIdent> m_label_up;
	std::unique_ptr<GoASTStmt> m_stmt_up;

	GoASTLabeledStmt(const GoASTLabeledStmt &) = delete;
	const GoASTLabeledStmt &operator=(const GoASTLabeledStmt &) = delete;
	};

	class GoASTMapType : public GoASTExpr {
	public:
	GoASTMapType(GoASTExpr key, GoASTExpr value)
	: GoASTExpr(eMapType), m_key_up(key), m_value_up(value) {}
	~GoASTMapType() override = default;

	const char *GetKindName() const override { return "MapType"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eMapType; }

	const GoASTExpr *GetKey() const { return m_key_up.get(); }
	void SetKey(GoASTExpr *key) { m_key_up.reset(key); }

	const GoASTExpr *GetValue() const { return m_value_up.get(); }
	void SetValue(GoASTExpr *value) { m_value_up.reset(value); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_key_up;
	std::unique_ptr<GoASTExpr> m_value_up;

	GoASTMapType(const GoASTMapType &) = delete;
	const GoASTMapType &operator=(const GoASTMapType &) = delete;
	};

	class GoASTParenExpr : public GoASTExpr {
	public:
	explicit GoASTParenExpr(GoASTExpr *x) : GoASTExpr(eParenExpr), m_x_up(x) {}
	~GoASTParenExpr() override = default;

	const char *GetKindName() const override { return "ParenExpr"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eParenExpr; }

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;

	GoASTParenExpr(const GoASTParenExpr &) = delete;
	const GoASTParenExpr &operator=(const GoASTParenExpr &) = delete;
	};

	class GoASTRangeStmt : public GoASTStmt {
	public:
	GoASTRangeStmt(GoASTExpr key, GoASTExpr value, bool define, GoASTExpr *x,
	GoASTBlockStmt *body)
	: GoASTStmt(eRangeStmt), m_key_up(key), m_value_up(value),
	m_define(define), m_x_up(x), m_body_up(body) {}
	~GoASTRangeStmt() override = default;

	const char *GetKindName() const override { return "RangeStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eRangeStmt; }

	const GoASTExpr *GetKey() const { return m_key_up.get(); }
	void SetKey(GoASTExpr *key) { m_key_up.reset(key); }

	const GoASTExpr *GetValue() const { return m_value_up.get(); }
	void SetValue(GoASTExpr *value) { m_value_up.reset(value); }

	bool GetDefine() const { return m_define; }
	void SetDefine(bool define) { m_define = define; }

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_key_up;
	std::unique_ptr<GoASTExpr> m_value_up;
	bool m_define;
	std::unique_ptr<GoASTExpr> m_x_up;
	std::unique_ptr<GoASTBlockStmt> m_body_up;

	GoASTRangeStmt(const GoASTRangeStmt &) = delete;
	const GoASTRangeStmt &operator=(const GoASTRangeStmt &) = delete;
	};

	class GoASTReturnStmt : public GoASTStmt {
	public:
	GoASTReturnStmt() : GoASTStmt(eReturnStmt) {}
	~GoASTReturnStmt() override = default;

	const char *GetKindName() const override { return "ReturnStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eReturnStmt;
	}

	size_t NumResults() const { return m_results.size(); }
	const GoASTExpr *GetResults(int i) const { return m_results[i].get(); }
	void AddResults(GoASTExpr *results) {
	m_results.push_back(std::unique_ptr<GoASTExpr>(results));
	}

	private:
	friend class GoASTNode;
	std::vector<std::unique_ptr<GoASTExpr>> m_results;

	GoASTReturnStmt(const GoASTReturnStmt &) = delete;
	const GoASTReturnStmt &operator=(const GoASTReturnStmt &) = delete;
	};

	class GoASTSelectStmt : public GoASTStmt {
	public:
	explicit GoASTSelectStmt(GoASTBlockStmt *body)
	: GoASTStmt(eSelectStmt), m_body_up(body) {}
	~GoASTSelectStmt() override = default;

	const char *GetKindName() const override { return "SelectStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eSelectStmt;
	}

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTBlockStmt> m_body_up;

	GoASTSelectStmt(const GoASTSelectStmt &) = delete;
	const GoASTSelectStmt &operator=(const GoASTSelectStmt &) = delete;
	};

	class GoASTSelectorExpr : public GoASTExpr {
	public:
	GoASTSelectorExpr(GoASTExpr x, GoASTIdent sel)
	: GoASTExpr(eSelectorExpr), m_x_up(x), m_sel_up(sel) {}
	~GoASTSelectorExpr() override = default;

	const char *GetKindName() const override { return "SelectorExpr"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eSelectorExpr;
	}

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	const GoASTIdent *GetSel() const { return m_sel_up.get(); }
	void SetSel(GoASTIdent *sel) { m_sel_up.reset(sel); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;
	std::unique_ptr<GoASTIdent> m_sel_up;

	GoASTSelectorExpr(const GoASTSelectorExpr &) = delete;
	const GoASTSelectorExpr &operator=(const GoASTSelectorExpr &) = delete;
	};

	class GoASTSendStmt : public GoASTStmt {
	public:
	GoASTSendStmt(GoASTExpr chan, GoASTExpr value)
	: GoASTStmt(eSendStmt), m_chan_up(chan), m_value_up(value) {}
	~GoASTSendStmt() override = default;

	const char *GetKindName() const override { return "SendStmt"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eSendStmt; }

	const GoASTExpr *GetChan() const { return m_chan_up.get(); }
	void SetChan(GoASTExpr *chan) { m_chan_up.reset(chan); }

	const GoASTExpr *GetValue() const { return m_value_up.get(); }
	void SetValue(GoASTExpr *value) { m_value_up.reset(value); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_chan_up;
	std::unique_ptr<GoASTExpr> m_value_up;

	GoASTSendStmt(const GoASTSendStmt &) = delete;
	const GoASTSendStmt &operator=(const GoASTSendStmt &) = delete;
	};

	class GoASTSliceExpr : public GoASTExpr {
	public:
	GoASTSliceExpr(GoASTExpr x, GoASTExpr low, GoASTExpr high, GoASTExpr max,
	bool slice3)
	: GoASTExpr(eSliceExpr), m_x_up(x), m_low_up(low), m_high_up(high),
	m_max_up(max), m_slice3(slice3) {}
	~GoASTSliceExpr() override = default;

	const char *GetKindName() const override { return "SliceExpr"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eSliceExpr; }

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	const GoASTExpr *GetLow() const { return m_low_up.get(); }
	void SetLow(GoASTExpr *low) { m_low_up.reset(low); }

	const GoASTExpr *GetHigh() const { return m_high_up.get(); }
	void SetHigh(GoASTExpr *high) { m_high_up.reset(high); }

	const GoASTExpr *GetMax() const { return m_max_up.get(); }
	void SetMax(GoASTExpr *max) { m_max_up.reset(max); }

	bool GetSlice3() const { return m_slice3; }
	void SetSlice3(bool slice3) { m_slice3 = slice3; }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;
	std::unique_ptr<GoASTExpr> m_low_up;
	std::unique_ptr<GoASTExpr> m_high_up;
	std::unique_ptr<GoASTExpr> m_max_up;
	bool m_slice3;

	GoASTSliceExpr(const GoASTSliceExpr &) = delete;
	const GoASTSliceExpr &operator=(const GoASTSliceExpr &) = delete;
	};

	class GoASTStarExpr : public GoASTExpr {
	public:
	explicit GoASTStarExpr(GoASTExpr *x) : GoASTExpr(eStarExpr), m_x_up(x) {}
	~GoASTStarExpr() override = default;

	const char *GetKindName() const override { return "StarExpr"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eStarExpr; }

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;

	GoASTStarExpr(const GoASTStarExpr &) = delete;
	const GoASTStarExpr &operator=(const GoASTStarExpr &) = delete;
	};

	class GoASTStructType : public GoASTExpr {
	public:
	explicit GoASTStructType(GoASTFieldList *fields)
	: GoASTExpr(eStructType), m_fields_up(fields) {}
	~GoASTStructType() override = default;

	const char *GetKindName() const override { return "StructType"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eStructType;
	}

	const GoASTFieldList *GetFields() const { return m_fields_up.get(); }
	void SetFields(GoASTFieldList *fields) { m_fields_up.reset(fields); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTFieldList> m_fields_up;

	GoASTStructType(const GoASTStructType &) = delete;
	const GoASTStructType &operator=(const GoASTStructType &) = delete;
	};

	class GoASTSwitchStmt : public GoASTStmt {
	public:
	GoASTSwitchStmt(GoASTStmt init, GoASTExpr tag, GoASTBlockStmt *body)
	: GoASTStmt(eSwitchStmt), m_init_up(init), m_tag_up(tag),
	m_body_up(body) {}
	~GoASTSwitchStmt() override = default;

	const char *GetKindName() const override { return "SwitchStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eSwitchStmt;
	}

	const GoASTStmt *GetInit() const { return m_init_up.get(); }
	void SetInit(GoASTStmt *init) { m_init_up.reset(init); }

	const GoASTExpr *GetTag() const { return m_tag_up.get(); }
	void SetTag(GoASTExpr *tag) { m_tag_up.reset(tag); }

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTStmt> m_init_up;
	std::unique_ptr<GoASTExpr> m_tag_up;
	std::unique_ptr<GoASTBlockStmt> m_body_up;

	GoASTSwitchStmt(const GoASTSwitchStmt &) = delete;
	const GoASTSwitchStmt &operator=(const GoASTSwitchStmt &) = delete;
	};

	class GoASTTypeAssertExpr : public GoASTExpr {
	public:
	GoASTTypeAssertExpr(GoASTExpr x, GoASTExpr type)
	: GoASTExpr(eTypeAssertExpr), m_x_up(x), m_type_up(type) {}
	~GoASTTypeAssertExpr() override = default;

	const char *GetKindName() const override { return "TypeAssertExpr"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eTypeAssertExpr;
	}

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	const GoASTExpr *GetType() const { return m_type_up.get(); }
	void SetType(GoASTExpr *type) { m_type_up.reset(type); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTExpr> m_x_up;
	std::unique_ptr<GoASTExpr> m_type_up;

	GoASTTypeAssertExpr(const GoASTTypeAssertExpr &) = delete;
	const GoASTTypeAssertExpr &operator=(const GoASTTypeAssertExpr &) = delete;
	};

	class GoASTTypeSpec : public GoASTSpec {
	public:
	GoASTTypeSpec(GoASTIdent name, GoASTExpr type)
	: GoASTSpec(eTypeSpec), m_name_up(name), m_type_up(type) {}
	~GoASTTypeSpec() override = default;

	const char *GetKindName() const override { return "TypeSpec"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eTypeSpec; }

	const GoASTIdent *GetName() const { return m_name_up.get(); }
	void SetName(GoASTIdent *name) { m_name_up.reset(name); }

	const GoASTExpr *GetType() const { return m_type_up.get(); }
	void SetType(GoASTExpr *type) { m_type_up.reset(type); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTIdent> m_name_up;
	std::unique_ptr<GoASTExpr> m_type_up;

	GoASTTypeSpec(const GoASTTypeSpec &) = delete;
	const GoASTTypeSpec &operator=(const GoASTTypeSpec &) = delete;
	};

	class GoASTTypeSwitchStmt : public GoASTStmt {
	public:
	GoASTTypeSwitchStmt(GoASTStmt init, GoASTStmt assign, GoASTBlockStmt *body)
	: GoASTStmt(eTypeSwitchStmt), m_init_up(init), m_assign_up(assign),
	m_body_up(body) {}
	~GoASTTypeSwitchStmt() override = default;

	const char *GetKindName() const override { return "TypeSwitchStmt"; }

	static bool classof(const GoASTNode *n) {
	return n->GetKind() == eTypeSwitchStmt;
	}

	const GoASTStmt *GetInit() const { return m_init_up.get(); }
	void SetInit(GoASTStmt *init) { m_init_up.reset(init); }

	const GoASTStmt *GetAssign() const { return m_assign_up.get(); }
	void SetAssign(GoASTStmt *assign) { m_assign_up.reset(assign); }

	const GoASTBlockStmt *GetBody() const { return m_body_up.get(); }
	void SetBody(GoASTBlockStmt *body) { m_body_up.reset(body); }

	private:
	friend class GoASTNode;
	std::unique_ptr<GoASTStmt> m_init_up;
	std::unique_ptr<GoASTStmt> m_assign_up;
	std::unique_ptr<GoASTBlockStmt> m_body_up;

	GoASTTypeSwitchStmt(const GoASTTypeSwitchStmt &) = delete;
	const GoASTTypeSwitchStmt &operator=(const GoASTTypeSwitchStmt &) = delete;
	};

	class GoASTUnaryExpr : public GoASTExpr {
	public:
	GoASTUnaryExpr(TokenType op, GoASTExpr *x)
	: GoASTExpr(eUnaryExpr), m_op(op), m_x_up(x) {}
	~GoASTUnaryExpr() override = default;

	const char *GetKindName() const override { return "UnaryExpr"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eUnaryExpr; }

	TokenType GetOp() const { return m_op; }
	void SetOp(TokenType op) { m_op = op; }

	const GoASTExpr *GetX() const { return m_x_up.get(); }
	void SetX(GoASTExpr *x) { m_x_up.reset(x); }

	private:
	friend class GoASTNode;
	TokenType m_op;
	std::unique_ptr<GoASTExpr> m_x_up;

	GoASTUnaryExpr(const GoASTUnaryExpr &) = delete;
	const GoASTUnaryExpr &operator=(const GoASTUnaryExpr &) = delete;
	};

	class GoASTValueSpec : public GoASTSpec {
	public:
	GoASTValueSpec() : GoASTSpec(eValueSpec) {}
	~GoASTValueSpec() override = default;

	const char *GetKindName() const override { return "ValueSpec"; }

	static bool classof(const GoASTNode *n) { return n->GetKind() == eValueSpec; }

	size_t NumNames() const { return m_names.size(); }
	const GoASTIdent *GetNames(int i) const { return m_names[i].get(); }
	void AddNames(GoASTIdent *names) {
	m_names.push_back(std::unique_ptr<GoASTIdent>(names));
	}

	const GoASTExpr *GetType() const { return m_type_up.get(); }
	void SetType(GoASTExpr *type) { m_type_up.reset(type); }

	size_t NumValues() const { return m_values.size(); }
	const GoASTExpr *GetValues(int i) const { return m_values[i].get(); }
	void AddValues(GoASTExpr *values) {
	m_values.push_back(std::unique_ptr<GoASTExpr>(values));
	}

	private:
	friend class GoASTNode;
	std::vector<std::unique_ptr<GoASTIdent>> m_names;
	std::unique_ptr<GoASTExpr> m_type_up;
	std::vector<std::unique_ptr<GoASTExpr>> m_values;

	GoASTValueSpec(const GoASTValueSpec &) = delete;
	const GoASTValueSpec &operator=(const GoASTValueSpec &) = delete;
	};

	template <typename R, typename V> R GoASTDecl::Visit(V *v) const {
	switch (GetKind()) {
	case eBadDecl:
	return v->VisitBadDecl(llvm::cast<const GoASTBadDecl>(this));
	case eFuncDecl:
	return v->VisitFuncDecl(llvm::cast<const GoASTFuncDecl>(this));
	case eGenDecl:
	return v->VisitGenDecl(llvm::cast<const GoASTGenDecl>(this));
	default:
	assert(false && "Invalid kind");
	}
	}

	template <typename R, typename V> R GoASTExpr::Visit(V *v) const {
	switch (GetKind()) {
	case eArrayType:
	return v->VisitArrayType(llvm::cast<const GoASTArrayType>(this));
	case eBadExpr:
	return v->VisitBadExpr(llvm::cast<const GoASTBadExpr>(this));
	case eBasicLit:
	return v->VisitBasicLit(llvm::cast<const GoASTBasicLit>(this));
	case eBinaryExpr:
	return v->VisitBinaryExpr(llvm::cast<const GoASTBinaryExpr>(this));
	case eIdent:
	return v->VisitIdent(llvm::cast<const GoASTIdent>(this));
	case eCallExpr:
	return v->VisitCallExpr(llvm::cast<const GoASTCallExpr>(this));
	case eChanType:
	return v->VisitChanType(llvm::cast<const GoASTChanType>(this));
	case eCompositeLit:
	return v->VisitCompositeLit(llvm::cast<const GoASTCompositeLit>(this));
	case eEllipsis:
	return v->VisitEllipsis(llvm::cast<const GoASTEllipsis>(this));
	case eFuncType:
	return v->VisitFuncType(llvm::cast<const GoASTFuncType>(this));
	case eFuncLit:
	return v->VisitFuncLit(llvm::cast<const GoASTFuncLit>(this));
	case eIndexExpr:
	return v->VisitIndexExpr(llvm::cast<const GoASTIndexExpr>(this));
	case eInterfaceType:
	return v->VisitInterfaceType(llvm::cast<const GoASTInterfaceType>(this));
	case eKeyValueExpr:
	return v->VisitKeyValueExpr(llvm::cast<const GoASTKeyValueExpr>(this));
	case eMapType:
	return v->VisitMapType(llvm::cast<const GoASTMapType>(this));
	case eParenExpr:
	return v->VisitParenExpr(llvm::cast<const GoASTParenExpr>(this));
	case eSelectorExpr:
	return v->VisitSelectorExpr(llvm::cast<const GoASTSelectorExpr>(this));
	case eSliceExpr:
	return v->VisitSliceExpr(llvm::cast<const GoASTSliceExpr>(this));
	case eStarExpr:
	return v->VisitStarExpr(llvm::cast<const GoASTStarExpr>(this));
	case eStructType:
	return v->VisitStructType(llvm::cast<const GoASTStructType>(this));
	case eTypeAssertExpr:
	return v->VisitTypeAssertExpr(llvm::cast<const GoASTTypeAssertExpr>(this));
	case eUnaryExpr:
	return v->VisitUnaryExpr(llvm::cast<const GoASTUnaryExpr>(this));
	default:
	assert(false && "Invalid kind");
	return R();
	}
	}

	template <typename R, typename V> R GoASTSpec::Visit(V *v) const {
	switch (GetKind()) {
	case eImportSpec:
	return v->VisitImportSpec(llvm::cast<const GoASTImportSpec>(this));
	case eTypeSpec:
	return v->VisitTypeSpec(llvm::cast<const GoASTTypeSpec>(this));
	case eValueSpec:
	return v->VisitValueSpec(llvm::cast<const GoASTValueSpec>(this));
	default:
	assert(false && "Invalid kind");
	}
	}

	template <typename R, typename V> R GoASTStmt::Visit(V *v) const {
	switch (GetKind()) {
	case eAssignStmt:
	return v->VisitAssignStmt(llvm::cast<const GoASTAssignStmt>(this));
	case eBadStmt:
	return v->VisitBadStmt(llvm::cast<const GoASTBadStmt>(this));
	case eBlockStmt:
	return v->VisitBlockStmt(llvm::cast<const GoASTBlockStmt>(this));
	case eBranchStmt:
	return v->VisitBranchStmt(llvm::cast<const GoASTBranchStmt>(this));
	case eCaseClause:
	return v->VisitCaseClause(llvm::cast<const GoASTCaseClause>(this));
	case eCommClause:
	return v->VisitCommClause(llvm::cast<const GoASTCommClause>(this));
	case eDeclStmt:
	return v->VisitDeclStmt(llvm::cast<const GoASTDeclStmt>(this));
	case eDeferStmt:
	return v->VisitDeferStmt(llvm::cast<const GoASTDeferStmt>(this));
	case eEmptyStmt:
	return v->VisitEmptyStmt(llvm::cast<const GoASTEmptyStmt>(this));
	case eExprStmt:
	return v->VisitExprStmt(llvm::cast<const GoASTExprStmt>(this));
	case eForStmt:
	return v->VisitForStmt(llvm::cast<const GoASTForStmt>(this));
	case eGoStmt:
	return v->VisitGoStmt(llvm::cast<const GoASTGoStmt>(this));
	case eIfStmt:
	return v->VisitIfStmt(llvm::cast<const GoASTIfStmt>(this));
	case eIncDecStmt:
	return v->VisitIncDecStmt(llvm::cast<const GoASTIncDecStmt>(this));
	case eLabeledStmt:
	return v->VisitLabeledStmt(llvm::cast<const GoASTLabeledStmt>(this));
	case eRangeStmt:
	return v->VisitRangeStmt(llvm::cast<const GoASTRangeStmt>(this));
	case eReturnStmt:
	return v->VisitReturnStmt(llvm::cast<const GoASTReturnStmt>(this));
	case eSelectStmt:
	return v->VisitSelectStmt(llvm::cast<const GoASTSelectStmt>(this));
	case eSendStmt:
	return v->VisitSendStmt(llvm::cast<const GoASTSendStmt>(this));
	case eSwitchStmt:
	return v->VisitSwitchStmt(llvm::cast<const GoASTSwitchStmt>(this));
	case eTypeSwitchStmt:
	return v->VisitTypeSwitchStmt(llvm::cast<const GoASTTypeSwitchStmt>(this));
	default:
	assert(false && "Invalid kind");
	}
	}

	template <typename V> void GoASTNode::WalkChildren(V &v) {
	switch (m_kind) {

	case eArrayType: {
	GoASTArrayType *n = llvm::cast<GoASTArrayType>(this);
	(void)n;
	v(n->m_len_up.get());
	v(n->m_elt_up.get());
	return;
	}
	case eAssignStmt: {
	GoASTAssignStmt *n = llvm::cast<GoASTAssignStmt>(this);
	(void)n;
	for (auto &e : n->m_lhs) {
	v(e.get());
	}
	for (auto &e : n->m_rhs) {
	v(e.get());
	}
	return;
	}
	case eBasicLit: {
	GoASTBasicLit *n = llvm::cast<GoASTBasicLit>(this);
	(void)n;
	return;
	}
	case eBinaryExpr: {
	GoASTBinaryExpr *n = llvm::cast<GoASTBinaryExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	v(n->m_y_up.get());
	return;
	}
	case eBlockStmt: {
	GoASTBlockStmt *n = llvm::cast<GoASTBlockStmt>(this);
	(void)n;
	for (auto &e : n->m_list) {
	v(e.get());
	}
	return;
	}
	case eIdent: {
	GoASTIdent *n = llvm::cast<GoASTIdent>(this);
	(void)n;
	return;
	}
	case eBranchStmt: {
	GoASTBranchStmt *n = llvm::cast<GoASTBranchStmt>(this);
	(void)n;
	v(n->m_label_up.get());
	return;
	}
	case eCallExpr: {
	GoASTCallExpr *n = llvm::cast<GoASTCallExpr>(this);
	(void)n;
	v(n->m_fun_up.get());
	for (auto &e : n->m_args) {
	v(e.get());
	}
	return;
	}
	case eCaseClause: {
	GoASTCaseClause *n = llvm::cast<GoASTCaseClause>(this);
	(void)n;
	for (auto &e : n->m_list) {
	v(e.get());
	}
	for (auto &e : n->m_body) {
	v(e.get());
	}
	return;
	}
	case eChanType: {
	GoASTChanType *n = llvm::cast<GoASTChanType>(this);
	(void)n;
	v(n->m_value_up.get());
	return;
	}
	case eCommClause: {
	GoASTCommClause *n = llvm::cast<GoASTCommClause>(this);
	(void)n;
	v(n->m_comm_up.get());
	for (auto &e : n->m_body) {
	v(e.get());
	}
	return;
	}
	case eCompositeLit: {
	GoASTCompositeLit *n = llvm::cast<GoASTCompositeLit>(this);
	(void)n;
	v(n->m_type_up.get());
	for (auto &e : n->m_elts) {
	v(e.get());
	}
	return;
	}
	case eDeclStmt: {
	GoASTDeclStmt *n = llvm::cast<GoASTDeclStmt>(this);
	(void)n;
	v(n->m_decl_up.get());
	return;
	}
	case eDeferStmt: {
	GoASTDeferStmt *n = llvm::cast<GoASTDeferStmt>(this);
	(void)n;
	v(n->m_call_up.get());
	return;
	}
	case eEllipsis: {
	GoASTEllipsis *n = llvm::cast<GoASTEllipsis>(this);
	(void)n;
	v(n->m_elt_up.get());
	return;
	}
	case eExprStmt: {
	GoASTExprStmt *n = llvm::cast<GoASTExprStmt>(this);
	(void)n;
	v(n->m_x_up.get());
	return;
	}
	case eField: {
	GoASTField *n = llvm::cast<GoASTField>(this);
	(void)n;
	for (auto &e : n->m_names) {
	v(e.get());
	}
	v(n->m_type_up.get());
	v(n->m_tag_up.get());
	return;
	}
	case eFieldList: {
	GoASTFieldList *n = llvm::cast<GoASTFieldList>(this);
	(void)n;
	for (auto &e : n->m_list) {
	v(e.get());
	}
	return;
	}
	case eForStmt: {
	GoASTForStmt *n = llvm::cast<GoASTForStmt>(this);
	(void)n;
	v(n->m_init_up.get());
	v(n->m_cond_up.get());
	v(n->m_post_up.get());
	v(n->m_body_up.get());
	return;
	}
	case eFuncType: {
	GoASTFuncType *n = llvm::cast<GoASTFuncType>(this);
	(void)n;
	v(n->m_params_up.get());
	v(n->m_results_up.get());
	return;
	}
	case eFuncDecl: {
	GoASTFuncDecl *n = llvm::cast<GoASTFuncDecl>(this);
	(void)n;
	v(n->m_recv_up.get());
	v(n->m_name_up.get());
	v(n->m_type_up.get());
	v(n->m_body_up.get());
	return;
	}
	case eFuncLit: {
	GoASTFuncLit *n = llvm::cast<GoASTFuncLit>(this);
	(void)n;
	v(n->m_type_up.get());
	v(n->m_body_up.get());
	return;
	}
	case eGenDecl: {
	GoASTGenDecl *n = llvm::cast<GoASTGenDecl>(this);
	(void)n;
	for (auto &e : n->m_specs) {
	v(e.get());
	}
	return;
	}
	case eGoStmt: {
	GoASTGoStmt *n = llvm::cast<GoASTGoStmt>(this);
	(void)n;
	v(n->m_call_up.get());
	return;
	}
	case eIfStmt: {
	GoASTIfStmt *n = llvm::cast<GoASTIfStmt>(this);
	(void)n;
	v(n->m_init_up.get());
	v(n->m_cond_up.get());
	v(n->m_body_up.get());
	v(n->m_els_up.get());
	return;
	}
	case eImportSpec: {
	GoASTImportSpec *n = llvm::cast<GoASTImportSpec>(this);
	(void)n;
	v(n->m_name_up.get());
	v(n->m_path_up.get());
	return;
	}
	case eIncDecStmt: {
	GoASTIncDecStmt *n = llvm::cast<GoASTIncDecStmt>(this);
	(void)n;
	v(n->m_x_up.get());
	return;
	}
	case eIndexExpr: {
	GoASTIndexExpr *n = llvm::cast<GoASTIndexExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	v(n->m_index_up.get());
	return;
	}
	case eInterfaceType: {
	GoASTInterfaceType *n = llvm::cast<GoASTInterfaceType>(this);
	(void)n;
	v(n->m_methods_up.get());
	return;
	}
	case eKeyValueExpr: {
	GoASTKeyValueExpr *n = llvm::cast<GoASTKeyValueExpr>(this);
	(void)n;
	v(n->m_key_up.get());
	v(n->m_value_up.get());
	return;
	}
	case eLabeledStmt: {
	GoASTLabeledStmt *n = llvm::cast<GoASTLabeledStmt>(this);
	(void)n;
	v(n->m_label_up.get());
	v(n->m_stmt_up.get());
	return;
	}
	case eMapType: {
	GoASTMapType *n = llvm::cast<GoASTMapType>(this);
	(void)n;
	v(n->m_key_up.get());
	v(n->m_value_up.get());
	return;
	}
	case eParenExpr: {
	GoASTParenExpr *n = llvm::cast<GoASTParenExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	return;
	}
	case eRangeStmt: {
	GoASTRangeStmt *n = llvm::cast<GoASTRangeStmt>(this);
	(void)n;
	v(n->m_key_up.get());
	v(n->m_value_up.get());
	v(n->m_x_up.get());
	v(n->m_body_up.get());
	return;
	}
	case eReturnStmt: {
	GoASTReturnStmt *n = llvm::cast<GoASTReturnStmt>(this);
	(void)n;
	for (auto &e : n->m_results) {
	v(e.get());
	}
	return;
	}
	case eSelectStmt: {
	GoASTSelectStmt *n = llvm::cast<GoASTSelectStmt>(this);
	(void)n;
	v(n->m_body_up.get());
	return;
	}
	case eSelectorExpr: {
	GoASTSelectorExpr *n = llvm::cast<GoASTSelectorExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	v(n->m_sel_up.get());
	return;
	}
	case eSendStmt: {
	GoASTSendStmt *n = llvm::cast<GoASTSendStmt>(this);
	(void)n;
	v(n->m_chan_up.get());
	v(n->m_value_up.get());
	return;
	}
	case eSliceExpr: {
	GoASTSliceExpr *n = llvm::cast<GoASTSliceExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	v(n->m_low_up.get());
	v(n->m_high_up.get());
	v(n->m_max_up.get());
	return;
	}
	case eStarExpr: {
	GoASTStarExpr *n = llvm::cast<GoASTStarExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	return;
	}
	case eStructType: {
	GoASTStructType *n = llvm::cast<GoASTStructType>(this);
	(void)n;
	v(n->m_fields_up.get());
	return;
	}
	case eSwitchStmt: {
	GoASTSwitchStmt *n = llvm::cast<GoASTSwitchStmt>(this);
	(void)n;
	v(n->m_init_up.get());
	v(n->m_tag_up.get());
	v(n->m_body_up.get());
	return;
	}
	case eTypeAssertExpr: {
	GoASTTypeAssertExpr *n = llvm::cast<GoASTTypeAssertExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	v(n->m_type_up.get());
	return;
	}
	case eTypeSpec: {
	GoASTTypeSpec *n = llvm::cast<GoASTTypeSpec>(this);
	(void)n;
	v(n->m_name_up.get());
	v(n->m_type_up.get());
	return;
	}
	case eTypeSwitchStmt: {
	GoASTTypeSwitchStmt *n = llvm::cast<GoASTTypeSwitchStmt>(this);
	(void)n;
	v(n->m_init_up.get());
	v(n->m_assign_up.get());
	v(n->m_body_up.get());
	return;
	}
	case eUnaryExpr: {
	GoASTUnaryExpr *n = llvm::cast<GoASTUnaryExpr>(this);
	(void)n;
	v(n->m_x_up.get());
	return;
	}
	case eValueSpec: {
	GoASTValueSpec *n = llvm::cast<GoASTValueSpec>(this);
	(void)n;
	for (auto &e : n->m_names) {
	v(e.get());
	}
	v(n->m_type_up.get());
	for (auto &e : n->m_values) {
	v(e.get());
	}
	return;
	}

	case eEmptyStmt:
	case eBadDecl:
	case eBadExpr:
	case eBadStmt:
	break;
	}
	}

	} // namespace lldb_private

	#endif

source/Plugins/ExpressionParser/Go/GoLexer.h

This file was deleted.

	//===-- GoLexer.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_GoLexer_h
	#define liblldb_GoLexer_h

	#include "llvm/ADT/StringMap.h"
	#include "llvm/ADT/StringRef.h"

	namespace lldb_private {

	class GoLexer {
	public:
	explicit GoLexer(const char *src);

	enum TokenType {
	TOK_EOF,
	TOK_INVALID,
	TOK_IDENTIFIER,
	LIT_INTEGER,
	LIT_FLOAT,
	LIT_IMAGINARY,
	LIT_RUNE,
	LIT_STRING,
	KEYWORD_BREAK,
	KEYWORD_DEFAULT,
	KEYWORD_FUNC,
	KEYWORD_INTERFACE,
	KEYWORD_SELECT,
	KEYWORD_CASE,
	KEYWORD_DEFER,
	KEYWORD_GO,
	KEYWORD_MAP,
	KEYWORD_STRUCT,
	KEYWORD_CHAN,
	KEYWORD_ELSE,
	KEYWORD_GOTO,
	KEYWORD_PACKAGE,
	KEYWORD_SWITCH,
	KEYWORD_CONST,
	KEYWORD_FALLTHROUGH,
	KEYWORD_IF,
	KEYWORD_RANGE,
	KEYWORD_TYPE,
	KEYWORD_CONTINUE,
	KEYWORD_FOR,
	KEYWORD_IMPORT,
	KEYWORD_RETURN,
	KEYWORD_VAR,
	OP_PLUS,
	OP_MINUS,
	OP_STAR,
	OP_SLASH,
	OP_PERCENT,
	OP_AMP,
	OP_PIPE,
	OP_CARET,
	OP_LSHIFT,
	OP_RSHIFT,
	OP_AMP_CARET,
	OP_PLUS_EQ,
	OP_MINUS_EQ,
	OP_STAR_EQ,
	OP_SLASH_EQ,
	OP_PERCENT_EQ,
	OP_AMP_EQ,
	OP_PIPE_EQ,
	OP_CARET_EQ,
	OP_LSHIFT_EQ,
	OP_RSHIFT_EQ,
	OP_AMP_CARET_EQ,
	OP_AMP_AMP,
	OP_PIPE_PIPE,
	OP_LT_MINUS,
	OP_PLUS_PLUS,
	OP_MINUS_MINUS,
	OP_EQ_EQ,
	OP_LT,
	OP_GT,
	OP_EQ,
	OP_BANG,
	OP_BANG_EQ,
	OP_LT_EQ,
	OP_GT_EQ,
	OP_COLON_EQ,
	OP_DOTS,
	OP_LPAREN,
	OP_LBRACK,
	OP_LBRACE,
	OP_COMMA,
	OP_DOT,
	OP_RPAREN,
	OP_RBRACK,
	OP_RBRACE,
	OP_SEMICOLON,
	OP_COLON,
	};

	struct Token {
	explicit Token(TokenType t, llvm::StringRef text)
	: m_type(t), m_value(text) {}
	TokenType m_type;
	llvm::StringRef m_value;
	};

	const Token &Lex();

	size_t BytesRemaining() const { return m_end - m_src; }
	llvm::StringRef GetString(int len) const {
	return llvm::StringRef(m_src, len);
	}

	static TokenType LookupKeyword(llvm::StringRef id);
	static llvm::StringRef LookupToken(TokenType t);

	private:
	bool IsDecimal(char c) { return c >= '0' && c <= '9'; }
	bool IsHexChar(char c) {
	if (c >= '0' && c <= '9')
	return true;
	if (c >= 'A' && c <= 'F')
	return true;
	if (c >= 'a' && c <= 'f')
	return true;
	return false;
	}
	bool IsLetterOrDigit(char c) {
	if (c >= 'a' && c <= 'z')
	return true;
	if (c >= 'A' && c <= 'Z')
	return true;
	if (c == '_')
	return true;
	if (c >= '0' && c <= '9')
	return true;
	// Treat all non-ascii chars as letters for simplicity.
	return 0 != (c & 0x80);
	}
	bool IsWhitespace(char c) {
	switch (c) {
	case ' ':
	case '\t':
	case '\r':
	return true;
	}
	return false;
	}

	bool SkipWhitespace();
	bool SkipComment();

	TokenType InternalLex(bool newline);

	TokenType DoOperator();

	TokenType DoIdent();

	TokenType DoNumber();

	TokenType DoRune();

	TokenType DoString();

	static llvm::StringMap<TokenType> *InitKeywords();

	static llvm::StringMap<TokenType> *m_keywords;

	const char *m_src;
	const char *m_end;
	Token m_last_token;
	};

	} // namespace lldb_private

	#endif

source/Plugins/ExpressionParser/Go/GoLexer.cpp

This file was deleted.

	//===-- GoLexer.cpp ---------------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include <string.h>

	#include "GoLexer.h"

	using namespace lldb_private;

	llvm::StringMap<GoLexer::TokenType> *GoLexer::m_keywords;

	GoLexer::GoLexer(const char *src)
	: m_src(src), m_end(src + strlen(src)), m_last_token(TOK_INVALID, "") {}

	bool GoLexer::SkipWhitespace() {
	bool saw_newline = false;
	for (; m_src < m_end; ++m_src) {
	if (*m_src == '\n')
	saw_newline = true;
	if (*m_src == '/' && !SkipComment())
	return saw_newline;
	else if (!IsWhitespace(*m_src))
	return saw_newline;
	}
	return saw_newline;
	}

	bool GoLexer::SkipComment() {
	if (m_src[0] == '/' && m_src[1] == '/') {
	for (const char *c = m_src + 2; c < m_end; ++c) {
	if (*c == '\n') {
	m_src = c - 1;
	return true;
	}
	}
	return true;
	} else if (m_src[0] == '/' && m_src[1] == '*') {
	for (const char *c = m_src + 2; c < m_end; ++c) {
	if (c[0] == '*' && c[1] == '/') {
	m_src = c + 1;
	return true;
	}
	}
	}
	return false;
	}

	const GoLexer::Token &GoLexer::Lex() {
	bool newline = SkipWhitespace();
	const char *start = m_src;
	m_last_token.m_type = InternalLex(newline);
	m_last_token.m_value = llvm::StringRef(start, m_src - start);
	return m_last_token;
	}

	GoLexer::TokenType GoLexer::InternalLex(bool newline) {
	if (m_src >= m_end) {
	return TOK_EOF;
	}
	if (newline) {
	switch (m_last_token.m_type) {
	case TOK_IDENTIFIER:
	case LIT_FLOAT:
	case LIT_IMAGINARY:
	case LIT_INTEGER:
	case LIT_RUNE:
	case LIT_STRING:
	case KEYWORD_BREAK:
	case KEYWORD_CONTINUE:
	case KEYWORD_FALLTHROUGH:
	case KEYWORD_RETURN:
	case OP_PLUS_PLUS:
	case OP_MINUS_MINUS:
	case OP_RPAREN:
	case OP_RBRACK:
	case OP_RBRACE:
	return OP_SEMICOLON;
	default:
	break;
	}
	}
	char c = *m_src;
	switch (c) {
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	return DoNumber();
	case '+':
	case '-':
	case '*':
	case '/':
	case '%':
	case '&':
	case '\|':
	case '^':
	case '<':
	case '>':
	case '!':
	case ':':
	case ';':
	case '(':
	case ')':
	case '[':
	case ']':
	case '{':
	case '}':
	case ',':
	case '=':
	return DoOperator();
	case '.':
	if (IsDecimal(m_src[1]))
	return DoNumber();
	return DoOperator();
	case '$':
	// For lldb persistent vars.
	return DoIdent();
	case '"':
	case '`':
	return DoString();
	case '\'':
	return DoRune();
	default:
	break;
	}
	if (IsLetterOrDigit(c))
	return DoIdent();
	++m_src;
	return TOK_INVALID;
	}

	GoLexer::TokenType GoLexer::DoOperator() {
	TokenType t = TOK_INVALID;
	if (m_end - m_src > 2) {
	t = LookupKeyword(llvm::StringRef(m_src, 3));
	if (t != TOK_INVALID)
	m_src += 3;
	}
	if (t == TOK_INVALID && m_end - m_src > 1) {
	t = LookupKeyword(llvm::StringRef(m_src, 2));
	if (t != TOK_INVALID)
	m_src += 2;
	}
	if (t == TOK_INVALID) {
	t = LookupKeyword(llvm::StringRef(m_src, 1));
	++m_src;
	}
	return t;
	}

	GoLexer::TokenType GoLexer::DoIdent() {
	const char *start = m_src++;
	while (m_src < m_end && IsLetterOrDigit(*m_src)) {
	++m_src;
	}
	TokenType kw = LookupKeyword(llvm::StringRef(start, m_src - start));
	if (kw != TOK_INVALID)
	return kw;
	return TOK_IDENTIFIER;
	}

	GoLexer::TokenType GoLexer::DoNumber() {
	if (m_src[0] == '0' && (m_src[1] == 'x' \|\| m_src[1] == 'X')) {
	m_src += 2;
	while (IsHexChar(*m_src))
	++m_src;
	return LIT_INTEGER;
	}
	bool dot_ok = true;
	bool e_ok = true;
	while (true) {
	while (IsDecimal(*m_src))
	++m_src;
	switch (*m_src) {
	case 'i':
	++m_src;
	return LIT_IMAGINARY;
	case '.':
	if (!dot_ok)
	return LIT_FLOAT;
	++m_src;
	dot_ok = false;
	break;
	case 'e':
	case 'E':
	if (!e_ok)
	return LIT_FLOAT;
	dot_ok = e_ok = false;
	++m_src;
	if (m_src == '+' \|\| m_src == '-')
	++m_src;
	break;
	default:
	if (dot_ok)
	return LIT_INTEGER;
	return LIT_FLOAT;
	}
	}
	}

	GoLexer::TokenType GoLexer::DoRune() {
	while (++m_src < m_end) {
	switch (*m_src) {
	case '\'':
	++m_src;
	return LIT_RUNE;
	case '\n':
	return TOK_INVALID;
	case '\\':
	if (m_src[1] == '\n')
	return TOK_INVALID;
	++m_src;
	}
	}
	return TOK_INVALID;
	}

	GoLexer::TokenType GoLexer::DoString() {
	if (*m_src == '`') {
	while (++m_src < m_end) {
	if (*m_src == '`') {
	++m_src;
	return LIT_STRING;
	}
	}
	return TOK_INVALID;
	}
	while (++m_src < m_end) {
	switch (*m_src) {
	case '"':
	++m_src;
	return LIT_STRING;
	case '\n':
	return TOK_INVALID;
	case '\\':
	if (m_src[1] == '\n')
	return TOK_INVALID;
	++m_src;
	}
	}
	return TOK_INVALID;
	}

	GoLexer::TokenType GoLexer::LookupKeyword(llvm::StringRef id) {
	if (m_keywords == nullptr)
	m_keywords = InitKeywords();
	const auto &it = m_keywords->find(id);
	if (it == m_keywords->end())
	return TOK_INVALID;
	return it->second;
	}

	llvm::StringRef GoLexer::LookupToken(TokenType t) {
	if (m_keywords == nullptr)
	m_keywords = InitKeywords();
	for (const auto &e : *m_keywords) {
	if (e.getValue() == t)
	return e.getKey();
	}
	return "";
	}

	llvm::StringMap<GoLexer::TokenType> *GoLexer::InitKeywords() {
	auto &result = *new llvm::StringMap<TokenType>(128);
	result["break"] = KEYWORD_BREAK;
	result["default"] = KEYWORD_DEFAULT;
	result["func"] = KEYWORD_FUNC;
	result["interface"] = KEYWORD_INTERFACE;
	result["select"] = KEYWORD_SELECT;
	result["case"] = KEYWORD_CASE;
	result["defer"] = KEYWORD_DEFER;
	result["go"] = KEYWORD_GO;
	result["map"] = KEYWORD_MAP;
	result["struct"] = KEYWORD_STRUCT;
	result["chan"] = KEYWORD_CHAN;
	result["else"] = KEYWORD_ELSE;
	result["goto"] = KEYWORD_GOTO;
	result["package"] = KEYWORD_PACKAGE;
	result["switch"] = KEYWORD_SWITCH;
	result["const"] = KEYWORD_CONST;
	result["fallthrough"] = KEYWORD_FALLTHROUGH;
	result["if"] = KEYWORD_IF;
	result["range"] = KEYWORD_RANGE;
	result["type"] = KEYWORD_TYPE;
	result["continue"] = KEYWORD_CONTINUE;
	result["for"] = KEYWORD_FOR;
	result["import"] = KEYWORD_IMPORT;
	result["return"] = KEYWORD_RETURN;
	result["var"] = KEYWORD_VAR;
	result["+"] = OP_PLUS;
	result["-"] = OP_MINUS;
	result["*"] = OP_STAR;
	result["/"] = OP_SLASH;
	result["%"] = OP_PERCENT;
	result["&"] = OP_AMP;
	result["\|"] = OP_PIPE;
	result["^"] = OP_CARET;
	result["<<"] = OP_LSHIFT;
	result[">>"] = OP_RSHIFT;
	result["&^"] = OP_AMP_CARET;
	result["+="] = OP_PLUS_EQ;
	result["-="] = OP_MINUS_EQ;
	result["*="] = OP_STAR_EQ;
	result["/="] = OP_SLASH_EQ;
	result["%="] = OP_PERCENT_EQ;
	result["&="] = OP_AMP_EQ;
	result["\|="] = OP_PIPE_EQ;
	result["^="] = OP_CARET_EQ;
	result["<<="] = OP_LSHIFT_EQ;
	result[">>="] = OP_RSHIFT_EQ;
	result["&^="] = OP_AMP_CARET_EQ;
	result["&&"] = OP_AMP_AMP;
	result["\|\|"] = OP_PIPE_PIPE;
	result["<-"] = OP_LT_MINUS;
	result["++"] = OP_PLUS_PLUS;
	result["--"] = OP_MINUS_MINUS;
	result["=="] = OP_EQ_EQ;
	result["<"] = OP_LT;
	result[">"] = OP_GT;
	result["="] = OP_EQ;
	result["!"] = OP_BANG;
	result["!="] = OP_BANG_EQ;
	result["<="] = OP_LT_EQ;
	result[">="] = OP_GT_EQ;
	result[":="] = OP_COLON_EQ;
	result["..."] = OP_DOTS;
	result["("] = OP_LPAREN;
	result["["] = OP_LBRACK;
	result["{"] = OP_LBRACE;
	result[","] = OP_COMMA;
	result["."] = OP_DOT;
	result[")"] = OP_RPAREN;
	result["]"] = OP_RBRACK;
	result["}"] = OP_RBRACE;
	result[";"] = OP_SEMICOLON;
	result[":"] = OP_COLON;
	return &result;
	}

source/Plugins/ExpressionParser/Go/GoParser.h

This file was deleted.

	//===-- GoParser.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_GoParser_h
	#define liblldb_GoParser_h

	#include "Plugins/ExpressionParser/Go/GoAST.h"
	#include "Plugins/ExpressionParser/Go/GoLexer.h"
	#include "lldb/lldb-private.h"

	namespace lldb_private {
	class GoParser {
	public:
	explicit GoParser(const char *src);

	GoASTStmt *Statement();

	GoASTStmt *GoStmt();
	GoASTStmt *ReturnStmt();
	GoASTStmt *BranchStmt();
	GoASTStmt *EmptyStmt();
	GoASTStmt ExpressionStmt(GoASTExpr e);
	GoASTStmt IncDecStmt(GoASTExpr e);
	GoASTStmt Assignment(GoASTExpr e);
	GoASTBlockStmt *Block();

	GoASTExpr *MoreExpressionList(); // ["," Expression]
	GoASTIdent *MoreIdentifierList(); // ["," Identifier]

	GoASTExpr *Expression();
	GoASTExpr *UnaryExpr();
	GoASTExpr *OrExpr();
	GoASTExpr *AndExpr();
	GoASTExpr *RelExpr();
	GoASTExpr *AddExpr();
	GoASTExpr *MulExpr();
	GoASTExpr *PrimaryExpr();
	GoASTExpr *Operand();
	GoASTExpr *Conversion();

	GoASTExpr Selector(GoASTExpr e);
	GoASTExpr IndexOrSlice(GoASTExpr e);
	GoASTExpr TypeAssertion(GoASTExpr e);
	GoASTExpr Arguments(GoASTExpr e);

	GoASTExpr *Type();
	GoASTExpr *Type2();
	GoASTExpr *ArrayOrSliceType(bool allowEllipsis);
	GoASTExpr *StructType();
	GoASTExpr *FunctionType();
	GoASTExpr *InterfaceType();
	GoASTExpr *MapType();
	GoASTExpr *ChanType();
	GoASTExpr *ChanType2();

	GoASTExpr *Name();
	GoASTExpr QualifiedIdent(GoASTIdent p);
	GoASTIdent *Identifier();

	GoASTField *FieldDecl();
	GoASTExpr *AnonymousFieldType();
	GoASTExpr FieldNamesAndType(GoASTField f);

	GoASTFieldList *Params();
	GoASTField *ParamDecl();
	GoASTExpr *ParamType();
	GoASTFuncType *Signature();
	GoASTExpr *CompositeLit();
	GoASTExpr *FunctionLit();
	GoASTExpr *Element();
	GoASTCompositeLit *LiteralValue();

	bool Failed() const { return m_failed; }
	bool AtEOF() const {
	return m_lexer.BytesRemaining() == 0 && m_pos == m_tokens.size();
	}

	void GetError(Status &error);

	private:
	class Rule;
	friend class Rule;

	std::nullptr_t syntaxerror() {
	m_failed = true;
	return nullptr;
	}
	GoLexer::Token &next() {
	if (m_pos >= m_tokens.size()) {
	if (m_pos != 0 && (m_tokens.back().m_type == GoLexer::TOK_EOF \|\|
	m_tokens.back().m_type == GoLexer::TOK_INVALID))
	return m_tokens.back();
	m_pos = m_tokens.size();
	m_tokens.push_back(m_lexer.Lex());
	}
	return m_tokens[m_pos++];
	}
	GoLexer::TokenType peek() {
	GoLexer::Token &tok = next();
	--m_pos;
	return tok.m_type;
	}
	GoLexer::Token *match(GoLexer::TokenType t) {
	GoLexer::Token &tok = next();
	if (tok.m_type == t)
	return &tok;
	--m_pos;
	m_last_tok = t;
	return nullptr;
	}
	GoLexer::Token *mustMatch(GoLexer::TokenType t) {
	GoLexer::Token *tok = match(t);
	if (tok)
	return tok;
	return syntaxerror();
	}
	bool Semicolon();

	GoASTStmt FinishStmt(GoASTStmt s) {
	if (!Semicolon())
	m_failed = true;
	return s;
	}

	llvm::StringRef CopyString(llvm::StringRef s);

	GoLexer m_lexer;
	std::vector<GoLexer::Token> m_tokens;
	size_t m_pos;
	llvm::StringRef m_error;
	llvm::StringRef m_last;
	GoLexer::TokenType m_last_tok;
	llvm::StringMap<uint8_t> m_strings;
	bool m_failed;
	};
	}

	#endif

source/Plugins/ExpressionParser/Go/GoParser.cpp

This file was deleted.

	//===-- GoParser.cpp ---------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include <vector>

	#include "GoParser.h"

	#include "Plugins/ExpressionParser/Go/GoAST.h"
	#include "lldb/Utility/Status.h"
	#include "llvm/ADT/SmallString.h"

	using namespace lldb_private;
	using namespace lldb;

	namespace {
	llvm::StringRef DescribeToken(GoLexer::TokenType t) {
	switch (t) {
	case GoLexer::TOK_EOF:
	return "<eof>";
	case GoLexer::TOK_IDENTIFIER:
	return "identifier";
	case GoLexer::LIT_FLOAT:
	return "float";
	case GoLexer::LIT_IMAGINARY:
	return "imaginary";
	case GoLexer::LIT_INTEGER:
	return "integer";
	case GoLexer::LIT_RUNE:
	return "rune";
	case GoLexer::LIT_STRING:
	return "string";
	default:
	return GoLexer::LookupToken(t);
	}
	}
	} // namespace

	class GoParser::Rule {
	public:
	Rule(llvm::StringRef name, GoParser *p)
	: m_name(name), m_parser(p), m_pos(p->m_pos) {}

	std::nullptr_t error() {
	if (!m_parser->m_failed) {
	// Set m_error in case this is the top level.
	if (m_parser->m_last_tok == GoLexer::TOK_INVALID)
	m_parser->m_error = m_parser->m_last;
	else
	m_parser->m_error = DescribeToken(m_parser->m_last_tok);
	// And set m_last in case it isn't.
	m_parser->m_last = m_name;
	m_parser->m_last_tok = GoLexer::TOK_INVALID;
	m_parser->m_pos = m_pos;
	}
	return nullptr;
	}

	private:
	llvm::StringRef m_name;
	GoParser *m_parser;
	size_t m_pos;
	};

	GoParser::GoParser(const char *src)
	: m_lexer(src), m_pos(0), m_last_tok(GoLexer::TOK_INVALID),
	m_failed(false) {}

	GoASTStmt *GoParser::Statement() {
	Rule r("Statement", this);
	GoLexer::TokenType t = peek();
	GoASTStmt *ret = nullptr;
	switch (t) {
	case GoLexer::TOK_EOF:
	case GoLexer::OP_SEMICOLON:
	case GoLexer::OP_RPAREN:
	case GoLexer::OP_RBRACE:
	case GoLexer::TOK_INVALID:
	return EmptyStmt();
	case GoLexer::OP_LBRACE:
	return Block();

	/* TODO:
	case GoLexer::KEYWORD_GO:
	return GoStmt();
	case GoLexer::KEYWORD_RETURN:
	return ReturnStmt();
	case GoLexer::KEYWORD_BREAK:
	case GoLexer::KEYWORD_CONTINUE:
	case GoLexer::KEYWORD_GOTO:
	case GoLexer::KEYWORD_FALLTHROUGH:
	return BranchStmt();
	case GoLexer::KEYWORD_IF:
	return IfStmt();
	case GoLexer::KEYWORD_SWITCH:
	return SwitchStmt();
	case GoLexer::KEYWORD_SELECT:
	return SelectStmt();
	case GoLexer::KEYWORD_FOR:
	return ForStmt();
	case GoLexer::KEYWORD_DEFER:
	return DeferStmt();
	case GoLexer::KEYWORD_CONST:
	case GoLexer::KEYWORD_TYPE:
	case GoLexer::KEYWORD_VAR:
	return DeclStmt();
	case GoLexer::TOK_IDENTIFIER:
	if ((ret = LabeledStmt()) \|\|
	(ret = ShortVarDecl()))
	{
	return ret;
	}
	*/
	default:
	break;
	}
	GoASTExpr *expr = Expression();
	if (expr == nullptr)
	return r.error();
	if (/(ret = SendStmt(expr)) \|\|/
	(ret = IncDecStmt(expr)) \|\| (ret = Assignment(expr)) \|\|
	(ret = ExpressionStmt(expr))) {
	return ret;
	}
	delete expr;
	return r.error();
	}

	GoASTStmt GoParser::ExpressionStmt(GoASTExpr e) {
	if (Semicolon())
	return new GoASTExprStmt(e);
	return nullptr;
	}

	GoASTStmt GoParser::IncDecStmt(GoASTExpr e) {
	Rule r("IncDecStmt", this);
	if (match(GoLexer::OP_PLUS_PLUS))
	return Semicolon() ? new GoASTIncDecStmt(e, GoLexer::OP_PLUS_PLUS)
	: r.error();
	if (match(GoLexer::OP_MINUS_MINUS))
	return Semicolon() ? new GoASTIncDecStmt(e, GoLexer::OP_MINUS_MINUS)
	: r.error();
	return nullptr;
	}

	GoASTStmt GoParser::Assignment(lldb_private::GoASTExpr e) {
	Rule r("Assignment", this);
	std::vector<std::unique_ptr<GoASTExpr>> lhs;
	for (GoASTExpr *l = MoreExpressionList(); l; l = MoreExpressionList())
	lhs.push_back(std::unique_ptr<GoASTExpr>(l));
	switch (peek()) {
	case GoLexer::OP_EQ:
	case GoLexer::OP_PLUS_EQ:
	case GoLexer::OP_MINUS_EQ:
	case GoLexer::OP_PIPE_EQ:
	case GoLexer::OP_CARET_EQ:
	case GoLexer::OP_STAR_EQ:
	case GoLexer::OP_SLASH_EQ:
	case GoLexer::OP_PERCENT_EQ:
	case GoLexer::OP_LSHIFT_EQ:
	case GoLexer::OP_RSHIFT_EQ:
	case GoLexer::OP_AMP_EQ:
	case GoLexer::OP_AMP_CARET_EQ:
	break;
	default:
	return r.error();
	}
	// We don't want to own e until we know this is an assignment.
	std::unique_ptr<GoASTAssignStmt> stmt(new GoASTAssignStmt(false));
	stmt->AddLhs(e);
	for (auto &l : lhs)
	stmt->AddLhs(l.release());
	for (GoASTExpr *r = Expression(); r; r = MoreExpressionList())
	stmt->AddRhs(r);
	if (!Semicolon() \|\| stmt->NumRhs() == 0)
	return new GoASTBadStmt;
	return stmt.release();
	}

	GoASTStmt *GoParser::EmptyStmt() {
	if (match(GoLexer::TOK_EOF))
	return nullptr;
	if (Semicolon())
	return new GoASTEmptyStmt;
	return nullptr;
	}

	GoASTStmt *GoParser::GoStmt() {
	if (match(GoLexer::KEYWORD_GO)) {
	if (GoASTCallExpr *e =
	llvm::dyn_cast_or_null<GoASTCallExpr>(Expression())) {
	return FinishStmt(new GoASTGoStmt(e));
	}
	m_last = "call expression";
	m_failed = true;
	return new GoASTBadStmt();
	}
	return nullptr;
	}

	GoASTStmt *GoParser::ReturnStmt() {
	if (match(GoLexer::KEYWORD_RETURN)) {
	std::unique_ptr<GoASTReturnStmt> r(new GoASTReturnStmt());
	for (GoASTExpr *e = Expression(); e; e = MoreExpressionList())
	r->AddResults(e);
	return FinishStmt(r.release());
	}
	return nullptr;
	}

	GoASTStmt *GoParser::BranchStmt() {
	GoLexer::Token *tok;
	if ((tok = match(GoLexer::KEYWORD_BREAK)) \|\|
	(tok = match(GoLexer::KEYWORD_CONTINUE)) \|\|
	(tok = match(GoLexer::KEYWORD_GOTO))) {
	auto *e = Identifier();
	if (tok->m_type == GoLexer::KEYWORD_GOTO && !e)
	return syntaxerror();
	return FinishStmt(new GoASTBranchStmt(e, tok->m_type));
	}
	if ((tok = match(GoLexer::KEYWORD_FALLTHROUGH)))
	return FinishStmt(new GoASTBranchStmt(nullptr, tok->m_type));

	return nullptr;
	}

	GoASTIdent *GoParser::Identifier() {
	if (auto *tok = match(GoLexer::TOK_IDENTIFIER))
	return new GoASTIdent(*tok);
	return nullptr;
	}

	GoASTExpr *GoParser::MoreExpressionList() {
	if (match(GoLexer::OP_COMMA)) {
	auto *e = Expression();
	if (!e)
	return syntaxerror();
	return e;
	}
	return nullptr;
	}

	GoASTIdent *GoParser::MoreIdentifierList() {
	if (match(GoLexer::OP_COMMA)) {
	auto *i = Identifier();
	if (!i)
	return syntaxerror();
	return i;
	}
	return nullptr;
	}

	GoASTExpr *GoParser::Expression() {
	Rule r("Expression", this);
	if (GoASTExpr *ret = OrExpr())
	return ret;
	return r.error();
	}

	GoASTExpr *GoParser::UnaryExpr() {
	switch (peek()) {
	case GoLexer::OP_PLUS:
	case GoLexer::OP_MINUS:
	case GoLexer::OP_BANG:
	case GoLexer::OP_CARET:
	case GoLexer::OP_STAR:
	case GoLexer::OP_AMP:
	case GoLexer::OP_LT_MINUS: {
	const GoLexer::Token t = next();
	if (GoASTExpr *e = UnaryExpr()) {
	if (t.m_type == GoLexer::OP_STAR)
	return new GoASTStarExpr(e);
	else
	return new GoASTUnaryExpr(t.m_type, e);
	}
	return syntaxerror();
	}
	default:
	return PrimaryExpr();
	}
	}

	GoASTExpr *GoParser::OrExpr() {
	std::unique_ptr<GoASTExpr> l(AndExpr());
	if (l) {
	while (match(GoLexer::OP_PIPE_PIPE)) {
	GoASTExpr *r = AndExpr();
	if (r)
	l.reset(new GoASTBinaryExpr(l.release(), r, GoLexer::OP_PIPE_PIPE));
	else
	return syntaxerror();
	}
	return l.release();
	}
	return nullptr;
	}

	GoASTExpr *GoParser::AndExpr() {
	std::unique_ptr<GoASTExpr> l(RelExpr());
	if (l) {
	while (match(GoLexer::OP_AMP_AMP)) {
	GoASTExpr *r = RelExpr();
	if (r)
	l.reset(new GoASTBinaryExpr(l.release(), r, GoLexer::OP_AMP_AMP));
	else
	return syntaxerror();
	}
	return l.release();
	}
	return nullptr;
	}

	GoASTExpr *GoParser::RelExpr() {
	std::unique_ptr<GoASTExpr> l(AddExpr());
	if (l) {
	for (GoLexer::Token *t;
	(t = match(GoLexer::OP_EQ_EQ)) \|\| (t = match(GoLexer::OP_BANG_EQ)) \|\|
	(t = match(GoLexer::OP_LT)) \|\| (t = match(GoLexer::OP_LT_EQ)) \|\|
	(t = match(GoLexer::OP_GT)) \|\| (t = match(GoLexer::OP_GT_EQ));) {
	GoLexer::TokenType op = t->m_type;
	GoASTExpr *r = AddExpr();
	if (r)
	l.reset(new GoASTBinaryExpr(l.release(), r, op));
	else
	return syntaxerror();
	}
	return l.release();
	}
	return nullptr;
	}

	GoASTExpr *GoParser::AddExpr() {
	std::unique_ptr<GoASTExpr> l(MulExpr());
	if (l) {
	for (GoLexer::Token *t;
	(t = match(GoLexer::OP_PLUS)) \|\| (t = match(GoLexer::OP_MINUS)) \|\|
	(t = match(GoLexer::OP_PIPE)) \|\| (t = match(GoLexer::OP_CARET));) {
	GoLexer::TokenType op = t->m_type;
	GoASTExpr *r = MulExpr();
	if (r)
	l.reset(new GoASTBinaryExpr(l.release(), r, op));
	else
	return syntaxerror();
	}
	return l.release();
	}
	return nullptr;
	}

	GoASTExpr *GoParser::MulExpr() {
	std::unique_ptr<GoASTExpr> l(UnaryExpr());
	if (l) {
	for (GoLexer::Token *t;
	(t = match(GoLexer::OP_STAR)) \|\| (t = match(GoLexer::OP_SLASH)) \|\|
	(t = match(GoLexer::OP_PERCENT)) \|\| (t = match(GoLexer::OP_LSHIFT)) \|\|
	(t = match(GoLexer::OP_RSHIFT)) \|\| (t = match(GoLexer::OP_AMP)) \|\|
	(t = match(GoLexer::OP_AMP_CARET));) {
	GoLexer::TokenType op = t->m_type;
	GoASTExpr *r = UnaryExpr();
	if (r)
	l.reset(new GoASTBinaryExpr(l.release(), r, op));
	else
	return syntaxerror();
	}
	return l.release();
	}
	return nullptr;
	}

	GoASTExpr *GoParser::PrimaryExpr() {
	GoASTExpr *l;
	GoASTExpr *r;
	(l = Conversion()) \|\| (l = Operand());
	if (!l)
	return nullptr;
	while ((r = Selector(l)) \|\| (r = IndexOrSlice(l)) \|\| (r = TypeAssertion(l)) \|\|
	(r = Arguments(l))) {
	l = r;
	}
	return l;
	}

	GoASTExpr *GoParser::Operand() {
	GoLexer::Token *lit;
	if ((lit = match(GoLexer::LIT_INTEGER)) \|\|
	(lit = match(GoLexer::LIT_FLOAT)) \|\|
	(lit = match(GoLexer::LIT_IMAGINARY)) \|\|
	(lit = match(GoLexer::LIT_RUNE)) \|\| (lit = match(GoLexer::LIT_STRING)))
	return new GoASTBasicLit(*lit);
	if (match(GoLexer::OP_LPAREN)) {
	GoASTExpr *e;
	if (!((e = Expression()) && match(GoLexer::OP_RPAREN)))
	return syntaxerror();
	return e;
	}
	// MethodExpr should be handled by Selector
	if (GoASTExpr *e = CompositeLit())
	return e;
	if (GoASTExpr *n = Name())
	return n;
	return FunctionLit();
	}

	GoASTExpr *GoParser::FunctionLit() {
	if (!match(GoLexer::KEYWORD_FUNC))
	return nullptr;
	auto *sig = Signature();
	if (!sig)
	return syntaxerror();
	auto *body = Block();
	if (!body) {
	delete sig;
	return syntaxerror();
	}
	return new GoASTFuncLit(sig, body);
	}

	GoASTBlockStmt *GoParser::Block() {
	if (!match(GoLexer::OP_LBRACE))
	return nullptr;
	std::unique_ptr<GoASTBlockStmt> block(new GoASTBlockStmt);
	for (auto *s = Statement(); s; s = Statement())
	block->AddList(s);
	if (!match(GoLexer::OP_RBRACE))
	return syntaxerror();
	return block.release();
	}

	GoASTExpr *GoParser::CompositeLit() {
	Rule r("CompositeLit", this);
	GoASTExpr *type;
	(type = StructType()) \|\| (type = ArrayOrSliceType(true)) \|\|
	(type = MapType()) \|\| (type = Name());
	if (!type)
	return r.error();
	GoASTCompositeLit *lit = LiteralValue();
	if (!lit) {
	delete type;
	return r.error();
	}
	lit->SetType(type);
	return lit;
	}

	GoASTCompositeLit *GoParser::LiteralValue() {
	if (!match(GoLexer::OP_LBRACE))
	return nullptr;
	std::unique_ptr<GoASTCompositeLit> lit(new GoASTCompositeLit);
	for (GoASTExpr *e = Element(); e; e = Element()) {
	lit->AddElts(e);
	if (!match(GoLexer::OP_COMMA))
	break;
	}
	if (!mustMatch(GoLexer::OP_RBRACE))
	return nullptr;
	return lit.release();
	}

	GoASTExpr *GoParser::Element() {
	GoASTExpr *key;
	if (!((key = Expression()) \|\| (key = LiteralValue())))
	return nullptr;
	if (!match(GoLexer::OP_COLON))
	return key;
	GoASTExpr *value;
	if ((value = Expression()) \|\| (value = LiteralValue()))
	return new GoASTKeyValueExpr(key, value);
	delete key;
	return syntaxerror();
	}

	GoASTExpr GoParser::Selector(GoASTExpr e) {
	Rule r("Selector", this);
	if (match(GoLexer::OP_DOT)) {
	if (auto *name = Identifier())
	return new GoASTSelectorExpr(e, name);
	}
	return r.error();
	}

	GoASTExpr GoParser::IndexOrSlice(GoASTExpr e) {
	Rule r("IndexOrSlice", this);
	if (match(GoLexer::OP_LBRACK)) {
	std::unique_ptr<GoASTExpr> i1(Expression()), i2, i3;
	bool slice = false;
	if (match(GoLexer::OP_COLON)) {
	slice = true;
	i2.reset(Expression());
	if (i2 && match(GoLexer::OP_COLON)) {
	i3.reset(Expression());
	if (!i3)
	return syntaxerror();
	}
	}
	if (!(slice \|\| i1))
	return syntaxerror();
	if (!mustMatch(GoLexer::OP_RBRACK))
	return nullptr;
	if (slice) {
	bool slice3 = i3.get();
	return new GoASTSliceExpr(e, i1.release(), i2.release(), i3.release(),
	slice3);
	}
	return new GoASTIndexExpr(e, i1.release());
	}
	return r.error();
	}

	GoASTExpr GoParser::TypeAssertion(GoASTExpr e) {
	Rule r("TypeAssertion", this);
	if (match(GoLexer::OP_DOT) && match(GoLexer::OP_LPAREN)) {
	if (auto *t = Type()) {
	if (!mustMatch(GoLexer::OP_RPAREN))
	return nullptr;
	return new GoASTTypeAssertExpr(e, t);
	}
	return syntaxerror();
	}
	return r.error();
	}

	GoASTExpr GoParser::Arguments(GoASTExpr e) {
	if (match(GoLexer::OP_LPAREN)) {
	std::unique_ptr<GoASTCallExpr> call(new GoASTCallExpr(false));
	GoASTExpr *arg;
	// ( ExpressionList \| Type [ "," ExpressionList ] )
	for ((arg = Expression()) \|\| (arg = Type()); arg;
	arg = MoreExpressionList()) {
	call->AddArgs(arg);
	}
	if (match(GoLexer::OP_DOTS))
	call->SetEllipsis(true);

	// Eat trailing comma
	match(GoLexer::OP_COMMA);

	if (!mustMatch(GoLexer::OP_RPAREN))
	return nullptr;
	call->SetFun(e);
	return call.release();
	}
	return nullptr;
	}

	GoASTExpr *GoParser::Conversion() {
	Rule r("Conversion", this);
	if (GoASTExpr *t = Type2()) {
	std::unique_ptr<GoASTExpr> owner(t);
	if (match(GoLexer::OP_LPAREN)) {
	GoASTExpr *v = Expression();
	if (!v)
	return syntaxerror();
	match(GoLexer::OP_COMMA);
	if (!mustMatch(GoLexer::OP_RPAREN))
	return r.error();
	GoASTCallExpr *call = new GoASTCallExpr(false);
	call->SetFun(t);
	owner.release();
	call->AddArgs(v);
	return call;
	}
	}
	return r.error();
	}

	GoASTExpr *GoParser::Type2() {
	switch (peek()) {
	case GoLexer::OP_LBRACK:
	return ArrayOrSliceType(false);
	case GoLexer::KEYWORD_STRUCT:
	return StructType();
	case GoLexer::KEYWORD_FUNC:
	return FunctionType();
	case GoLexer::KEYWORD_INTERFACE:
	return InterfaceType();
	case GoLexer::KEYWORD_MAP:
	return MapType();
	case GoLexer::KEYWORD_CHAN:
	return ChanType2();
	default:
	return nullptr;
	}
	}

	GoASTExpr *GoParser::ArrayOrSliceType(bool allowEllipsis) {
	Rule r("ArrayType", this);
	if (match(GoLexer::OP_LBRACK)) {
	std::unique_ptr<GoASTExpr> len;
	if (allowEllipsis && match(GoLexer::OP_DOTS)) {
	len.reset(new GoASTEllipsis(nullptr));
	} else {
	len.reset(Expression());
	}

	if (!match(GoLexer::OP_RBRACK))
	return r.error();
	GoASTExpr *elem = Type();
	if (!elem)
	return syntaxerror();
	return new GoASTArrayType(len.release(), elem);
	}
	return r.error();
	}

	GoASTExpr *GoParser::StructType() {
	if (!(match(GoLexer::KEYWORD_STRUCT) && mustMatch(GoLexer::OP_LBRACE)))
	return nullptr;
	std::unique_ptr<GoASTFieldList> fields(new GoASTFieldList);
	while (auto *field = FieldDecl())
	fields->AddList(field);
	if (!mustMatch(GoLexer::OP_RBRACE))
	return nullptr;
	return new GoASTStructType(fields.release());
	}

	GoASTField *GoParser::FieldDecl() {
	std::unique_ptr<GoASTField> f(new GoASTField);
	GoASTExpr *t = FieldNamesAndType(f.get());
	if (!t)
	t = AnonymousFieldType();
	if (!t)
	return nullptr;

	if (auto *tok = match(GoLexer::LIT_STRING))
	f->SetTag(new GoASTBasicLit(*tok));
	if (!Semicolon())
	return syntaxerror();
	return f.release();
	}

	GoASTExpr GoParser::FieldNamesAndType(GoASTField field) {
	Rule r("FieldNames", this);
	for (auto *id = Identifier(); id; id = MoreIdentifierList())
	field->AddNames(id);
	if (m_failed)
	return nullptr;
	GoASTExpr *t = Type();
	if (t)
	return t;
	return r.error();
	}

	GoASTExpr *GoParser::AnonymousFieldType() {
	bool pointer = match(GoLexer::OP_STAR);
	GoASTExpr *t = Type();
	if (!t)
	return nullptr;
	if (pointer)
	return new GoASTStarExpr(t);
	return t;
	}

	GoASTExpr *GoParser::FunctionType() {
	if (!match(GoLexer::KEYWORD_FUNC))
	return nullptr;
	return Signature();
	}

	GoASTFuncType *GoParser::Signature() {
	auto *params = Params();
	if (!params)
	return syntaxerror();
	auto *result = Params();
	if (!result) {
	if (auto *t = Type()) {
	result = new GoASTFieldList;
	auto *f = new GoASTField;
	f->SetType(t);
	result->AddList(f);
	}
	}
	return new GoASTFuncType(params, result);
	}

	GoASTFieldList *GoParser::Params() {
	if (!match(GoLexer::OP_LPAREN))
	return nullptr;
	std::unique_ptr<GoASTFieldList> l(new GoASTFieldList);
	while (GoASTField *p = ParamDecl()) {
	l->AddList(p);
	if (!match(GoLexer::OP_COMMA))
	break;
	}
	if (!mustMatch(GoLexer::OP_RPAREN))
	return nullptr;
	return l.release();
	}

	GoASTField *GoParser::ParamDecl() {
	std::unique_ptr<GoASTField> field(new GoASTField);
	GoASTIdent *id = Identifier();
	if (id) {
	// Try `IdentifierList [ "..." ] Type`.
	// If that fails, backtrack and try `[ "..." ] Type`.
	Rule r("NamedParam", this);
	for (; id; id = MoreIdentifierList())
	field->AddNames(id);
	GoASTExpr *t = ParamType();
	if (t) {
	field->SetType(t);
	return field.release();
	}
	field.reset(new GoASTField);
	r.error();
	}
	GoASTExpr *t = ParamType();
	if (t) {
	field->SetType(t);
	return field.release();
	}
	return nullptr;
	}

	GoASTExpr *GoParser::ParamType() {
	bool dots = match(GoLexer::OP_DOTS);
	GoASTExpr *t = Type();
	if (!dots)
	return t;
	if (!t)
	return syntaxerror();
	return new GoASTEllipsis(t);
	}

	GoASTExpr *GoParser::InterfaceType() {
	if (!match(GoLexer::KEYWORD_INTERFACE) \|\| !mustMatch(GoLexer::OP_LBRACE))
	return nullptr;
	std::unique_ptr<GoASTFieldList> methods(new GoASTFieldList);
	while (true) {
	Rule r("MethodSpec", this);
	// ( identifier Signature \| TypeName ) ;
	std::unique_ptr<GoASTIdent> id(Identifier());
	if (!id)
	break;
	GoASTExpr *type = Signature();
	if (!type) {
	r.error();
	id.reset();
	type = Name();
	}
	if (!Semicolon())
	return syntaxerror();
	auto *f = new GoASTField;
	if (id)
	f->AddNames(id.release());
	f->SetType(type);
	methods->AddList(f);
	}
	if (!mustMatch(GoLexer::OP_RBRACE))
	return nullptr;
	return new GoASTInterfaceType(methods.release());
	}

	GoASTExpr *GoParser::MapType() {
	if (!(match(GoLexer::KEYWORD_MAP) && mustMatch(GoLexer::OP_LBRACK)))
	return nullptr;
	std::unique_ptr<GoASTExpr> key(Type());
	if (!key)
	return syntaxerror();
	if (!mustMatch(GoLexer::OP_RBRACK))
	return nullptr;
	auto *elem = Type();
	if (!elem)
	return syntaxerror();
	return new GoASTMapType(key.release(), elem);
	}

	GoASTExpr *GoParser::ChanType() {
	Rule r("chan", this);
	if (match(GoLexer::OP_LT_MINUS)) {
	if (match(GoLexer::KEYWORD_CHAN)) {
	auto *elem = Type();
	if (!elem)
	return syntaxerror();
	return new GoASTChanType(GoASTNode::eChanRecv, elem);
	}
	return r.error();
	}
	return ChanType2();
	}

	GoASTExpr *GoParser::ChanType2() {
	if (!match(GoLexer::KEYWORD_CHAN))
	return nullptr;
	auto dir = GoASTNode::eChanBidir;
	if (match(GoLexer::OP_LT_MINUS))
	dir = GoASTNode::eChanSend;
	auto *elem = Type();
	if (!elem)
	return syntaxerror();
	return new GoASTChanType(dir, elem);
	}

	GoASTExpr *GoParser::Type() {
	if (GoASTExpr *t = Type2())
	return t;
	if (GoASTExpr *t = Name())
	return t;
	if (GoASTExpr *t = ChanType())
	return t;
	if (match(GoLexer::OP_STAR)) {
	GoASTExpr *t = Type();
	if (!t)
	return syntaxerror();
	return new GoASTStarExpr(t);
	}
	if (match(GoLexer::OP_LPAREN)) {
	std::unique_ptr<GoASTExpr> t(Type());
	if (!t \|\| !match(GoLexer::OP_RPAREN))
	return syntaxerror();
	return t.release();
	}
	return nullptr;
	}

	bool GoParser::Semicolon() {
	if (match(GoLexer::OP_SEMICOLON))
	return true;
	switch (peek()) {
	case GoLexer::OP_RPAREN:
	case GoLexer::OP_RBRACE:
	case GoLexer::TOK_EOF:
	return true;
	default:
	return false;
	}
	}

	GoASTExpr *GoParser::Name() {
	if (auto *id = Identifier()) {
	if (GoASTExpr *qual = QualifiedIdent(id))
	return qual;
	return id;
	}
	return nullptr;
	}

	GoASTExpr GoParser::QualifiedIdent(lldb_private::GoASTIdent p) {
	Rule r("QualifiedIdent", this);
	llvm::SmallString<32> path(p->GetName().m_value);
	GoLexer::Token *next;
	bool have_slashes = false;
	// LLDB extension: support full/package/path.name
	while (match(GoLexer::OP_SLASH) && (next = match(GoLexer::TOK_IDENTIFIER))) {
	have_slashes = true;
	path.append("/");
	path.append(next->m_value);
	}
	if (match(GoLexer::OP_DOT)) {
	auto *name = Identifier();
	if (name) {
	if (have_slashes) {
	p->SetName(GoLexer::Token(GoLexer::TOK_IDENTIFIER, CopyString(path)));
	}
	return new GoASTSelectorExpr(p, name);
	}
	}
	return r.error();
	}

	llvm::StringRef GoParser::CopyString(llvm::StringRef s) {
	return m_strings.insert(std::make_pair(s, 'x')).first->getKey();
	}

	void GoParser::GetError(Status &error) {
	llvm::StringRef want;
	if (m_failed)
	want =
	m_last_tok == GoLexer::TOK_INVALID ? DescribeToken(m_last_tok) : m_last;
	else
	want = m_error;
	size_t len = m_lexer.BytesRemaining();
	if (len > 10)
	len = 10;
	llvm::StringRef got;
	if (len == 0)
	got = "<eof>";
	else
	got = m_lexer.GetString(len);
	error.SetErrorStringWithFormat("Syntax error: expected %s before '%s'.",
	want.str().c_str(), got.str().c_str());
	}

source/Plugins/ExpressionParser/Go/GoUserExpression.h

This file was deleted.

	//===-- GoUserExpression.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_GoUserExpression_h_
	#define liblldb_GoUserExpression_h_

	// C Includes
	// C++ Includes
	#include <memory>

	// Other libraries and framework includes
	// Project includes
	#include "lldb/Expression/ExpressionVariable.h"
	#include "lldb/Expression/UserExpression.h"
	#include "lldb/Target/ExecutionContext.h"
	#include "lldb/lldb-forward.h"
	#include "lldb/lldb-private.h"

	namespace lldb_private {
	class GoParser;

	class GoPersistentExpressionState : public PersistentExpressionState {
	public:
	GoPersistentExpressionState();

	llvm::StringRef
	GetPersistentVariablePrefix(bool is_error) const override {
	return "$go";
	}
	void RemovePersistentVariable(lldb::ExpressionVariableSP variable) override;

	lldb::addr_t LookupSymbol(const ConstString &name) override {
	return LLDB_INVALID_ADDRESS;
	}

	static bool classof(const PersistentExpressionState *pv) {
	return pv->getKind() == PersistentExpressionState::eKindGo;
	}

	private:
	uint32_t m_next_persistent_variable_id; ///< The counter used by
	///GetNextResultName().
	};

	//----------------------------------------------------------------------
	/// @class GoUserExpression GoUserExpression.h
	/// "lldb/Expression/GoUserExpression.h" Encapsulates a single expression for
	/// use with Go
	///
	/// LLDB uses expressions for various purposes, notably to call functions
	/// and as a backend for the expr command. GoUserExpression encapsulates the
	/// objects needed to parse and interpret an expression.
	//----------------------------------------------------------------------
	class GoUserExpression : public UserExpression {
	public:
	GoUserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr,
	llvm::StringRef prefix, lldb::LanguageType language,
	ResultType desired_type,
	const EvaluateExpressionOptions &options);

	bool Parse(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
	lldb_private::ExecutionPolicy execution_policy,
	bool keep_result_in_memory, bool generate_debug_info) override;

	bool CanInterpret() override { return true; }
	bool FinalizeJITExecution(
	DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
	lldb::ExpressionVariableSP &result,
	lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS,
	lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS) override {
	return true;
	}

	protected:
	lldb::ExpressionResults
	DoExecute(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
	const EvaluateExpressionOptions &options,
	lldb::UserExpressionSP &shared_ptr_to_me,
	lldb::ExpressionVariableSP &result) override;

	private:
	class GoInterpreter;
	std::unique_ptr<GoInterpreter> m_interpreter;
	};

	} // namespace lldb_private

	#endif // liblldb_GoUserExpression_h_

source/Plugins/ExpressionParser/Go/GoUserExpression.cpp

This file was deleted.

	//===-- GoUserExpression.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>
	#if HAVE_SYS_TYPES_H
	#include <sys/types.h>
	#endif

	// C++ Includes
	#include <cstdlib>
	#include <memory>
	#include <string>
	#include <vector>

	// Other libraries and framework includes
	#include "llvm/ADT/StringMap.h"
	#include "llvm/ADT/StringRef.h"

	// Project includes
	#include "GoUserExpression.h"

	#include "lldb/Core/Module.h"
	#include "lldb/Core/StreamFile.h"
	#include "lldb/Core/ValueObjectConstResult.h"
	#include "lldb/Core/ValueObjectRegister.h"
	#include "lldb/Expression/DiagnosticManager.h"
	#include "lldb/Expression/ExpressionVariable.h"
	#include "lldb/Symbol/GoASTContext.h"
	#include "lldb/Symbol/SymbolFile.h"
	#include "lldb/Symbol/TypeList.h"
	#include "lldb/Symbol/VariableList.h"
	#include "lldb/Target/ExecutionContext.h"
	#include "lldb/Target/Process.h"
	#include "lldb/Target/RegisterContext.h"
	#include "lldb/Target/StackFrame.h"
	#include "lldb/Target/Target.h"
	#include "lldb/Target/ThreadPlan.h"
	#include "lldb/Target/ThreadPlanCallUserExpression.h"
	#include "lldb/Utility/ConstString.h"
	#include "lldb/Utility/DataBufferHeap.h"
	#include "lldb/Utility/DataEncoder.h"
	#include "lldb/Utility/DataExtractor.h"
	#include "lldb/Utility/Log.h"
	#include "lldb/Utility/StreamString.h"
	#include "lldb/lldb-private.h"

	#include "Plugins/ExpressionParser/Go/GoAST.h"
	#include "Plugins/ExpressionParser/Go/GoParser.h"

	using namespace lldb_private;
	using namespace lldb;

	class GoUserExpression::GoInterpreter {
	public:
	GoInterpreter(ExecutionContext &exe_ctx, const char *expr)
	: m_exe_ctx(exe_ctx), m_frame(exe_ctx.GetFrameSP()), m_parser(expr) {
	if (m_frame) {
	const SymbolContext &ctx =
	m_frame->GetSymbolContext(eSymbolContextFunction);
	ConstString fname = ctx.GetFunctionName();
	if (fname.GetLength() > 0) {
	size_t dot = fname.GetStringRef().find('.');
	if (dot != llvm::StringRef::npos)
	m_package = llvm::StringRef(fname.AsCString(), dot);
	}
	}
	}

	void set_use_dynamic(DynamicValueType use_dynamic) {
	m_use_dynamic = use_dynamic;
	}

	bool Parse();
	lldb::ValueObjectSP Evaluate(ExecutionContext &exe_ctx);
	lldb::ValueObjectSP EvaluateStatement(const GoASTStmt *s);
	lldb::ValueObjectSP EvaluateExpr(const GoASTExpr *e);

	ValueObjectSP VisitBadExpr(const GoASTBadExpr *e) {
	m_parser.GetError(m_error);
	return nullptr;
	}

	ValueObjectSP VisitParenExpr(const GoASTParenExpr *e);
	ValueObjectSP VisitIdent(const GoASTIdent *e);
	ValueObjectSP VisitStarExpr(const GoASTStarExpr *e);
	ValueObjectSP VisitSelectorExpr(const GoASTSelectorExpr *e);
	ValueObjectSP VisitBasicLit(const GoASTBasicLit *e);
	ValueObjectSP VisitIndexExpr(const GoASTIndexExpr *e);
	ValueObjectSP VisitUnaryExpr(const GoASTUnaryExpr *e);
	ValueObjectSP VisitCallExpr(const GoASTCallExpr *e);

	ValueObjectSP VisitTypeAssertExpr(const GoASTTypeAssertExpr *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitBinaryExpr(const GoASTBinaryExpr *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitArrayType(const GoASTArrayType *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitChanType(const GoASTChanType *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitCompositeLit(const GoASTCompositeLit *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitEllipsis(const GoASTEllipsis *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitFuncType(const GoASTFuncType *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitFuncLit(const GoASTFuncLit *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitInterfaceType(const GoASTInterfaceType *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitKeyValueExpr(const GoASTKeyValueExpr *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitMapType(const GoASTMapType *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitSliceExpr(const GoASTSliceExpr *e) {
	return NotImplemented(e);
	}

	ValueObjectSP VisitStructType(const GoASTStructType *e) {
	return NotImplemented(e);
	}

	CompilerType EvaluateType(const GoASTExpr *e);

	Status &error() { return m_error; }

	private:
	std::nullptr_t NotImplemented(const GoASTExpr *e) {
	m_error.SetErrorStringWithFormat("%s node not implemented",
	e->GetKindName());
	return nullptr;
	}

	ExecutionContext m_exe_ctx;
	lldb::StackFrameSP m_frame;
	GoParser m_parser;
	DynamicValueType m_use_dynamic;
	Status m_error;
	llvm::StringRef m_package;
	std::vector<std::unique_ptr<GoASTStmt>> m_statements;
	};

	VariableSP FindGlobalVariable(TargetSP target, llvm::Twine name) {
	ConstString fullname(name.str());
	VariableList variable_list;
	if (!target) {
	return nullptr;
	}
	const uint32_t match_count =
	target->GetImages().FindGlobalVariables(fullname, 1, variable_list);
	if (match_count == 1) {
	return variable_list.GetVariableAtIndex(0);
	}
	return nullptr;
	}

	CompilerType LookupType(TargetSP target, ConstString name) {
	if (!target)
	return CompilerType();
	SymbolContext sc;
	TypeList type_list;
	llvm::DenseSet<SymbolFile *> searched_symbol_files;
	uint32_t num_matches = target->GetImages().FindTypes(
	sc, name, false, 2, searched_symbol_files, type_list);
	if (num_matches > 0) {
	return type_list.GetTypeAtIndex(0)->GetFullCompilerType();
	}
	return CompilerType();
	}

	GoUserExpression::GoUserExpression(ExecutionContextScope &exe_scope,
	llvm::StringRef expr, llvm::StringRef prefix,
	lldb::LanguageType language,
	ResultType desired_type,
	const EvaluateExpressionOptions &options)
	: UserExpression(exe_scope, expr, prefix, language, desired_type, options) {
	}

	bool GoUserExpression::Parse(DiagnosticManager &diagnostic_manager,
	ExecutionContext &exe_ctx,
	lldb_private::ExecutionPolicy execution_policy,
	bool keep_result_in_memory,
	bool generate_debug_info) {
	InstallContext(exe_ctx);
	m_interpreter.reset(new GoInterpreter(exe_ctx, GetUserText()));
	if (m_interpreter->Parse())
	return true;
	const char *error_cstr = m_interpreter->error().AsCString();
	if (error_cstr && error_cstr[0])
	diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
	else
	diagnostic_manager.Printf(eDiagnosticSeverityError,
	"expression can't be interpreted or run");
	return false;
	}

	lldb::ExpressionResults
	GoUserExpression::DoExecute(DiagnosticManager &diagnostic_manager,
	ExecutionContext &exe_ctx,
	const EvaluateExpressionOptions &options,
	lldb::UserExpressionSP &shared_ptr_to_me,
	lldb::ExpressionVariableSP &result) {
	Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS \|
	LIBLLDB_LOG_STEP));

	lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
	lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;

	Process *process = exe_ctx.GetProcessPtr();
	Target *target = exe_ctx.GetTargetPtr();

	if (target == nullptr \|\| process == nullptr \|\|
	process->GetState() != lldb::eStateStopped) {
	if (execution_policy == eExecutionPolicyAlways) {
	if (log)
	log->Printf("== [GoUserExpression::Evaluate] Expression may not run, "
	"but is not constant ==");

	diagnostic_manager.PutString(eDiagnosticSeverityError,
	"expression needed to run but couldn't");

	return execution_results;
	}
	}

	m_interpreter->set_use_dynamic(options.GetUseDynamic());
	ValueObjectSP result_val_sp = m_interpreter->Evaluate(exe_ctx);
	Status err = m_interpreter->error();
	m_interpreter.reset();

	if (!result_val_sp) {
	const char *error_cstr = err.AsCString();
	if (error_cstr && error_cstr[0])
	diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
	else
	diagnostic_manager.PutString(eDiagnosticSeverityError,
	"expression can't be interpreted or run");
	return lldb::eExpressionDiscarded;
	}
	result.reset(new ExpressionVariable(ExpressionVariable::eKindGo));
	result->m_live_sp = result->m_frozen_sp = result_val_sp;
	result->m_flags \|= ExpressionVariable::EVIsProgramReference;
	PersistentExpressionState *pv =
	target->GetPersistentExpressionStateForLanguage(eLanguageTypeGo);
	if (pv != nullptr) {
	result->SetName(pv->GetNextPersistentVariableName(
	*target, pv->GetPersistentVariablePrefix()));
	pv->AddVariable(result);
	}
	return lldb::eExpressionCompleted;
	}

	bool GoUserExpression::GoInterpreter::Parse() {
	for (std::unique_ptr<GoASTStmt> stmt(m_parser.Statement()); stmt;
	stmt.reset(m_parser.Statement())) {
	if (m_parser.Failed())
	break;
	m_statements.emplace_back(std::move(stmt));
	}
	if (m_parser.Failed() \|\| !m_parser.AtEOF())
	m_parser.GetError(m_error);

	return m_error.Success();
	}

	ValueObjectSP
	GoUserExpression::GoInterpreter::Evaluate(ExecutionContext &exe_ctx) {
	m_exe_ctx = exe_ctx;
	ValueObjectSP result;
	for (const std::unique_ptr<GoASTStmt> &stmt : m_statements) {
	result = EvaluateStatement(stmt.get());
	if (m_error.Fail())
	return nullptr;
	}
	return result;
	}

	ValueObjectSP GoUserExpression::GoInterpreter::EvaluateStatement(
	const lldb_private::GoASTStmt *stmt) {
	ValueObjectSP result;
	switch (stmt->GetKind()) {
	case GoASTNode::eBlockStmt: {
	const GoASTBlockStmt *block = llvm::cast<GoASTBlockStmt>(stmt);
	for (size_t i = 0; i < block->NumList(); ++i)
	result = EvaluateStatement(block->GetList(i));
	break;
	}
	case GoASTNode::eBadStmt:
	m_parser.GetError(m_error);
	break;
	case GoASTNode::eExprStmt: {
	const GoASTExprStmt *expr = llvm::cast<GoASTExprStmt>(stmt);
	return EvaluateExpr(expr->GetX());
	}
	default:
	m_error.SetErrorStringWithFormat("%s node not supported",
	stmt->GetKindName());
	}
	return result;
	}

	ValueObjectSP GoUserExpression::GoInterpreter::EvaluateExpr(
	const lldb_private::GoASTExpr *e) {
	if (e)
	return e->Visit<ValueObjectSP>(this);
	return ValueObjectSP();
	}

	ValueObjectSP GoUserExpression::GoInterpreter::VisitParenExpr(
	const lldb_private::GoASTParenExpr *e) {
	return EvaluateExpr(e->GetX());
	}

	ValueObjectSP GoUserExpression::GoInterpreter::VisitIdent(const GoASTIdent *e) {
	ValueObjectSP val;
	if (m_frame) {
	VariableSP var_sp;
	std::string varname = e->GetName().m_value.str();
	if (varname.size() > 1 && varname[0] == '$') {
	RegisterContextSP reg_ctx_sp = m_frame->GetRegisterContext();
	const RegisterInfo *reg =
	reg_ctx_sp->GetRegisterInfoByName(varname.c_str() + 1);
	if (reg) {
	std::string type;
	switch (reg->encoding) {
	case lldb::eEncodingSint:
	type.append("int");
	break;
	case lldb::eEncodingUint:
	type.append("uint");
	break;
	case lldb::eEncodingIEEE754:
	type.append("float");
	break;
	default:
	m_error.SetErrorString("Invalid register encoding");
	return nullptr;
	}
	switch (reg->byte_size) {
	case 8:
	type.append("64");
	break;
	case 4:
	type.append("32");
	break;
	case 2:
	type.append("16");
	break;
	case 1:
	type.append("8");
	break;
	default:
	m_error.SetErrorString("Invalid register size");
	return nullptr;
	}
	ValueObjectSP regVal = ValueObjectRegister::Create(
	m_frame.get(), reg_ctx_sp, reg->kinds[eRegisterKindLLDB]);
	CompilerType goType =
	LookupType(m_frame->CalculateTarget(), ConstString(type));
	if (regVal) {
	regVal = regVal->Cast(goType);
	return regVal;
	}
	}
	m_error.SetErrorString("Invalid register name");
	return nullptr;
	}
	VariableListSP var_list_sp(m_frame->GetInScopeVariableList(false));
	if (var_list_sp) {
	var_sp = var_list_sp->FindVariable(ConstString(varname));
	if (var_sp)
	val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
	else {
	// When a variable is on the heap instead of the stack, go records a
	// variable '&x' instead of 'x'.
	var_sp = var_list_sp->FindVariable(ConstString("&" + varname));
	if (var_sp) {
	val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
	if (val)
	val = val->Dereference(m_error);
	if (m_error.Fail())
	return nullptr;
	}
	}
	}
	if (!val) {
	m_error.Clear();
	TargetSP target = m_frame->CalculateTarget();
	if (!target) {
	m_error.SetErrorString("No target");
	return nullptr;
	}
	var_sp =
	FindGlobalVariable(target, m_package + "." + e->GetName().m_value);
	if (var_sp)
	return m_frame->TrackGlobalVariable(var_sp, m_use_dynamic);
	}
	}
	if (!val)
	m_error.SetErrorStringWithFormat("Unknown variable %s",
	e->GetName().m_value.str().c_str());
	return val;
	}

	ValueObjectSP
	GoUserExpression::GoInterpreter::VisitStarExpr(const GoASTStarExpr *e) {
	ValueObjectSP target = EvaluateExpr(e->GetX());
	if (!target)
	return nullptr;
	return target->Dereference(m_error);
	}

	ValueObjectSP GoUserExpression::GoInterpreter::VisitSelectorExpr(
	const lldb_private::GoASTSelectorExpr *e) {
	ValueObjectSP target = EvaluateExpr(e->GetX());
	if (target) {
	if (target->GetCompilerType().IsPointerType()) {
	target = target->Dereference(m_error);
	if (m_error.Fail())
	return nullptr;
	}
	ConstString field(e->GetSel()->GetName().m_value);
	ValueObjectSP result = target->GetChildMemberWithName(field, true);
	if (!result)
	m_error.SetErrorStringWithFormat("Unknown child %s", field.AsCString());
	return result;
	}
	if (const GoASTIdent *package = llvm::dyn_cast<GoASTIdent>(e->GetX())) {
	if (VariableSP global = FindGlobalVariable(
	m_exe_ctx.GetTargetSP(), package->GetName().m_value + "." +
	e->GetSel()->GetName().m_value)) {
	if (m_frame) {
	m_error.Clear();
	return m_frame->GetValueObjectForFrameVariable(global, m_use_dynamic);
	}
	}
	}
	if (const GoASTBasicLit *packageLit =
	llvm::dyn_cast<GoASTBasicLit>(e->GetX())) {
	if (packageLit->GetValue().m_type == GoLexer::LIT_STRING) {
	std::string value = packageLit->GetValue().m_value.str();
	value = value.substr(1, value.size() - 2);
	if (VariableSP global = FindGlobalVariable(
	m_exe_ctx.GetTargetSP(),
	value + "." + e->GetSel()->GetName().m_value)) {
	if (m_frame) {
	m_error.Clear();
	return m_frame->TrackGlobalVariable(global, m_use_dynamic);
	}
	}
	}
	}
	// EvaluateExpr should have already set m_error.
	return target;
	}

	ValueObjectSP GoUserExpression::GoInterpreter::VisitBasicLit(
	const lldb_private::GoASTBasicLit *e) {
	std::string value = e->GetValue().m_value.str();
	if (e->GetValue().m_type != GoLexer::LIT_INTEGER) {
	m_error.SetErrorStringWithFormat("Unsupported literal %s", value.c_str());
	return nullptr;
	}
	errno = 0;
	int64_t intvalue = strtol(value.c_str(), nullptr, 0);
	if (errno != 0) {
	m_error.SetErrorToErrno();
	return nullptr;
	}
	DataBufferSP buf(new DataBufferHeap(sizeof(intvalue), 0));
	TargetSP target = m_exe_ctx.GetTargetSP();
	if (!target) {
	m_error.SetErrorString("No target");
	return nullptr;
	}
	ByteOrder order = target->GetArchitecture().GetByteOrder();
	uint8_t addr_size = target->GetArchitecture().GetAddressByteSize();
	DataEncoder enc(buf, order, addr_size);
	enc.PutU64(0, static_cast<uint64_t>(intvalue));
	DataExtractor data(buf, order, addr_size);

	CompilerType type = LookupType(target, ConstString("int64"));
	return ValueObject::CreateValueObjectFromData(llvm::StringRef(), data,
	m_exe_ctx, type);
	}

	ValueObjectSP GoUserExpression::GoInterpreter::VisitIndexExpr(
	const lldb_private::GoASTIndexExpr *e) {
	ValueObjectSP target = EvaluateExpr(e->GetX());
	if (!target)
	return nullptr;
	ValueObjectSP index = EvaluateExpr(e->GetIndex());
	if (!index)
	return nullptr;
	bool is_signed;
	if (!index->GetCompilerType().IsIntegerType(is_signed)) {
	m_error.SetErrorString("Unsupported index");
	return nullptr;
	}
	size_t idx;
	if (is_signed)
	idx = index->GetValueAsSigned(0);
	else
	idx = index->GetValueAsUnsigned(0);
	if (GoASTContext::IsGoSlice(target->GetCompilerType())) {
	target = target->GetStaticValue();
	ValueObjectSP cap =
	target->GetChildMemberWithName(ConstString("cap"), true);
	if (cap) {
	uint64_t capval = cap->GetValueAsUnsigned(0);
	if (idx >= capval) {
	m_error.SetErrorStringWithFormat("Invalid index %" PRIu64
	" , cap = %" PRIu64,
	uint64_t(idx), capval);
	return nullptr;
	}
	}
	target = target->GetChildMemberWithName(ConstString("array"), true);
	if (target && m_use_dynamic != eNoDynamicValues) {
	ValueObjectSP dynamic = target->GetDynamicValue(m_use_dynamic);
	if (dynamic)
	target = dynamic;
	}
	if (!target)
	return nullptr;
	return target->GetSyntheticArrayMember(idx, true);
	}
	return target->GetChildAtIndex(idx, true);
	}

	ValueObjectSP
	GoUserExpression::GoInterpreter::VisitUnaryExpr(const GoASTUnaryExpr *e) {
	ValueObjectSP x = EvaluateExpr(e->GetX());
	if (!x)
	return nullptr;
	switch (e->GetOp()) {
	case GoLexer::OP_AMP: {
	CompilerType type = x->GetCompilerType().GetPointerType();
	uint64_t address = x->GetAddressOf();
	return ValueObject::CreateValueObjectFromAddress(llvm::StringRef(), address,
	m_exe_ctx, type);
	}
	case GoLexer::OP_PLUS:
	return x;
	default:
	m_error.SetErrorStringWithFormat(
	"Operator %s not supported",
	GoLexer::LookupToken(e->GetOp()).str().c_str());
	return nullptr;
	}
	}

	CompilerType GoUserExpression::GoInterpreter::EvaluateType(const GoASTExpr *e) {
	TargetSP target = m_exe_ctx.GetTargetSP();
	if (auto *id = llvm::dyn_cast<GoASTIdent>(e)) {
	CompilerType result =
	LookupType(target, ConstString(id->GetName().m_value));
	if (result.IsValid())
	return result;
	std::string fullname = (m_package + "." + id->GetName().m_value).str();
	result = LookupType(target, ConstString(fullname));
	if (!result)
	m_error.SetErrorStringWithFormat("Unknown type %s", fullname.c_str());
	return result;
	}
	if (auto *sel = llvm::dyn_cast<GoASTSelectorExpr>(e)) {
	std::string package;
	if (auto *pkg_node = llvm::dyn_cast<GoASTIdent>(sel->GetX())) {
	package = pkg_node->GetName().m_value.str();
	} else if (auto *str_node = llvm::dyn_cast<GoASTBasicLit>(sel->GetX())) {
	if (str_node->GetValue().m_type == GoLexer::LIT_STRING) {
	package = str_node->GetValue().m_value.substr(1).str();
	package.resize(package.length() - 1);
	}
	}
	if (package.empty()) {
	m_error.SetErrorStringWithFormat("Invalid %s in type expression",
	sel->GetX()->GetKindName());
	return CompilerType();
	}
	std::string fullname =
	(package + "." + sel->GetSel()->GetName().m_value).str();
	CompilerType result = LookupType(target, ConstString(fullname));
	if (!result)
	m_error.SetErrorStringWithFormat("Unknown type %s", fullname.c_str());
	return result;
	}
	if (auto *star = llvm::dyn_cast<GoASTStarExpr>(e)) {
	CompilerType elem = EvaluateType(star->GetX());
	return elem.GetPointerType();
	}
	if (auto *paren = llvm::dyn_cast<GoASTParenExpr>(e))
	return EvaluateType(paren->GetX());
	if (auto *array = llvm::dyn_cast<GoASTArrayType>(e)) {
	CompilerType elem = EvaluateType(array->GetElt());
	}

	m_error.SetErrorStringWithFormat("Invalid %s in type expression",
	e->GetKindName());
	return CompilerType();
	}

	ValueObjectSP GoUserExpression::GoInterpreter::VisitCallExpr(
	const lldb_private::GoASTCallExpr *e) {
	ValueObjectSP x = EvaluateExpr(e->GetFun());
	if (x \|\| e->NumArgs() != 1) {
	m_error.SetErrorStringWithFormat("Code execution not supported");
	return nullptr;
	}
	m_error.Clear();
	CompilerType type = EvaluateType(e->GetFun());
	if (!type) {
	return nullptr;
	}
	ValueObjectSP value = EvaluateExpr(e->GetArgs(0));
	if (!value)
	return nullptr;
	// TODO: Handle special conversions
	return value->Cast(type);
	}

	GoPersistentExpressionState::GoPersistentExpressionState()
	: PersistentExpressionState(eKindGo) {}

	void GoPersistentExpressionState::RemovePersistentVariable(
	lldb::ExpressionVariableSP variable) {
	RemoveVariable(variable);

	const char *name = variable->GetName().AsCString();

	if (*(name++) != '$')
	return;
	if (*(name++) != 'g')
	return;
	if (*(name++) != 'o')
	return;

	if (strtoul(name, nullptr, 0) == m_next_persistent_variable_id - 1)
	m_next_persistent_variable_id--;
	}

source/Plugins/ExpressionParser/Go/gen_go_ast.py

This file was deleted.

	import StringIO


	def addNodes():
	addNode("ArrayType", "Expr", "len", "Expr", "elt", "Expr")
	addNode(
	"AssignStmt",
	"Stmt",
	"lhs",
	"[]Expr",
	"rhs",
	"[]Expr",
	"define",
	"bool")
	addNode("BadDecl", "Decl")
	addNode("BadExpr", "Expr")
	addNode("BadStmt", "Stmt")
	addNode("BasicLit", "Expr", "value", "Token")
	addNode("BinaryExpr", "Expr", "x", "Expr", "y", "Expr", "op", "TokenType")
	addNode("BlockStmt", "Stmt", "list", "[]Stmt")
	addNode("Ident", "Expr", "name", "Token")
	addNode("BranchStmt", "Stmt", "label", "Ident", "tok", "TokenType")
	addNode(
	"CallExpr",
	"Expr",
	"fun",
	"Expr",
	"args",
	"[]Expr",
	"ellipsis",
	"bool")
	addNode("CaseClause", "Stmt", "list", "[]Expr", "body", "[]Stmt")
	addNode("ChanType", "Expr", "dir", "ChanDir", "value", "Expr")
	addNode("CommClause", "Stmt", "comm", "Stmt", "body", "[]Stmt")
	addNode("CompositeLit", "Expr", "type", "Expr", "elts", "[]Expr")
	addNode("DeclStmt", "Stmt", "decl", "Decl")
	addNode("DeferStmt", "Stmt", "call", "CallExpr")
	addNode("Ellipsis", "Expr", "elt", "Expr")
	addNode("EmptyStmt", "Stmt")
	addNode("ExprStmt", "Stmt", "x", "Expr")
	addNode(
	"Field",
	"Node",
	"names",
	"[]Ident",
	"type",
	"Expr",
	"tag",
	"BasicLit")
	addNode("FieldList", "Node", "list", "[]Field")
	addNode(
	"ForStmt",
	"Stmt",
	"init",
	"Stmt",
	"cond",
	"Expr",
	"post",
	"Stmt",
	"body",
	"BlockStmt")
	addNode("FuncType", "Expr", "params", "FieldList", "results", "FieldList")
	addNode(
	"FuncDecl",
	"Decl",
	"recv",
	"FieldList",
	"name",
	"Ident",
	"type",
	"FuncType",
	"body",
	"BlockStmt")
	addNode("FuncLit", "Expr", "type", "FuncType", "body", "BlockStmt")
	addNode("GenDecl", "Decl", "tok", "TokenType", "specs", "[]Spec")
	addNode("GoStmt", "Stmt", "call", "CallExpr")
	addNode(
	"IfStmt",
	"Stmt",
	"init",
	"Stmt",
	"cond",
	"Expr",
	"body",
	"BlockStmt",
	"els",
	"Stmt")
	addNode("ImportSpec", "Spec", "name", "Ident", "path", "BasicLit")
	addNode("IncDecStmt", "Stmt", "x", "Expr", "tok", "TokenType")
	addNode("IndexExpr", "Expr", "x", "Expr", "index", "Expr")
	addNode("InterfaceType", "Expr", "methods", "FieldList")
	addNode("KeyValueExpr", "Expr", "key", "Expr", "value", "Expr")
	addNode("LabeledStmt", "Stmt", "label", "Ident", "stmt", "Stmt")
	addNode("MapType", "Expr", "key", "Expr", "value", "Expr")
	addNode("ParenExpr", "Expr", "x", "Expr")
	addNode(
	"RangeStmt",
	"Stmt",
	"key",
	"Expr",
	"value",
	"Expr",
	"define",
	"bool",
	"x",
	"Expr",
	"body",
	"BlockStmt")
	addNode("ReturnStmt", "Stmt", "results", "[]Expr")
	addNode("SelectStmt", "Stmt", "body", "BlockStmt")
	addNode("SelectorExpr", "Expr", "x", "Expr", "sel", "Ident")
	addNode("SendStmt", "Stmt", "chan", "Expr", "value", "Expr")
	addNode(
	"SliceExpr",
	"Expr",
	"x",
	"Expr",
	"low",
	"Expr",
	"high",
	"Expr",
	"max",
	"Expr",
	"slice3",
	"bool")
	addNode("StarExpr", "Expr", "x", "Expr")
	addNode("StructType", "Expr", "fields", "FieldList")
	addNode(
	"SwitchStmt",
	"Stmt",
	"init",
	"Stmt",
	"tag",
	"Expr",
	"body",
	"BlockStmt")
	addNode("TypeAssertExpr", "Expr", "x", "Expr", "type", "Expr")
	addNode("TypeSpec", "Spec", "name", "Ident", "type", "Expr")
	addNode(
	"TypeSwitchStmt",
	"Stmt",
	"init",
	"Stmt",
	"assign",
	"Stmt",
	"body",
	"BlockStmt")
	addNode("UnaryExpr", "Expr", "op", "TokenType", "x", "Expr")
	addNode(
	"ValueSpec",
	"Spec",
	"names",
	"[]Ident",
	"type",
	"Expr",
	"values",
	"[]Expr")
	addParent("Decl", "Node")
	addParent("Expr", "Node")
	addParent("Spec", "Node")
	addParent("Stmt", "Node")


	class Member(object):

	def __init__(self, name, typename):
	self.title = name.title()
	self.sname = name
	self.mname = 'm_' + name
	self.is_list = typename.startswith("[]")
	self.is_value = isValueType(typename)
	if self.is_value:
	self.argtype = typename
	self.mtype = typename
	elif self.is_list:
	self.argtype = 'GoAST' + typename[2:]
	self.mtype = 'std::vector<std::unique_ptr<%s> >' % self.argtype
	else:
	self.argtype = 'GoAST' + typename
	self.mtype = 'std::unique_ptr<%s>' % self.argtype
	self.mname = self.mname + '_up'


	kinds = {}
	parentClasses = StringIO.StringIO()
	childClasses = StringIO.StringIO()
	walker = StringIO.StringIO()


	def startClass(name, parent, out):
	out.write("""
	class GoAST%s : public GoAST%s
	{
	public:
	""" % (name, parent))


	def endClass(name, out):
	out.write("""
	%(name)s(const %(name)s &) = delete;
	const %(name)s &operator=(const %(name)s &) = delete;
	};
	""" % {'name': 'GoAST' + name})


	def addNode(name, parent, *children):
	startClass(name, parent, childClasses)
	l = kinds.setdefault(parent, [])
	l.append(name)
	children = createMembers(name, children)
	addConstructor(name, parent, children)
	childClasses.write("""
	const char *
	GetKindName() const override
	{
	return "%(name)s";
	}

	static bool
	classof(const GoASTNode *n)
	{
	return n->GetKind() == e%(name)s;
	}
	""" % {'name': name})
	addChildren(name, children)
	endClass(name, childClasses)


	def isValueType(typename):
	if typename[0].islower():
	return True
	if typename[0].isupper():
	return typename.startswith('Token') or typename == 'ChanDir'
	return False


	def createMembers(name, children):
	l = len(children)
	if (l % 2) != 0:
	raise Exception("Invalid children for %s: %s" % (name, children))
	return [Member(children[i], children[i + 1]) for i in xrange(0, l, 2)]


	def addConstructor(name, parent, children):
	for c in children:
	if c.is_list:
	children = [x for x in children if x.is_value]
	break
	childClasses.write(' ')
	if len(children) == 1:
	childClasses.write('explicit ')
	childClasses.write('GoAST%s(' % name)
	for i in xrange(len(children)):
	if i > 0:
	childClasses.write(', ')

	c = children[i]
	if c.is_value:
	childClasses.write(c.argtype)
	childClasses.write(' ')
	else:
	childClasses.write('%s *' % c.argtype)
	childClasses.write(c.sname)
	childClasses.write(') : GoAST%s(e%s)' % (parent, name))
	for c in children:
	childClasses.write(', ')
	childClasses.write('%(mname)s(%(sname)s)' % c.__dict__)
	childClasses.write(""" {}
	~GoAST%s() override = default;
	""" % name)


	def addChildren(name, children):
	if len(children) == 0:
	return
	walker.write("""
	case e%(n)s:
	{
	GoAST%(n)s *n = llvm::cast<GoAST%(n)s>(this);
	(void)n;""" % {'n': name})
	for c in children:
	if c.is_list:
	childClasses.write("""
	size_t
	Num%(title)s() const
	{
	return %(mname)s.size();
	}
	const %(argtype)s *
	Get%(title)s(int i) const
	{
	return %(mname)s[i].get();
	}
	void
	Add%(title)s(%(argtype)s *%(sname)s)
	{
	%(mname)s.push_back(std::unique_ptr<%(argtype)s>(%(sname)s));
	}
	""" % c.__dict__)
	walker.write("""
	for (auto& e : n->%s) { v(e.get()); }""" % c.mname)
	else:
	const = ''
	get = ''
	set = ''
	t = c.argtype
	if isValueType(t):
	set = '%(mname)s = %(sname)s' % c.__dict__
	t = t + ' '
	else:
	t = t + ' *'
	const = 'const '
	get = '.get()'
	set = '%(mname)s.reset(%(sname)s)' % c.__dict__
	walker.write("""
	v(n->%s.get());""" % c.mname)
	childClasses.write("""
	%(const)s%(type)s
	Get%(title)s() const
	{
	return %(mname)s%(get)s;
	}
	void
	Set%(title)s(%(type)s%(sname)s)
	{
	%(set)s;
	}
	""" % {'const': const, 'title': c.title, 'sname': c.sname, 'get': get, 'set': set, 'type': t, 'mname': c.mname})
	childClasses.write('\n private:\n friend class GoASTNode;\n')
	walker.write("""
	return;
	}""")
	for c in children:
	childClasses.write(' %s %s;\n' % (c.mtype, c.mname))


	def addParent(name, parent):
	startClass(name, parent, parentClasses)
	l = kinds[name]
	minName = l[0]
	maxName = l[-1]
	parentClasses.write(""" template <typename R, typename V> R Visit(V *v) const;

	static bool
	classof(const GoASTNode *n)
	{
	return n->GetKind() >= e%s && n->GetKind() <= e%s;
	}

	protected:
	explicit GoAST%s(NodeKind kind) : GoASTNode(kind) { }
	private:
	""" % (minName, maxName, name))
	endClass(name, parentClasses)

	addNodes()

	print """//===-- GoAST.h -------------------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	// DO NOT EDIT.
	// Generated by gen_go_ast.py

	#ifndef liblldb_GoAST_h
	#define liblldb_GoAST_h

	#include "lldb/lldb-forward.h"
	#include "lldb/lldb-private.h"
	#include "llvm/Support/Casting.h"
	#include "Plugins/ExpressionParser/Go/GoLexer.h"

	namespace lldb_private
	{

	class GoASTNode
	{
	public:
	typedef GoLexer::TokenType TokenType;
	typedef GoLexer::Token Token;
	enum ChanDir
	{
	eChanBidir,
	eChanSend,
	eChanRecv,
	};
	enum NodeKind
	{"""
	for l in kinds.itervalues():
	for x in l:
	print " e%s," % x
	print """ };

	virtual ~GoASTNode() = default;

	NodeKind
	GetKind() const
	{
	return m_kind;
	}

	virtual const char *GetKindName() const = 0;

	template <typename V> void WalkChildren(V &v);

	protected:
	explicit GoASTNode(NodeKind kind) : m_kind(kind) { }

	private:
	const NodeKind m_kind;

	GoASTNode(const GoASTNode &) = delete;
	const GoASTNode &operator=(const GoASTNode &) = delete;
	};
	"""


	print parentClasses.getvalue()
	print childClasses.getvalue()

	for k, l in kinds.iteritems():
	if k == 'Node':
	continue
	print """
	template <typename R, typename V>
	R GoAST%s::Visit(V* v) const
	{
	switch(GetKind())
	{""" % k
	for subtype in l:
	print """ case e%(n)s:
	return v->Visit%(n)s(llvm::cast<const GoAST%(n)s>(this));""" % {'n': subtype}

	print """ default:
	assert(false && "Invalid kind");
	}
	}"""

	print """
	template <typename V>
	void GoASTNode::WalkChildren(V &v)
	{
	switch (m_kind)
	{
	"""
	print walker.getvalue()
	print"""
	case eEmptyStmt:
	case eBadDecl:
	case eBadExpr:
	case eBadStmt:
	break;
	}
	}

	} // namespace lldb_private

	#endif
	"""

source/Plugins/Language/CMakeLists.txt

	add_subdirectory(ClangCommon)			add_subdirectory(ClangCommon)
	add_subdirectory(CPlusPlus)			add_subdirectory(CPlusPlus)
	add_subdirectory(Go)
	add_subdirectory(Java)			add_subdirectory(Java)
	add_subdirectory(ObjC)			add_subdirectory(ObjC)
	add_subdirectory(ObjCPlusPlus)			add_subdirectory(ObjCPlusPlus)
	add_subdirectory(OCaml)			add_subdirectory(OCaml)

source/Plugins/Language/Go/CMakeLists.txt

This file was deleted.

	add_lldb_library(lldbPluginGoLanguage PLUGIN
	GoLanguage.cpp
	GoFormatterFunctions.cpp

	LINK_LIBS
	clangAST
	lldbCore
	lldbDataFormatters
	lldbSymbol
	lldbTarget
	LINK_COMPONENTS
	Support
	)

source/Plugins/Language/Go/GoFormatterFunctions.h

This file was deleted.

	//===-- GoFormatterFunctions.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_GoFormatterFunctions_h_
	#define liblldb_GoFormatterFunctions_h_

	// C Includes
	#include <stdint.h>
	#include <time.h>

	// C++ Includes
	// Other libraries and framework includes
	#include "clang/AST/ASTContext.h"

	// Project includes
	#include "lldb/lldb-forward.h"

	#include "lldb/DataFormatters/FormatClasses.h"
	#include "lldb/DataFormatters/TypeSynthetic.h"
	#include "lldb/Target/ExecutionContext.h"
	#include "lldb/Target/ObjCLanguageRuntime.h"
	#include "lldb/Target/Target.h"
	#include "lldb/Utility/ConstString.h"

	namespace lldb_private {
	namespace formatters {

	bool GoStringSummaryProvider(ValueObject &valobj, Stream &stream,
	const TypeSummaryOptions &options);

	SyntheticChildrenFrontEnd *
	GoSliceSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP);

	} // namespace formatters
	} // namespace lldb_private

	#endif // liblldb_GoFormatterFunctions_h_

source/Plugins/Language/Go/GoFormatterFunctions.cpp

This file was deleted.

	//===-- GoFormatterFunctions.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
	#include <map>

	// Other libraries and framework includes
	// Project includes
	#include "GoFormatterFunctions.h"
	#include "lldb/DataFormatters/FormattersHelpers.h"
	#include "lldb/DataFormatters/StringPrinter.h"

	using namespace lldb;
	using namespace lldb_private;
	using namespace lldb_private::formatters;

	namespace {
	class GoSliceSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
	public:
	GoSliceSyntheticFrontEnd(ValueObject &valobj)
	: SyntheticChildrenFrontEnd(valobj) {
	Update();
	}

	~GoSliceSyntheticFrontEnd() override = default;

	size_t CalculateNumChildren() override { return m_len; }

	lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
	if (idx < m_len) {
	ValueObjectSP &cached = m_children[idx];
	if (!cached) {
	StreamString idx_name;
	idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
	lldb::addr_t object_at_idx = m_base_data_address;
	object_at_idx += idx * m_type.GetByteSize(nullptr);
	cached = CreateValueObjectFromAddress(
	idx_name.GetString(), object_at_idx,
	m_backend.GetExecutionContextRef(), m_type);
	}
	return cached;
	}
	return ValueObjectSP();
	}

	bool Update() override {
	size_t old_count = m_len;

	ConstString array_const_str("array");
	ValueObjectSP array_sp =
	m_backend.GetChildMemberWithName(array_const_str, true);
	if (!array_sp) {
	m_children.clear();
	return old_count == 0;
	}
	m_type = array_sp->GetCompilerType().GetPointeeType();
	m_base_data_address = array_sp->GetPointerValue();

	ConstString len_const_str("len");
	ValueObjectSP len_sp =
	m_backend.GetChildMemberWithName(len_const_str, true);
	if (len_sp) {
	m_len = len_sp->GetValueAsUnsigned(0);
	m_children.clear();
	}

	return old_count == m_len;
	}

	bool MightHaveChildren() override { return true; }

	size_t GetIndexOfChildWithName(const ConstString &name) override {
	return ExtractIndexFromString(name.AsCString());
	}

	private:
	CompilerType m_type;
	lldb::addr_t m_base_data_address;
	size_t m_len;
	std::map<size_t, lldb::ValueObjectSP> m_children;
	};

	} // anonymous namespace

	bool lldb_private::formatters::GoStringSummaryProvider(
	ValueObject &valobj, Stream &stream, const TypeSummaryOptions &opts) {
	ProcessSP process_sp = valobj.GetProcessSP();
	if (!process_sp)
	return false;

	if (valobj.IsPointerType()) {
	Status err;
	ValueObjectSP deref = valobj.Dereference(err);
	if (!err.Success())
	return false;
	return GoStringSummaryProvider(*deref, stream, opts);
	}

	ConstString str_name("str");
	ConstString len_name("len");

	ValueObjectSP data_sp = valobj.GetChildMemberWithName(str_name, true);
	ValueObjectSP len_sp = valobj.GetChildMemberWithName(len_name, true);
	if (!data_sp \|\| !len_sp)
	return false;
	bool success;
	lldb::addr_t valobj_addr = data_sp->GetValueAsUnsigned(0, &success);

	if (!success)
	return false;

	uint64_t length = len_sp->GetValueAsUnsigned(0);
	if (length == 0) {
	stream.Printf("\"\"");
	return true;
	}

	StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
	options.SetLocation(valobj_addr);
	options.SetProcessSP(process_sp);
	options.SetStream(&stream);
	options.SetSourceSize(length);
	options.SetNeedsZeroTermination(false);
	options.SetLanguage(eLanguageTypeGo);

	if (!StringPrinter::ReadStringAndDumpToStream<
	StringPrinter::StringElementType::UTF8>(options)) {
	stream.Printf("Summary Unavailable");
	return true;
	}

	return true;
	}

	SyntheticChildrenFrontEnd *
	lldb_private::formatters::GoSliceSyntheticFrontEndCreator(
	CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
	if (!valobj_sp)
	return nullptr;

	lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
	if (!process_sp)
	return nullptr;
	return new GoSliceSyntheticFrontEnd(*valobj_sp);
	}

source/Plugins/Language/Go/GoLanguage.h

This file was deleted.

	//===-- GoLanguage.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_GoLanguage_h_
	#define liblldb_GoLanguage_h_

	// C Includes
	// C++ Includes
	#include <vector>

	// Other libraries and framework includes
	#include "llvm/ADT/StringRef.h"

	// Project includes
	#include "lldb/Target/Language.h"
	#include "lldb/Utility/ConstString.h"
	#include "lldb/lldb-private.h"

	namespace lldb_private {

	class GoLanguage : public Language {
	public:
	GoLanguage() = default;

	~GoLanguage() override = default;

	lldb::LanguageType GetLanguageType() const override {
	return lldb::eLanguageTypeGo;
	}

	HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries() override;

	HardcodedFormatters::HardcodedSyntheticFinder
	GetHardcodedSynthetics() override;

	bool IsSourceFile(llvm::StringRef file_path) const override;

	//------------------------------------------------------------------
	// Static Functions
	//------------------------------------------------------------------
	static void Initialize();

	static void Terminate();

	static lldb_private::Language *CreateInstance(lldb::LanguageType language);

	static lldb_private::ConstString GetPluginNameStatic();

	//------------------------------------------------------------------
	// PluginInterface protocol
	//------------------------------------------------------------------
	ConstString GetPluginName() override;

	uint32_t GetPluginVersion() override;
	};

	} // namespace lldb_private

	#endif // liblldb_GoLanguage_h_

source/Plugins/Language/Go/GoLanguage.cpp

This file was deleted.

	//===-- GoLanguage.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 <string.h>
	// C++ Includes
	#include <functional>
	#include <mutex>

	// Other libraries and framework includes
	#include "llvm/ADT/StringRef.h"
	#include "llvm/Support/Threading.h"

	// Project includes
	#include "GoLanguage.h"
	#include "Plugins/Language/Go/GoFormatterFunctions.h"
	#include "lldb/Core/PluginManager.h"
	#include "lldb/DataFormatters/FormattersHelpers.h"
	#include "lldb/Symbol/GoASTContext.h"
	#include "lldb/Utility/ConstString.h"

	using namespace lldb;
	using namespace lldb_private;
	using namespace lldb_private::formatters;

	void GoLanguage::Initialize() {
	PluginManager::RegisterPlugin(GetPluginNameStatic(), "Go Language",
	CreateInstance);
	}

	void GoLanguage::Terminate() {
	PluginManager::UnregisterPlugin(CreateInstance);
	}

	lldb_private::ConstString GoLanguage::GetPluginNameStatic() {
	static ConstString g_name("Go");
	return g_name;
	}

	//------------------------------------------------------------------
	// PluginInterface protocol
	//------------------------------------------------------------------
	lldb_private::ConstString GoLanguage::GetPluginName() {
	return GetPluginNameStatic();
	}

	uint32_t GoLanguage::GetPluginVersion() { return 1; }

	//------------------------------------------------------------------
	// Static Functions
	//------------------------------------------------------------------
	Language *GoLanguage::CreateInstance(lldb::LanguageType language) {
	if (language == eLanguageTypeGo)
	return new GoLanguage();
	return nullptr;
	}

	HardcodedFormatters::HardcodedSummaryFinder
	GoLanguage::GetHardcodedSummaries() {
	static llvm::once_flag g_initialize;
	static HardcodedFormatters::HardcodedSummaryFinder g_formatters;

	llvm::call_once(g_initialize, []() -> void {
	g_formatters.push_back(
	[](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
	FormatManager &) -> TypeSummaryImpl::SharedPointer {
	static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
	new CXXFunctionSummaryFormat(
	TypeSummaryImpl::Flags().SetDontShowChildren(true),
	lldb_private::formatters::GoStringSummaryProvider,
	"Go string summary provider"));
	if (GoASTContext::IsGoString(valobj.GetCompilerType())) {
	return formatter_sp;
	}
	if (GoASTContext::IsGoString(
	valobj.GetCompilerType().GetPointeeType())) {
	return formatter_sp;
	}
	return nullptr;
	});
	g_formatters.push_back(
	[](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
	FormatManager &) -> TypeSummaryImpl::SharedPointer {
	static lldb::TypeSummaryImplSP formatter_sp(new StringSummaryFormat(
	TypeSummaryImpl::Flags().SetHideItemNames(true),
	"(len ${var.len}, cap ${var.cap})"));
	if (GoASTContext::IsGoSlice(valobj.GetCompilerType())) {
	return formatter_sp;
	}
	if (GoASTContext::IsGoSlice(
	valobj.GetCompilerType().GetPointeeType())) {
	return formatter_sp;
	}
	return nullptr;
	});
	});
	return g_formatters;
	}

	HardcodedFormatters::HardcodedSyntheticFinder
	GoLanguage::GetHardcodedSynthetics() {
	static llvm::once_flag g_initialize;
	static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;

	llvm::call_once(g_initialize, []() -> void {
	g_formatters.push_back(
	[](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
	FormatManager &fmt_mgr) -> SyntheticChildren::SharedPointer {
	static CXXSyntheticChildren::SharedPointer formatter_sp(
	new CXXSyntheticChildren(
	SyntheticChildren::Flags(), "slice synthetic children",
	lldb_private::formatters::GoSliceSyntheticFrontEndCreator));
	if (GoASTContext::IsGoSlice(valobj.GetCompilerType())) {
	return formatter_sp;
	}
	return nullptr;
	});
	});

	return g_formatters;
	}

	bool GoLanguage::IsSourceFile(llvm::StringRef file_path) const {
	return file_path.endswith(".go");
	}

source/Plugins/LanguageRuntime/CMakeLists.txt

	add_subdirectory(CPlusPlus)			add_subdirectory(CPlusPlus)
	add_subdirectory(ObjC)			add_subdirectory(ObjC)
	add_subdirectory(Go)
	add_subdirectory(Java)			add_subdirectory(Java)
	add_subdirectory(RenderScript)			add_subdirectory(RenderScript)

source/Plugins/LanguageRuntime/Go/CMakeLists.txt

	set(LLVM_NO_RTTI 1)			set(LLVM_NO_RTTI 1)

	add_lldb_library(lldbPluginLanguageRuntimeGo PLUGIN			add_lldb_library(lldbPluginLanguageRuntimeGo PLUGIN
	GoLanguageRuntime.cpp

	LINK_LIBS			LINK_LIBS
	lldbBreakpoint			lldbBreakpoint
	lldbCore			lldbCore
	lldbSymbol			lldbSymbol
	lldbTarget			lldbTarget
	LINK_COMPONENTS			LINK_COMPONENTS
	Support			Support
	)			)

source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.h

This file was deleted.

	//===-- GoLanguageRuntime.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_GoLanguageRuntime_h_
	#define liblldb_GoLanguageRuntime_h_

	// C Includes
	// C++ Includes
	// Other libraries and framework includes
	// Project includes
	#include "lldb/Breakpoint/BreakpointResolver.h"
	#include "lldb/Core/Value.h"
	#include "lldb/Target/LanguageRuntime.h"
	#include "lldb/lldb-private.h"

	namespace lldb_private {

	class GoLanguageRuntime : public lldb_private::LanguageRuntime {
	public:
	~GoLanguageRuntime() override = default;

	//------------------------------------------------------------------
	// Static Functions
	//------------------------------------------------------------------
	static void Initialize();

	static void Terminate();

	static lldb_private::LanguageRuntime *
	CreateInstance(Process *process, lldb::LanguageType language);

	static lldb_private::ConstString GetPluginNameStatic();

	lldb::LanguageType GetLanguageType() const override {
	return lldb::eLanguageTypeGo;
	}

	bool GetObjectDescription(Stream &str, ValueObject &object) override {
	// TODO(ribrdb): Maybe call String() method?
	return false;
	}

	bool GetObjectDescription(Stream &str, Value &value,
	ExecutionContextScope *exe_scope) override {
	return false;
	}

	bool GetDynamicTypeAndAddress(ValueObject &in_value,
	lldb::DynamicValueType use_dynamic,
	TypeAndOrName &class_type_or_name,
	Address &address,
	Value::ValueType &value_type) override;

	bool CouldHaveDynamicValue(ValueObject &in_value) override;

	lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt,
	bool catch_bp,
	bool throw_bp) override {
	return lldb::BreakpointResolverSP();
	}

	TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
	ValueObject &static_value) override;

	//------------------------------------------------------------------
	// PluginInterface protocol
	//------------------------------------------------------------------
	lldb_private::ConstString GetPluginName() override;

	uint32_t GetPluginVersion() override;

	private:
	GoLanguageRuntime(Process *process)
	: lldb_private::LanguageRuntime(process) {
	} // Call CreateInstance instead.
	};

	} // namespace lldb_private

	#endif // liblldb_GoLanguageRuntime_h_

source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.cpp

This file was deleted.

	//===-- 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/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;

	namespace {
	ValueObjectSP GetChild(ValueObject &obj, const char *name,
	bool dereference = true) {
	ConstString name_const_str(name);
	ValueObjectSP result = obj.GetChildMemberWithName(name_const_str, true);
	if (dereference && result && result->IsPointerType()) {
	Status err;
	result = result->Dereference(err);
	if (err.Fail())
	result.reset();
	}
	return result;
	}

	ConstString ReadString(ValueObject &str, Process *process) {
	ConstString result;
	ValueObjectSP data = GetChild(str, "str", false);
	ValueObjectSP len = GetChild(str, "len");
	if (len && data) {
	Status err;
	lldb::addr_t addr = data->GetPointerValue();
	if (addr == LLDB_INVALID_ADDRESS)
	return result;
	uint64_t byte_size = len->GetValueAsUnsigned(0);
	char *buf = new char[byte_size + 1];
	buf[byte_size] = 0;
	size_t bytes_read = process->ReadMemory(addr, buf, byte_size, err);
	if (!(err.Fail() \|\| bytes_read != byte_size))
	result = ConstString(buf, bytes_read);
	delete[] buf;
	}
	return result;
	}

	ConstString ReadTypeName(ValueObjectSP type, Process *process) {
	if (ValueObjectSP uncommon = GetChild(*type, "x")) {
	ValueObjectSP name = GetChild(*uncommon, "name");
	ValueObjectSP package = GetChild(*uncommon, "pkgpath");
	if (name && name->GetPointerValue() != 0 && package &&
	package->GetPointerValue() != 0) {
	ConstString package_const_str = ReadString(*package, process);
	ConstString name_const_str = ReadString(*name, process);
	if (package_const_str.GetLength() == 0)
	return name_const_str;
	return ConstString((package_const_str.GetStringRef() + "." +
	name_const_str.GetStringRef())
	.str());
	}
	}
	ValueObjectSP name = GetChild(*type, "_string");
	if (name)
	return ReadString(*name, process);
	return ConstString("");
	}

	CompilerType LookupRuntimeType(ValueObjectSP type, ExecutionContext *exe_ctx,
	bool *is_direct) {
	uint8_t kind = GetChild(*type, "kind")->GetValueAsUnsigned(0);
	*is_direct = GoASTContext::IsDirectIface(kind);
	if (GoASTContext::IsPointerKind(kind)) {
	CompilerType type_ptr = type->GetCompilerType().GetPointerType();
	Status err;
	ValueObjectSP elem =
	type->CreateValueObjectFromAddress("elem", type->GetAddressOf() +
	type->GetByteSize(),
	*exe_ctx, type_ptr)
	->Dereference(err);
	if (err.Fail())
	return CompilerType();
	bool tmp_direct;
	return LookupRuntimeType(elem, exe_ctx, &tmp_direct).GetPointerType();
	}
	Target *target = exe_ctx->GetTargetPtr();
	Process *process = exe_ctx->GetProcessPtr();

	ConstString const_typename = ReadTypeName(type, process);
	if (const_typename.GetLength() == 0)
	return CompilerType();

	SymbolContext sc;
	TypeList type_list;
	llvm::DenseSet<SymbolFile *> searched_symbol_files;
	uint32_t num_matches = target->GetImages().FindTypes(
	sc, const_typename, false, 2, searched_symbol_files, type_list);
	if (num_matches > 0) {
	return type_list.GetTypeAtIndex(0)->GetFullCompilerType();
	}
	return CompilerType();
	}
	}

	bool GoLanguageRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
	return GoASTContext::IsGoInterface(in_value.GetCompilerType());
	}

	bool GoLanguageRuntime::GetDynamicTypeAndAddress(
	ValueObject &in_value, lldb::DynamicValueType use_dynamic,
	TypeAndOrName &class_type_or_name, Address &dynamic_address,
	Value::ValueType &value_type) {
	value_type = Value::eValueTypeScalar;
	class_type_or_name.Clear();
	if (CouldHaveDynamicValue(in_value)) {
	Status err;
	ValueObjectSP iface = in_value.GetStaticValue();
	ValueObjectSP data_sp = GetChild(*iface, "data", false);
	if (!data_sp)
	return false;

	if (ValueObjectSP tab = GetChild(*iface, "tab"))
	iface = tab;
	ValueObjectSP type = GetChild(*iface, "_type");
	if (!type) {
	return false;
	}

	bool direct;
	ExecutionContext exe_ctx(in_value.GetExecutionContextRef());
	CompilerType final_type = LookupRuntimeType(type, &exe_ctx, &direct);
	if (!final_type)
	return false;
	if (direct) {
	class_type_or_name.SetCompilerType(final_type);
	} else {
	// TODO: implement reference types or fix caller to support dynamic types
	// that aren't pointers
	// so we don't have to introduce this extra pointer.
	class_type_or_name.SetCompilerType(final_type.GetPointerType());
	}

	dynamic_address.SetLoadAddress(data_sp->GetPointerValue(),
	exe_ctx.GetTargetPtr());

	return true;
	}
	return false;
	}

	TypeAndOrName
	GoLanguageRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
	ValueObject &static_value) {
	return type_and_or_name;
	}

	//------------------------------------------------------------------
	// Static Functions
	//------------------------------------------------------------------
	LanguageRuntime *
	GoLanguageRuntime::CreateInstance(Process *process,
	lldb::LanguageType language) {
	if (language == eLanguageTypeGo)
	return new GoLanguageRuntime(process);
	else
	return NULL;
	}

	void GoLanguageRuntime::Initialize() {
	PluginManager::RegisterPlugin(GetPluginNameStatic(), "Go Language Runtime",
	CreateInstance);
	}

	void GoLanguageRuntime::Terminate() {
	PluginManager::UnregisterPlugin(CreateInstance);
	}

	lldb_private::ConstString GoLanguageRuntime::GetPluginNameStatic() {
	static ConstString g_name("golang");
	return g_name;
	}

	//------------------------------------------------------------------
	// PluginInterface protocol
	//------------------------------------------------------------------
	lldb_private::ConstString GoLanguageRuntime::GetPluginName() {
	return GetPluginNameStatic();
	}

	uint32_t GoLanguageRuntime::GetPluginVersion() { return 1; }

source/Plugins/OperatingSystem/CMakeLists.txt

	add_subdirectory(Go)
	add_subdirectory(Python)			add_subdirectory(Python)

source/Plugins/OperatingSystem/Go/CMakeLists.txt

This file was deleted.

	add_lldb_library(lldbPluginOSGo PLUGIN
	OperatingSystemGo.cpp

	LINK_LIBS
	lldbCore
	lldbInterpreter
	lldbSymbol
	lldbTarget
	lldbPluginProcessUtility
	)

source/Plugins/OperatingSystem/Go/OperatingSystemGo.h

This file was deleted.

	//===-- OperatingSystemGo.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_OperatingSystemGo_h_
	#define _liblldb_OperatingSystemGo_h_

	// C Includes
	// C++ Includes
	#include <memory>

	// Other libraries and framework includes
	// Project includes
	#include "lldb/Target/OperatingSystem.h"

	class DynamicRegisterInfo;

	class OperatingSystemGo : public lldb_private::OperatingSystem {
	public:
	OperatingSystemGo(lldb_private::Process *process);

	~OperatingSystemGo() override;

	//------------------------------------------------------------------
	// Static Functions
	//------------------------------------------------------------------
	static lldb_private::OperatingSystem *
	CreateInstance(lldb_private::Process *process, bool force);

	static void Initialize();

	static void DebuggerInitialize(lldb_private::Debugger &debugger);

	static void Terminate();

	static lldb_private::ConstString GetPluginNameStatic();

	static const char *GetPluginDescriptionStatic();

	//------------------------------------------------------------------
	// lldb_private::PluginInterface Methods
	//------------------------------------------------------------------
	lldb_private::ConstString GetPluginName() override;

	uint32_t GetPluginVersion() override;

	//------------------------------------------------------------------
	// lldb_private::OperatingSystem Methods
	//------------------------------------------------------------------
	bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
	lldb_private::ThreadList &real_thread_list,
	lldb_private::ThreadList &new_thread_list) override;

	void ThreadWasSelected(lldb_private::Thread *thread) override;

	lldb::RegisterContextSP
	CreateRegisterContextForThread(lldb_private::Thread *thread,
	lldb::addr_t reg_data_addr) override;

	lldb::StopInfoSP
	CreateThreadStopReason(lldb_private::Thread *thread) override;

	//------------------------------------------------------------------
	// Method for lazy creation of threads on demand
	//------------------------------------------------------------------
	lldb::ThreadSP CreateThread(lldb::tid_t tid, lldb::addr_t context) override;

	private:
	struct Goroutine;

	static lldb::ValueObjectSP FindGlobal(lldb::TargetSP target,
	const char *name);

	static lldb::TypeSP FindType(lldb::TargetSP target_sp, const char *name);

	bool Init(lldb_private::ThreadList &threads);

	Goroutine CreateGoroutineAtIndex(uint64_t idx, lldb_private::Status &err);

	std::unique_ptr<DynamicRegisterInfo> m_reginfo;
	lldb::ValueObjectSP m_allg_sp;
	lldb::ValueObjectSP m_allglen_sp;
	};

	#endif // liblldb_OperatingSystemGo_h_

source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

This file was deleted.

	//===-- OperatingSystemGo.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
	#include <unordered_map>

	// Other libraries and framework includes
	// Project includes
	#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/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 constexpr PropertyDefinition g_properties[] = {
	{"enable", OptionValue::eTypeBoolean, true, true, nullptr, {},
	"Specify whether goroutines should be treated as threads."}};

	enum {
	ePropertyEnableGoroutines,
	};

	class PluginProperties : public Properties {
	public:
	PluginProperties() : Properties() {
	m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
	m_collection_sp->Initialize(g_properties);
	}

	~PluginProperties() override = default;

	static ConstString GetSettingName() {
	return OperatingSystemGo::GetPluginNameStatic();
	}

	bool GetEnableGoroutines() {
	const uint32_t idx = ePropertyEnableGoroutines;
	return m_collection_sp->GetPropertyAtIndexAsBoolean(
	NULL, idx, g_properties[idx].default_uint_value);
	}

	bool SetEnableGoroutines(bool enable) {
	const uint32_t idx = ePropertyEnableGoroutines;
	return m_collection_sp->SetPropertyAtIndexAsUInt64(NULL, idx, enable);
	}
	};

	typedef std::shared_ptr<PluginProperties> OperatingSystemGoPropertiesSP;

	static const OperatingSystemGoPropertiesSP &GetGlobalPluginProperties() {
	static OperatingSystemGoPropertiesSP g_settings_sp;
	if (!g_settings_sp)
	g_settings_sp.reset(new PluginProperties());
	return g_settings_sp;
	}

	class RegisterContextGo : public RegisterContextMemory {
	public:
	RegisterContextGo(lldb_private::Thread &thread, uint32_t concrete_frame_idx,
	DynamicRegisterInfo &reg_info, lldb::addr_t reg_data_addr)
	: RegisterContextMemory(thread, concrete_frame_idx, reg_info,
	reg_data_addr) {
	const RegisterInfo *sp = reg_info.GetRegisterInfoAtIndex(
	reg_info.ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
	LLDB_REGNUM_GENERIC_SP));
	const RegisterInfo *pc = reg_info.GetRegisterInfoAtIndex(
	reg_info.ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
	LLDB_REGNUM_GENERIC_PC));
	size_t byte_size = std::max(sp->byte_offset + sp->byte_size,
	pc->byte_offset + pc->byte_size);

	DataBufferSP reg_data_sp(new DataBufferHeap(byte_size, 0));
	m_reg_data.SetData(reg_data_sp);
	}

	~RegisterContextGo() override = default;

	bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
	lldb_private::RegisterValue &reg_value) override {
	switch (reg_info->kinds[eRegisterKindGeneric]) {
	case LLDB_REGNUM_GENERIC_SP:
	case LLDB_REGNUM_GENERIC_PC:
	return RegisterContextMemory::ReadRegister(reg_info, reg_value);
	default:
	reg_value.SetValueToInvalid();
	return true;
	}
	}

	bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
	const lldb_private::RegisterValue &reg_value) override {
	switch (reg_info->kinds[eRegisterKindGeneric]) {
	case LLDB_REGNUM_GENERIC_SP:
	case LLDB_REGNUM_GENERIC_PC:
	return RegisterContextMemory::WriteRegister(reg_info, reg_value);
	default:
	return false;
	}
	}

	private:
	DISALLOW_COPY_AND_ASSIGN(RegisterContextGo);
	};

	} // anonymous namespace

	struct OperatingSystemGo::Goroutine {
	uint64_t m_lostack;
	uint64_t m_histack;
	uint64_t m_goid;
	addr_t m_gobuf;
	uint32_t m_status;
	};

	void OperatingSystemGo::Initialize() {
	PluginManager::RegisterPlugin(GetPluginNameStatic(),
	GetPluginDescriptionStatic(), CreateInstance,
	DebuggerInitialize);
	}

	void OperatingSystemGo::DebuggerInitialize(Debugger &debugger) {
	if (!PluginManager::GetSettingForOperatingSystemPlugin(
	debugger, PluginProperties::GetSettingName())) {
	const bool is_global_setting = true;
	PluginManager::CreateSettingForOperatingSystemPlugin(
	debugger, GetGlobalPluginProperties()->GetValueProperties(),
	ConstString("Properties for the goroutine thread plug-in."),
	is_global_setting);
	}
	}

	void OperatingSystemGo::Terminate() {
	PluginManager::UnregisterPlugin(CreateInstance);
	}

	OperatingSystem OperatingSystemGo::CreateInstance(Process process,
	bool force) {
	if (!force) {
	TargetSP target_sp = process->CalculateTarget();
	if (!target_sp)
	return nullptr;
	ModuleList &module_list = target_sp->GetImages();
	std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
	const size_t num_modules = module_list.GetSize();
	bool found_go_runtime = false;
	for (size_t i = 0; i < num_modules; ++i) {
	Module *module = module_list.GetModulePointerAtIndexUnlocked(i);
	const SectionList *section_list = module->GetSectionList();
	if (section_list) {
	SectionSP section_sp(
	section_list->FindSectionByType(eSectionTypeGoSymtab, true));
	if (section_sp) {
	found_go_runtime = true;
	break;
	}
	}
	}
	if (!found_go_runtime)
	return nullptr;
	}
	return new OperatingSystemGo(process);
	}

	OperatingSystemGo::OperatingSystemGo(lldb_private::Process *process)
	: OperatingSystem(process), m_reginfo(new DynamicRegisterInfo) {}

	OperatingSystemGo::~OperatingSystemGo() = default;

	ConstString OperatingSystemGo::GetPluginNameStatic() {
	static ConstString g_name("goroutines");
	return g_name;
	}

	const char *OperatingSystemGo::GetPluginDescriptionStatic() {
	return "Operating system plug-in that reads runtime data-structures for "
	"goroutines.";
	}

	bool OperatingSystemGo::Init(ThreadList &threads) {
	if (threads.GetSize(false) < 1)
	return false;
	TargetSP target_sp = m_process->CalculateTarget();
	if (!target_sp)
	return false;
	// Go 1.6 stores goroutines in a slice called runtime.allgs
	ValueObjectSP allgs_sp = FindGlobal(target_sp, "runtime.allgs");
	if (allgs_sp) {
	m_allg_sp = allgs_sp->GetChildMemberWithName(ConstString("array"), true);
	m_allglen_sp = allgs_sp->GetChildMemberWithName(ConstString("len"), true);
	} else {
	// Go 1.4 stores goroutines in the variable runtime.allg.
	m_allg_sp = FindGlobal(target_sp, "runtime.allg");
	m_allglen_sp = FindGlobal(target_sp, "runtime.allglen");
	}

	if (m_allg_sp && !m_allglen_sp) {
	StreamSP error_sp = target_sp->GetDebugger().GetAsyncErrorStream();
	error_sp->Printf("Unsupported Go runtime version detected.");
	return false;
	}

	if (!m_allg_sp)
	return false;

	RegisterContextSP real_registers_sp =
	threads.GetThreadAtIndex(0, false)->GetRegisterContext();

	std::unordered_map<size_t, ConstString> register_sets;
	for (size_t set_idx = 0; set_idx < real_registers_sp->GetRegisterSetCount();
	++set_idx) {
	const RegisterSet *set = real_registers_sp->GetRegisterSet(set_idx);
	ConstString name(set->name);
	for (size_t reg_idx = 0; reg_idx < set->num_registers; ++reg_idx) {
	register_sets[reg_idx] = name;
	}
	}
	TypeSP gobuf_sp = FindType(target_sp, "runtime.gobuf");
	if (!gobuf_sp) {
	Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));

	if (log)
	log->Printf("OperatingSystemGo unable to find struct Gobuf");
	return false;
	}
	CompilerType gobuf_type(gobuf_sp->GetLayoutCompilerType());
	for (size_t idx = 0; idx < real_registers_sp->GetRegisterCount(); ++idx) {
	RegisterInfo reg = *real_registers_sp->GetRegisterInfoAtIndex(idx);
	int field_index = -1;
	if (reg.kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP) {
	field_index = 0;
	} else if (reg.kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC) {
	field_index = 1;
	}
	if (field_index == -1) {
	reg.byte_offset = ~0;
	} else {
	std::string field_name;
	uint64_t bit_offset = 0;
	CompilerType field_type = gobuf_type.GetFieldAtIndex(
	field_index, field_name, &bit_offset, nullptr, nullptr);
	reg.byte_size = field_type.GetByteSize(nullptr);
	reg.byte_offset = bit_offset / 8;
	}
	ConstString name(reg.name);
	ConstString alt_name(reg.alt_name);
	m_reginfo->AddRegister(reg, name, alt_name, register_sets[idx]);
	}
	return true;
	}

	//------------------------------------------------------------------
	// PluginInterface protocol
	//------------------------------------------------------------------
	ConstString OperatingSystemGo::GetPluginName() { return GetPluginNameStatic(); }

	uint32_t OperatingSystemGo::GetPluginVersion() { return 1; }

	bool OperatingSystemGo::UpdateThreadList(ThreadList &old_thread_list,
	ThreadList &real_thread_list,
	ThreadList &new_thread_list) {
	new_thread_list = real_thread_list;
	Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));

	if (!(m_allg_sp \|\| Init(real_thread_list)) \|\| (m_allg_sp && !m_allglen_sp) \|\|
	!GetGlobalPluginProperties()->GetEnableGoroutines()) {
	return new_thread_list.GetSize(false) > 0;
	}

	if (log)
	log->Printf("OperatingSystemGo::UpdateThreadList(%d, %d, %d) fetching "
	"thread data from Go for pid %" PRIu64,
	old_thread_list.GetSize(false), real_thread_list.GetSize(false),
	new_thread_list.GetSize(0), m_process->GetID());
	uint64_t allglen = m_allglen_sp->GetValueAsUnsigned(0);
	if (allglen == 0) {
	return new_thread_list.GetSize(false) > 0;
	}
	std::vector<Goroutine> goroutines;
	// The threads that are in "new_thread_list" upon entry are the threads from
	// the lldb_private::Process subclass, no memory threads will be in this
	// list.

	Status err;
	for (uint64_t i = 0; i < allglen; ++i) {
	goroutines.push_back(CreateGoroutineAtIndex(i, err));
	if (err.Fail()) {
	LLDB_LOG(log, "error: {0}", err);
	return new_thread_list.GetSize(false) > 0;
	}
	}
	// Make a map so we can match goroutines with backing threads.
	std::map<uint64_t, ThreadSP> stack_map;
	for (uint32_t i = 0; i < real_thread_list.GetSize(false); ++i) {
	ThreadSP thread = real_thread_list.GetThreadAtIndex(i, false);
	stack_map[thread->GetRegisterContext()->GetSP()] = thread;
	}
	for (const Goroutine &goroutine : goroutines) {
	if (0 /* Gidle */ == goroutine.m_status \|\|
	6 /* Gdead */ == goroutine.m_status) {
	continue;
	}
	ThreadSP memory_thread =
	old_thread_list.FindThreadByID(goroutine.m_goid, false);
	if (memory_thread && IsOperatingSystemPluginThread(memory_thread) &&
	memory_thread->IsValid()) {
	memory_thread->ClearBackingThread();
	} else {
	memory_thread.reset(new ThreadMemory(*m_process, goroutine.m_goid, "", "",
	goroutine.m_gobuf));
	}
	// Search for the backing thread if the goroutine is running.
	if (2 == (goroutine.m_status & 0xfff)) {
	auto backing_it = stack_map.lower_bound(goroutine.m_lostack);
	if (backing_it != stack_map.end()) {
	if (goroutine.m_histack >= backing_it->first) {
	if (log)
	log->Printf(
	"OperatingSystemGo::UpdateThreadList found backing thread "
	"%" PRIx64 " (%" PRIx64 ") for thread %" PRIx64 "",
	backing_it->second->GetID(),
	backing_it->second->GetProtocolID(), memory_thread->GetID());
	memory_thread->SetBackingThread(backing_it->second);
	new_thread_list.RemoveThreadByID(backing_it->second->GetID(), false);
	}
	}
	}
	new_thread_list.AddThread(memory_thread);
	}

	return new_thread_list.GetSize(false) > 0;
	}

	void OperatingSystemGo::ThreadWasSelected(Thread *thread) {}

	RegisterContextSP
	OperatingSystemGo::CreateRegisterContextForThread(Thread *thread,
	addr_t reg_data_addr) {
	RegisterContextSP reg_ctx_sp;
	if (!thread)
	return reg_ctx_sp;

	if (!IsOperatingSystemPluginThread(thread->shared_from_this()))
	return reg_ctx_sp;

	reg_ctx_sp.reset(
	new RegisterContextGo(thread, 0, m_reginfo, reg_data_addr));
	return reg_ctx_sp;
	}

	StopInfoSP
	OperatingSystemGo::CreateThreadStopReason(lldb_private::Thread *thread) {
	StopInfoSP stop_info_sp;
	return stop_info_sp;
	}

	lldb::ThreadSP OperatingSystemGo::CreateThread(lldb::tid_t tid,
	addr_t context) {
	Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));

	if (log)
	log->Printf("OperatingSystemGo::CreateThread (tid = 0x%" PRIx64
	", context = 0x%" PRIx64 ") not implemented",
	tid, context);

	return ThreadSP();
	}

	ValueObjectSP OperatingSystemGo::FindGlobal(TargetSP target, const char *name) {
	VariableList variable_list;

	Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));

	if (log) {
	log->Printf(
	"exe: %s",
	target->GetExecutableModule()->GetSpecificationDescription().c_str());
	log->Printf("modules: %zu", target->GetImages().GetSize());
	}

	uint32_t match_count = target->GetImages().FindGlobalVariables(
	ConstString(name), 1, variable_list);
	if (match_count > 0) {
	ExecutionContextScope *exe_scope = target->GetProcessSP().get();
	if (exe_scope == NULL)
	exe_scope = target.get();
	return ValueObjectVariable::Create(exe_scope,
	variable_list.GetVariableAtIndex(0));
	}
	return ValueObjectSP();
	}

	TypeSP OperatingSystemGo::FindType(TargetSP target_sp, const char *name) {
	ConstString const_typename(name);
	SymbolContext sc;
	const bool exact_match = false;

	const ModuleList &module_list = target_sp->GetImages();
	size_t count = module_list.GetSize();
	for (size_t idx = 0; idx < count; idx++) {
	ModuleSP module_sp(module_list.GetModuleAtIndex(idx));
	if (module_sp) {
	TypeSP type_sp(module_sp->FindFirstType(sc, const_typename, exact_match));
	if (type_sp)
	return type_sp;
	}
	}
	Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));

	if (log)
	log->Printf("OperatingSystemGo::FindType(%s): not found", name);
	return TypeSP();
	}

	OperatingSystemGo::Goroutine
	OperatingSystemGo::CreateGoroutineAtIndex(uint64_t idx, Status &err) {
	err.Clear();
	Goroutine result = {};
	ValueObjectSP g =
	m_allg_sp->GetSyntheticArrayMember(idx, true)->Dereference(err);
	if (err.Fail()) {
	return result;
	}

	ConstString name("goid");
	ValueObjectSP val = g->GetChildMemberWithName(name, true);
	bool success = false;
	result.m_goid = val->GetValueAsUnsigned(0, &success);
	if (!success) {
	err.SetErrorToGenericError();
	err.SetErrorString("unable to read goid");
	return result;
	}
	name.SetCString("atomicstatus");
	val = g->GetChildMemberWithName(name, true);
	result.m_status = (uint32_t)val->GetValueAsUnsigned(0, &success);
	if (!success) {
	err.SetErrorToGenericError();
	err.SetErrorString("unable to read atomicstatus");
	return result;
	}
	name.SetCString("sched");
	val = g->GetChildMemberWithName(name, true);
	result.m_gobuf = val->GetAddressOf(false);
	name.SetCString("stack");
	val = g->GetChildMemberWithName(name, true);
	name.SetCString("lo");
	ValueObjectSP child = val->GetChildMemberWithName(name, true);
	result.m_lostack = child->GetValueAsUnsigned(0, &success);
	if (!success) {
	err.SetErrorToGenericError();
	err.SetErrorString("unable to read stack.lo");
	return result;
	}
	name.SetCString("hi");
	child = val->GetChildMemberWithName(name, true);
	result.m_histack = child->GetValueAsUnsigned(0, &success);
	if (!success) {
	err.SetErrorToGenericError();
	err.SetErrorString("unable to read stack.hi");
	return result;
	}
	return result;
	}

source/Plugins/SymbolFile/DWARF/CMakeLists.txt

	add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN			add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
	AppleDWARFIndex.cpp			AppleDWARFIndex.cpp
	DebugNamesDWARFIndex.cpp			DebugNamesDWARFIndex.cpp
	DIERef.cpp			DIERef.cpp
	DWARFAbbreviationDeclaration.cpp			DWARFAbbreviationDeclaration.cpp
	DWARFASTParserClang.cpp			DWARFASTParserClang.cpp
	DWARFASTParserGo.cpp
	DWARFASTParserJava.cpp			DWARFASTParserJava.cpp
	DWARFASTParserOCaml.cpp			DWARFASTParserOCaml.cpp
	DWARFAttribute.cpp			DWARFAttribute.cpp
	DWARFBaseDIE.cpp			DWARFBaseDIE.cpp
	DWARFCompileUnit.cpp			DWARFCompileUnit.cpp
	DWARFDataExtractor.cpp			DWARFDataExtractor.cpp
	DWARFDebugAbbrev.cpp			DWARFDebugAbbrev.cpp
	DWARFDebugAranges.cpp			DWARFDebugAranges.cpp
	▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h

This file was deleted.

	//===-- DWARFASTParserGo.h --------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef SymbolFileDWARF_DWARFASTParserGo_h_
	#define SymbolFileDWARF_DWARFASTParserGo_h_

	// C Includes
	// C++ Includes
	// Other libraries and framework includes
	#include "llvm/ADT/DenseMap.h"
	#include "llvm/ADT/SmallPtrSet.h"
	#include "llvm/ADT/SmallVector.h"

	// Project includes
	#include "DWARFASTParser.h"
	#include "DWARFDIE.h"
	#include "DWARFDefines.h"
	#include "lldb/Core/PluginInterface.h"
	#include "lldb/Symbol/GoASTContext.h"

	class DWARFDebugInfoEntry;
	class DWARFDIECollection;

	class DWARFASTParserGo : public DWARFASTParser {
	public:
	DWARFASTParserGo(lldb_private::GoASTContext &ast);

	~DWARFASTParserGo() override;

	lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
	const DWARFDIE &die, lldb_private::Log *log,
	bool *type_is_new_ptr) override;

	lldb_private::Function *
	ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
	const DWARFDIE &die) override;

	bool CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
	lldb_private::CompilerType &go_type) override;

	lldb_private::CompilerDeclContext
	GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override {
	return lldb_private::CompilerDeclContext();
	}

	lldb_private::CompilerDeclContext
	GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) override {
	return lldb_private::CompilerDeclContext();
	}

	lldb_private::CompilerDecl
	GetDeclForUIDFromDWARF(const DWARFDIE &die) override {
	return lldb_private::CompilerDecl();
	}

	std::vector<DWARFDIE> GetDIEForDeclContext(
	lldb_private::CompilerDeclContext decl_context) override {
	return std::vector<DWARFDIE>();
	}

	private:
	size_t ParseChildParameters(
	const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die,
	bool &is_variadic,
	std::vector<lldb_private::CompilerType> &function_param_types);
	void ParseChildArrayInfo(const lldb_private::SymbolContext &sc,
	const DWARFDIE &parent_die, int64_t &first_index,
	std::vector<uint64_t> &element_orders,
	uint32_t &byte_stride, uint32_t &bit_stride);

	size_t ParseChildMembers(const lldb_private::SymbolContext &sc,
	const DWARFDIE &die,
	lldb_private::CompilerType &class_compiler_type);

	lldb_private::GoASTContext &m_ast;
	};

	#endif // SymbolFileDWARF_DWARFASTParserGo_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp

This file was deleted.

	//===-- DWARFASTParserGo.cpp ---------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "DWARFASTParserGo.h"

	#include "DWARFASTParserGo.h"
	#include "DWARFDIE.h"
	#include "DWARFDIECollection.h"
	#include "DWARFDebugInfo.h"
	#include "DWARFDeclContext.h"
	#include "DWARFDefines.h"
	#include "SymbolFileDWARF.h"
	#include "SymbolFileDWARFDebugMap.h"
	#include "UniqueDWARFASTType.h"

	#include "clang/Basic/Specifiers.h"

	#include "lldb/Core/Module.h"
	#include "lldb/Core/Value.h"
	#include "lldb/Symbol/CompileUnit.h"
	#include "lldb/Symbol/Function.h"
	#include "lldb/Symbol/ObjectFile.h"
	#include "lldb/Symbol/TypeList.h"

	//#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN

	#ifdef ENABLE_DEBUG_PRINTF
	#include <stdio.h>
	#define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
	#else
	#define DEBUG_PRINTF(fmt, ...)
	#endif

	#define DW_AT_go_kind 0x2900
	#define DW_AT_go_key 0x2901
	#define DW_AT_go_elem 0x2902

	using namespace lldb;
	using namespace lldb_private;
	DWARFASTParserGo::DWARFASTParserGo(GoASTContext &ast) : m_ast(ast) {}

	DWARFASTParserGo::~DWARFASTParserGo() {}

	TypeSP DWARFASTParserGo::ParseTypeFromDWARF(
	const lldb_private::SymbolContext &sc, const DWARFDIE &die,
	lldb_private::Log log, bool type_is_new_ptr) {
	TypeSP type_sp;

	if (type_is_new_ptr)
	*type_is_new_ptr = false;

	if (die) {
	SymbolFileDWARF *dwarf = die.GetDWARF();
	if (log) {
	dwarf->GetObjectFile()->GetModule()->LogMessage(
	log, "DWARFASTParserGo::ParseTypeFromDWARF (die = 0x%8.8x) %s name = "
	"'%s')",
	die.GetOffset(), DW_TAG_value_to_name(die.Tag()), die.GetName());
	}

	Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE());
	TypeList *type_list = dwarf->GetTypeList();
	if (type_ptr == NULL) {
	if (type_is_new_ptr)
	*type_is_new_ptr = true;

	const dw_tag_t tag = die.Tag();

	bool is_forward_declaration = false;
	DWARFAttributes attributes;
	const char *type_name_cstr = NULL;
	ConstString type_name_const_str;
	Type::ResolveState resolve_state = Type::eResolveStateUnresolved;
	uint64_t byte_size = 0;
	uint64_t go_kind = 0;
	Declaration decl;

	Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
	CompilerType compiler_type;
	DWARFFormValue form_value;

	dw_attr_t attr;

	switch (tag) {
	case DW_TAG_base_type:
	case DW_TAG_pointer_type:
	case DW_TAG_typedef:
	case DW_TAG_unspecified_type: {
	// Set a bit that lets us know that we are currently parsing this
	dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;

	const size_t num_attributes = die.GetAttributes(attributes);
	lldb::user_id_t encoding_uid = LLDB_INVALID_UID;

	if (num_attributes > 0) {
	uint32_t i;
	for (i = 0; i < num_attributes; ++i) {
	attr = attributes.AttributeAtIndex(i);
	if (attributes.ExtractFormValueAtIndex(i, form_value)) {
	switch (attr) {
	case DW_AT_name:
	type_name_cstr = form_value.AsCString();
	if (type_name_cstr)
	type_name_const_str.SetCString(type_name_cstr);
	break;
	case DW_AT_byte_size:
	byte_size = form_value.Unsigned();
	break;
	case DW_AT_encoding:
	// = form_value.Unsigned();
	break;
	case DW_AT_type:
	encoding_uid = form_value.Reference();
	break;
	case DW_AT_go_kind:
	go_kind = form_value.Unsigned();
	break;
	default:
	// Do we care about DW_AT_go_key or DW_AT_go_elem?
	break;
	}
	}
	}
	}

	DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n",
	die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr,
	encoding_uid);

	switch (tag) {
	default:
	break;

	case DW_TAG_unspecified_type:
	resolve_state = Type::eResolveStateFull;
	compiler_type = m_ast.CreateVoidType(type_name_const_str);
	break;

	case DW_TAG_base_type:
	resolve_state = Type::eResolveStateFull;
	compiler_type =
	m_ast.CreateBaseType(go_kind, type_name_const_str, byte_size);
	break;

	case DW_TAG_pointer_type:
	encoding_data_type = Type::eEncodingIsPointerUID;
	break;
	case DW_TAG_typedef:
	encoding_data_type = Type::eEncodingIsTypedefUID;
	CompilerType impl;
	Type *type = dwarf->ResolveTypeUID(encoding_uid);
	if (type) {
	if (go_kind == 0 && type->GetName() == type_name_const_str) {
	// Go emits extra typedefs as a forward declaration. Ignore
	// these.
	dwarf->m_die_to_type[die.GetDIE()] = type;
	return type->shared_from_this();
	}
	impl = type->GetForwardCompilerType();
	compiler_type =
	m_ast.CreateTypedefType(go_kind, type_name_const_str, impl);
	}
	break;
	}

	type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
	byte_size, NULL, encoding_uid,
	encoding_data_type, &decl, compiler_type,
	resolve_state));

	dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
	} break;

	case DW_TAG_structure_type: {
	// Set a bit that lets us know that we are currently parsing this
	dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
	bool byte_size_valid = false;

	const size_t num_attributes = die.GetAttributes(attributes);
	if (num_attributes > 0) {
	uint32_t i;
	for (i = 0; i < num_attributes; ++i) {
	attr = attributes.AttributeAtIndex(i);
	if (attributes.ExtractFormValueAtIndex(i, form_value)) {
	switch (attr) {
	case DW_AT_name:
	type_name_cstr = form_value.AsCString();
	type_name_const_str.SetCString(type_name_cstr);
	break;

	case DW_AT_byte_size:
	byte_size = form_value.Unsigned();
	byte_size_valid = true;
	break;

	case DW_AT_go_kind:
	go_kind = form_value.Unsigned();
	break;

	// TODO: Should we use SLICETYPE's DW_AT_go_elem?
	default:
	break;
	}
	}
	}
	}

	// TODO(ribrdb): Do we need this?

	// UniqueDWARFASTType is large, so don't create a local variables on
	// the stack, put it on the heap. This function is often called
	// recursively and clang isn't good and sharing the stack space for
	// variables in different blocks.
	std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap(
	new UniqueDWARFASTType());

	// Only try and unique the type if it has a name.
	if (type_name_const_str &&
	dwarf->GetUniqueDWARFASTTypeMap().Find(
	type_name_const_str, die, decl,
	byte_size_valid ? byte_size : -1, *unique_ast_entry_ap)) {
	// We have already parsed this type or from another compile unit. GCC
	// loves to use the "one definition rule" which can result in
	// multiple definitions of the same class over and over in each
	// compile unit.
	type_sp = unique_ast_entry_ap->m_type_sp;
	if (type_sp) {
	dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
	return type_sp;
	}
	}

	DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
	DW_TAG_value_to_name(tag), type_name_cstr);

	bool compiler_type_was_created = false;
	compiler_type.SetCompilerType(
	&m_ast,
	dwarf->m_forward_decl_die_to_clang_type.lookup(die.GetDIE()));
	if (!compiler_type) {
	compiler_type_was_created = true;
	compiler_type =
	m_ast.CreateStructType(go_kind, type_name_const_str, byte_size);
	}

	type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
	byte_size, NULL, LLDB_INVALID_UID,
	Type::eEncodingIsUID, &decl, compiler_type,
	Type::eResolveStateForward));

	// Add our type to the unique type map so we don't end up creating many
	// copies of the same type over and over in the ASTContext for our
	// module
	unique_ast_entry_ap->m_type_sp = type_sp;
	unique_ast_entry_ap->m_die = die;
	unique_ast_entry_ap->m_declaration = decl;
	unique_ast_entry_ap->m_byte_size = byte_size;
	dwarf->GetUniqueDWARFASTTypeMap().Insert(type_name_const_str,
	*unique_ast_entry_ap);

	if (!is_forward_declaration) {
	// Always start the definition for a class type so that if the class
	// has child classes or types that require the class to be created
	// for use as their decl contexts the class will be ready to accept
	// these child definitions.
	if (die.HasChildren() == false) {
	// No children for this struct/union/class, lets finish it
	m_ast.CompleteStructType(compiler_type);
	} else if (compiler_type_was_created) {
	// Leave this as a forward declaration until we need to know the
	// details of the type. lldb_private::Type will automatically call
	// the SymbolFile virtual function
	// "SymbolFileDWARF::CompleteType(Type *)" When the definition
	// needs to be defined.
	dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] =
	compiler_type.GetOpaqueQualType();
	dwarf->m_forward_decl_clang_type_to_die[compiler_type
	.GetOpaqueQualType()] =
	die.GetDIERef();
	// SetHasExternalStorage (compiler_type.GetOpaqueQualType(), true);
	}
	}
	} break;

	case DW_TAG_subprogram:
	case DW_TAG_subroutine_type: {
	// Set a bit that lets us know that we are currently parsing this
	dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;

	bool is_variadic = false;
	clang::StorageClass storage =
	clang::SC_None; //, Extern, Static, PrivateExtern

	const size_t num_attributes = die.GetAttributes(attributes);
	if (num_attributes > 0) {
	uint32_t i;
	for (i = 0; i < num_attributes; ++i) {
	attr = attributes.AttributeAtIndex(i);
	if (attributes.ExtractFormValueAtIndex(i, form_value)) {
	switch (attr) {
	case DW_AT_name:
	type_name_cstr = form_value.AsCString();
	type_name_const_str.SetCString(type_name_cstr);
	break;

	case DW_AT_external:
	if (form_value.Unsigned()) {
	if (storage == clang::SC_None)
	storage = clang::SC_Extern;
	else
	storage = clang::SC_PrivateExtern;
	}
	break;

	case DW_AT_high_pc:
	case DW_AT_low_pc:
	break;
	}
	}
	}
	}

	DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
	DW_TAG_value_to_name(tag), type_name_cstr);

	std::vector<CompilerType> function_param_types;

	// Parse the function children for the parameters

	if (die.HasChildren()) {
	ParseChildParameters(sc, die, is_variadic, function_param_types);
	}

	// compiler_type will get the function prototype clang type after this
	// call
	compiler_type = m_ast.CreateFunctionType(
	type_name_const_str, function_param_types.data(),
	function_param_types.size(), is_variadic);

	type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str, 0, NULL,
	LLDB_INVALID_UID, Type::eEncodingIsUID, &decl,
	compiler_type, Type::eResolveStateFull));
	assert(type_sp.get());
	} break;

	case DW_TAG_array_type: {
	// Set a bit that lets us know that we are currently parsing this
	dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;

	lldb::user_id_t type_die_offset = DW_INVALID_OFFSET;
	int64_t first_index = 0;
	uint32_t byte_stride = 0;
	uint32_t bit_stride = 0;
	const size_t num_attributes = die.GetAttributes(attributes);

	if (num_attributes > 0) {
	uint32_t i;
	for (i = 0; i < num_attributes; ++i) {
	attr = attributes.AttributeAtIndex(i);
	if (attributes.ExtractFormValueAtIndex(i, form_value)) {
	switch (attr) {
	case DW_AT_name:
	type_name_cstr = form_value.AsCString();
	type_name_const_str.SetCString(type_name_cstr);
	break;

	case DW_AT_type:
	type_die_offset = form_value.Reference();
	break;
	case DW_AT_byte_size:
	break; // byte_size = form_value.Unsigned(); break;
	case DW_AT_go_kind:
	go_kind = form_value.Unsigned();
	break;
	default:
	break;
	}
	}
	}

	DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
	DW_TAG_value_to_name(tag), type_name_cstr);

	Type *element_type = dwarf->ResolveTypeUID(type_die_offset);

	if (element_type) {
	std::vector<uint64_t> element_orders;
	ParseChildArrayInfo(sc, die, first_index, element_orders,
	byte_stride, bit_stride);
	if (byte_stride == 0)
	byte_stride = element_type->GetByteSize();
	CompilerType array_element_type =
	element_type->GetForwardCompilerType();
	if (element_orders.size() > 0) {
	if (element_orders.size() > 1)
	printf("golang: unsupported multi-dimensional array %s\n",
	type_name_cstr);
	compiler_type = m_ast.CreateArrayType(
	type_name_const_str, array_element_type, element_orders[0]);
	} else {
	compiler_type = m_ast.CreateArrayType(type_name_const_str,
	array_element_type, 0);
	}
	type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
	byte_stride, NULL, type_die_offset,
	Type::eEncodingIsUID, &decl, compiler_type,
	Type::eResolveStateFull));
	type_sp->SetEncodingType(element_type);
	}
	}
	} break;

	default:
	dwarf->GetObjectFile()->GetModule()->ReportError(
	"{0x%8.8x}: unhandled type tag 0x%4.4x (%s), "
	"please file a bug and attach the file at the "
	"start of this error message",
	die.GetOffset(), tag, DW_TAG_value_to_name(tag));
	break;
	}

	if (type_sp.get()) {
	DWARFDIE sc_parent_die =
	SymbolFileDWARF::GetParentSymbolContextDIE(die);
	dw_tag_t sc_parent_tag = sc_parent_die.Tag();

	SymbolContextScope *symbol_context_scope = NULL;
	if (sc_parent_tag == DW_TAG_compile_unit \|\|
	sc_parent_tag == DW_TAG_partial_unit) {
	symbol_context_scope = sc.comp_unit;
	} else if (sc.function != NULL && sc_parent_die) {
	symbol_context_scope =
	sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
	if (symbol_context_scope == NULL)
	symbol_context_scope = sc.function;
	}

	if (symbol_context_scope != NULL) {
	type_sp->SetSymbolContextScope(symbol_context_scope);
	}

	// We are ready to put this type into the uniqued list up at the module
	// level
	type_list->Insert(type_sp);

	dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
	}
	} else if (type_ptr != DIE_IS_BEING_PARSED) {
	type_sp = type_ptr->shared_from_this();
	}
	}
	return type_sp;
	}

	size_t DWARFASTParserGo::ParseChildParameters(
	const SymbolContext &sc,

	const DWARFDIE &parent_die, bool &is_variadic,
	std::vector<CompilerType> &function_param_types) {
	if (!parent_die)
	return 0;

	size_t arg_idx = 0;
	for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
	die = die.GetSibling()) {

	dw_tag_t tag = die.Tag();
	switch (tag) {
	case DW_TAG_formal_parameter: {
	DWARFAttributes attributes;
	const size_t num_attributes = die.GetAttributes(attributes);
	if (num_attributes > 0) {
	Declaration decl;
	DWARFFormValue param_type_die_offset;

	uint32_t i;
	for (i = 0; i < num_attributes; ++i) {
	const dw_attr_t attr = attributes.AttributeAtIndex(i);
	DWARFFormValue form_value;
	if (attributes.ExtractFormValueAtIndex(i, form_value)) {
	switch (attr) {
	case DW_AT_name:
	// = form_value.AsCString();
	break;
	case DW_AT_type:
	param_type_die_offset = form_value;
	break;
	case DW_AT_location:
	// if (form_value.BlockData())
	// {
	// const DWARFDataExtractor&
	// debug_info_data =
	// debug_info();
	// uint32_t block_length =
	// form_value.Unsigned();
	// DWARFDataExtractor
	// location(debug_info_data,
	// form_value.BlockData() -
	// debug_info_data.GetDataStart(),
	// block_length);
	// }
	// else
	// {
	// }
	// break;
	default:
	break;
	}
	}
	}

	Type *type = parent_die.ResolveTypeUID(DIERef(param_type_die_offset));
	if (type) {
	function_param_types.push_back(type->GetForwardCompilerType());
	}
	}
	arg_idx++;
	} break;

	case DW_TAG_unspecified_parameters:
	is_variadic = true;
	break;

	default:
	break;
	}
	}
	return arg_idx;
	}

	void DWARFASTParserGo::ParseChildArrayInfo(
	const SymbolContext &sc, const DWARFDIE &parent_die, int64_t &first_index,
	std::vector<uint64_t> &element_orders, uint32_t &byte_stride,
	uint32_t &bit_stride) {
	if (!parent_die)
	return;

	for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
	die = die.GetSibling()) {
	const dw_tag_t tag = die.Tag();
	switch (tag) {
	case DW_TAG_subrange_type: {
	DWARFAttributes attributes;
	const size_t num_child_attributes = die.GetAttributes(attributes);
	if (num_child_attributes > 0) {
	uint64_t num_elements = 0;
	uint32_t i;
	for (i = 0; i < num_child_attributes; ++i) {
	const dw_attr_t attr = attributes.AttributeAtIndex(i);
	DWARFFormValue form_value;
	if (attributes.ExtractFormValueAtIndex(i, form_value)) {
	switch (attr) {
	case DW_AT_count:
	num_elements = form_value.Unsigned();
	break;

	default:
	case DW_AT_type:
	break;
	}
	}
	}

	element_orders.push_back(num_elements);
	}
	} break;
	}
	}
	}

	bool DWARFASTParserGo::CompleteTypeFromDWARF(const DWARFDIE &die,
	lldb_private::Type *type,
	CompilerType &compiler_type) {
	if (!die)
	return false;

	const dw_tag_t tag = die.Tag();

	SymbolFileDWARF *dwarf = die.GetDWARF();
	Log *log =
	nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO\|DWARF_LOG_TYPE_COMPLETION));
	if (log)
	dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
	log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
	die.GetID(), DW_TAG_value_to_name(tag), type->GetName().AsCString());
	assert(compiler_type);
	DWARFAttributes attributes;

	switch (tag) {
	case DW_TAG_structure_type: {
	{
	if (die.HasChildren()) {
	SymbolContext sc(die.GetLLDBCompileUnit());

	ParseChildMembers(sc, die, compiler_type);
	}
	}
	m_ast.CompleteStructType(compiler_type);
	return (bool)compiler_type;
	}

	default:
	assert(false && "not a forward go type decl!");
	break;
	}

	return false;
	}

	size_t DWARFASTParserGo::ParseChildMembers(const SymbolContext &sc,
	const DWARFDIE &parent_die,
	CompilerType &class_compiler_type) {
	size_t count = 0;
	uint32_t member_idx = 0;

	ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
	GoASTContext *ast =
	llvm::dyn_cast_or_null<GoASTContext>(class_compiler_type.GetTypeSystem());
	if (ast == nullptr)
	return 0;

	for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
	die = die.GetSibling()) {
	dw_tag_t tag = die.Tag();

	switch (tag) {
	case DW_TAG_member: {
	DWARFAttributes attributes;
	const size_t num_attributes = die.GetAttributes(attributes);
	if (num_attributes > 0) {
	Declaration decl;
	const char *name = NULL;

	DWARFFormValue encoding_uid;
	uint32_t member_byte_offset = UINT32_MAX;
	uint32_t i;
	for (i = 0; i < num_attributes; ++i) {
	const dw_attr_t attr = attributes.AttributeAtIndex(i);
	DWARFFormValue form_value;
	if (attributes.ExtractFormValueAtIndex(i, form_value)) {
	switch (attr) {
	case DW_AT_name:
	name = form_value.AsCString();
	break;
	case DW_AT_type:
	encoding_uid = form_value;
	break;
	case DW_AT_data_member_location:
	if (form_value.BlockData()) {
	Value initialValue(0);
	Value memberOffset(0);
	const DWARFDataExtractor &debug_info_data = die.GetData();
	uint32_t block_length = form_value.Unsigned();
	uint32_t block_offset =
	form_value.BlockData() - debug_info_data.GetDataStart();
	if (DWARFExpression::Evaluate(
	NULL, // ExecutionContext *
	NULL, // RegisterContext *
	module_sp, debug_info_data, die.GetCU(), block_offset,
	block_length, eRegisterKindDWARF, &initialValue, NULL,
	memberOffset, NULL)) {
	member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
	}
	} else {
	// With DWARF 3 and later, if the value is an integer constant,
	// this form value is the offset in bytes from the beginning of
	// the containing entity.
	member_byte_offset = form_value.Unsigned();
	}
	break;

	default:
	break;
	}
	}
	}

	Type *member_type = die.ResolveTypeUID(DIERef(encoding_uid));
	if (member_type) {
	CompilerType member_go_type = member_type->GetFullCompilerType();
	ConstString name_const_str(name);
	m_ast.AddFieldToStruct(class_compiler_type, name_const_str,
	member_go_type, member_byte_offset);
	}
	}
	++member_idx;
	} break;

	default:
	break;
	}
	}

	return count;
	}

	Function *DWARFASTParserGo::ParseFunctionFromDWARF(const SymbolContext &sc,
	const DWARFDIE &die) {
	DWARFRangeList func_ranges;
	const char *name = NULL;
	const char *mangled = NULL;
	int decl_file = 0;
	int decl_line = 0;
	int decl_column = 0;
	int call_file = 0;
	int call_line = 0;
	int call_column = 0;
	DWARFExpression frame_base(die.GetCU());

	assert(die.Tag() == DW_TAG_subprogram);

	if (die.Tag() != DW_TAG_subprogram)
	return NULL;

	if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
	decl_column, call_file, call_line, call_column,
	&frame_base)) {
	// Union of all ranges in the function DIE (if the function is
	// discontiguous)
	AddressRange func_range;
	lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase(0);
	lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd(0);
	if (lowest_func_addr != LLDB_INVALID_ADDRESS &&
	lowest_func_addr <= highest_func_addr) {
	ModuleSP module_sp(die.GetModule());
	func_range.GetBaseAddress().ResolveAddressUsingFileSections(
	lowest_func_addr, module_sp->GetSectionList());
	if (func_range.GetBaseAddress().IsValid())
	func_range.SetByteSize(highest_func_addr - lowest_func_addr);
	}

	if (func_range.GetBaseAddress().IsValid()) {
	Mangled func_name;
	func_name.SetValue(ConstString(name), false);

	FunctionSP func_sp;
	std::unique_ptr<Declaration> decl_ap;
	if (decl_file != 0 \|\| decl_line != 0 \|\| decl_column != 0)
	decl_ap.reset(new Declaration(
	sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
	decl_line, decl_column));

	SymbolFileDWARF *dwarf = die.GetDWARF();
	// Supply the type _only_ if it has already been parsed
	Type *func_type = dwarf->m_die_to_type.lookup(die.GetDIE());

	assert(func_type == NULL \|\| func_type != DIE_IS_BEING_PARSED);

	if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
	const user_id_t func_user_id = die.GetID();
	func_sp.reset(new Function(sc.comp_unit,
	func_user_id, // UserID is the DIE offset
	func_user_id, func_name, func_type,
	func_range)); // first address range

	if (func_sp.get() != NULL) {
	if (frame_base.IsValid())
	func_sp->GetFrameBaseExpression() = frame_base;
	sc.comp_unit->AddFunction(func_sp);
	return func_sp.get();
	}
	}
	}
	}
	return NULL;
	}

source/Symbol/CMakeLists.txt

Show All 10 Lines	add_lldb_library(lldbSymbol
CompilerType.cpp		CompilerType.cpp
CompileUnit.cpp		CompileUnit.cpp
CompactUnwindInfo.cpp		CompactUnwindInfo.cpp
DebugMacros.cpp		DebugMacros.cpp
Declaration.cpp		Declaration.cpp
DWARFCallFrameInfo.cpp		DWARFCallFrameInfo.cpp
Function.cpp		Function.cpp
FuncUnwinders.cpp		FuncUnwinders.cpp
GoASTContext.cpp
JavaASTContext.cpp		JavaASTContext.cpp
LineEntry.cpp		LineEntry.cpp
LineTable.cpp		LineTable.cpp
ObjectFile.cpp		ObjectFile.cpp
OCamlASTContext.cpp		OCamlASTContext.cpp
Symbol.cpp		Symbol.cpp
SymbolContext.cpp		SymbolContext.cpp
SymbolFile.cpp		SymbolFile.cpp
SymbolVendor.cpp		SymbolVendor.cpp
Symtab.cpp		Symtab.cpp
Type.cpp		Type.cpp
TypeList.cpp		TypeList.cpp
TypeMap.cpp		TypeMap.cpp
TypeSystem.cpp		TypeSystem.cpp
UnwindPlan.cpp		UnwindPlan.cpp
UnwindTable.cpp		UnwindTable.cpp
Variable.cpp		Variable.cpp
VariableList.cpp		VariableList.cpp
VerifyDecl.cpp		VerifyDecl.cpp

LINK_LIBS		LINK_LIBS
clangAST		clangAST
clangBasic		clangBasic
clangFrontend		clangFrontend
lldbCore		lldbCore
lldbExpression		lldbExpression
lldbHost		lldbHost
lldbTarget		lldbTarget
lldbUtility		lldbUtility
lldbPluginExpressionParserClang		lldbPluginExpressionParserClang
lldbPluginExpressionParserGo
lldbPluginSymbolFileDWARF		lldbPluginSymbolFileDWARF
lldbPluginSymbolFilePDB		lldbPluginSymbolFilePDB
lldbPluginCPlusPlusLanguage		lldbPluginCPlusPlusLanguage
lldbPluginObjCLanguage		lldbPluginObjCLanguage

LINK_COMPONENTS		LINK_COMPONENTS
Support		Support
)		)

source/Symbol/GoASTContext.cpp

This file was deleted.

	//===-- GoASTContext.cpp ----------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include <mutex>
	#include <utility>
	#include <vector>

	#include "lldb/Core/DumpDataExtractor.h"
	#include "lldb/Core/Module.h"
	#include "lldb/Core/PluginManager.h"
	#include "lldb/Core/StreamFile.h"
	#include "lldb/Core/UniqueCStringMap.h"
	#include "lldb/Core/ValueObject.h"
	#include "lldb/Symbol/CompilerType.h"
	#include "lldb/Symbol/GoASTContext.h"
	#include "lldb/Symbol/ObjectFile.h"
	#include "lldb/Symbol/SymbolFile.h"
	#include "lldb/Symbol/Type.h"
	#include "lldb/Target/ExecutionContext.h"
	#include "lldb/Target/Target.h"

	#include "llvm/Support/Threading.h"

	#include "Plugins/ExpressionParser/Go/GoUserExpression.h"
	#include "Plugins/SymbolFile/DWARF/DWARFASTParserGo.h"

	using namespace lldb;

	namespace lldb_private {
	class GoArray;
	class GoFunction;
	class GoStruct;

	class GoType {
	public:
	enum {
	KIND_BOOL = 1,
	KIND_INT = 2,
	KIND_INT8 = 3,
	KIND_INT16 = 4,
	KIND_INT32 = 5,
	KIND_INT64 = 6,
	KIND_UINT = 7,
	KIND_UINT8 = 8,
	KIND_UINT16 = 9,
	KIND_UINT32 = 10,
	KIND_UINT64 = 11,
	KIND_UINTPTR = 12,
	KIND_FLOAT32 = 13,
	KIND_FLOAT64 = 14,
	KIND_COMPLEX64 = 15,
	KIND_COMPLEX128 = 16,
	KIND_ARRAY = 17,
	KIND_CHAN = 18,
	KIND_FUNC = 19,
	KIND_INTERFACE = 20,
	KIND_MAP = 21,
	KIND_PTR = 22,
	KIND_SLICE = 23,
	KIND_STRING = 24,
	KIND_STRUCT = 25,
	KIND_UNSAFEPOINTER = 26,
	KIND_LLDB_VOID, // Extension for LLDB, not used by go runtime.
	KIND_MASK = (1 << 5) - 1,
	KIND_DIRECT_IFACE = 1 << 5
	};
	GoType(int kind, const ConstString &name)
	: m_kind(kind & KIND_MASK), m_name(name) {
	if (m_kind == KIND_FUNC)
	m_kind = KIND_FUNC;
	}
	virtual ~GoType() {}

	int GetGoKind() const { return m_kind; }
	const ConstString &GetName() const { return m_name; }
	virtual CompilerType GetElementType() const { return CompilerType(); }

	bool IsTypedef() const {
	switch (m_kind) {
	case KIND_CHAN:
	case KIND_MAP:
	case KIND_INTERFACE:
	return true;
	default:
	return false;
	}
	}

	GoArray *GetArray();
	GoFunction *GetFunction();
	GoStruct *GetStruct();

	private:
	int m_kind;
	ConstString m_name;
	GoType(const GoType &) = delete;
	const GoType &operator=(const GoType &) = delete;
	};

	class GoElem : public GoType {
	public:
	GoElem(int kind, const ConstString &name, const CompilerType &elem)
	: GoType(kind, name), m_elem(elem) {}
	virtual CompilerType GetElementType() const { return m_elem; }

	private:
	// TODO: should we store this differently?
	CompilerType m_elem;

	GoElem(const GoElem &) = delete;
	const GoElem &operator=(const GoElem &) = delete;
	};

	class GoArray : public GoElem {
	public:
	GoArray(const ConstString &name, uint64_t length, const CompilerType &elem)
	: GoElem(KIND_ARRAY, name, elem), m_length(length) {}

	uint64_t GetLength() const { return m_length; }

	private:
	uint64_t m_length;
	GoArray(const GoArray &) = delete;
	const GoArray &operator=(const GoArray &) = delete;
	};

	class GoFunction : public GoType {
	public:
	GoFunction(const ConstString &name, bool is_variadic)
	: GoType(KIND_FUNC, name), m_is_variadic(is_variadic) {}

	bool IsVariadic() const { return m_is_variadic; }

	private:
	bool m_is_variadic;
	GoFunction(const GoFunction &) = delete;
	const GoFunction &operator=(const GoFunction &) = delete;
	};

	class GoStruct : public GoType {
	public:
	struct Field {
	Field(const ConstString &name, const CompilerType &type, uint64_t offset)
	: m_name(name), m_type(type), m_byte_offset(offset) {}
	ConstString m_name;
	CompilerType m_type;
	uint64_t m_byte_offset;
	};

	GoStruct(int kind, const ConstString &name, int64_t byte_size)
	: GoType(kind == 0 ? KIND_STRUCT : kind, name), m_is_complete(false),
	m_byte_size(byte_size) {}

	uint32_t GetNumFields() const { return m_fields.size(); }

	const Field *GetField(uint32_t i) const {
	if (i < m_fields.size())
	return &m_fields[i];
	return nullptr;
	}

	void AddField(const ConstString &name, const CompilerType &type,
	uint64_t offset) {
	m_fields.push_back(Field(name, type, offset));
	}

	bool IsComplete() const { return m_is_complete; }

	void SetComplete() { m_is_complete = true; }

	int64_t GetByteSize() const { return m_byte_size; }

	private:
	bool m_is_complete;
	int64_t m_byte_size;
	std::vector<Field> m_fields;

	GoStruct(const GoStruct &) = delete;
	const GoStruct &operator=(const GoStruct &) = delete;
	};

	GoArray *GoType::GetArray() {
	if (m_kind == KIND_ARRAY) {
	return static_cast<GoArray *>(this);
	}
	return nullptr;
	}

	GoFunction *GoType::GetFunction() {
	if (m_kind == KIND_FUNC) {
	return static_cast<GoFunction *>(this);
	}
	return nullptr;
	}

	GoStruct *GoType::GetStruct() {
	switch (m_kind) {
	case KIND_STRING:
	case KIND_STRUCT:
	case KIND_SLICE:
	return static_cast<GoStruct *>(this);
	}
	return nullptr;
	}
	} // namespace lldb_private
	using namespace lldb_private;

	GoASTContext::GoASTContext()
	: TypeSystem(eKindGo), m_pointer_byte_size(0), m_int_byte_size(0),
	m_types(new TypeMap) {}
	GoASTContext::~GoASTContext() {}

	//------------------------------------------------------------------
	// PluginInterface functions
	//------------------------------------------------------------------

	ConstString GoASTContext::GetPluginNameStatic() { return ConstString("go"); }

	ConstString GoASTContext::GetPluginName() {
	return GoASTContext::GetPluginNameStatic();
	}

	uint32_t GoASTContext::GetPluginVersion() { return 1; }

	lldb::TypeSystemSP GoASTContext::CreateInstance(lldb::LanguageType language,
	Module *module,
	Target *target) {
	if (language == eLanguageTypeGo) {
	ArchSpec arch;
	std::shared_ptr<GoASTContext> go_ast_sp;
	if (module) {
	arch = module->GetArchitecture();
	go_ast_sp = std::shared_ptr<GoASTContext>(new GoASTContext);
	} else if (target) {
	arch = target->GetArchitecture();
	go_ast_sp = std::shared_ptr<GoASTContextForExpr>(
	new GoASTContextForExpr(target->shared_from_this()));
	}

	if (arch.IsValid()) {
	go_ast_sp->SetAddressByteSize(arch.GetAddressByteSize());
	return go_ast_sp;
	}
	}
	return lldb::TypeSystemSP();
	}

	void GoASTContext::EnumerateSupportedLanguages(
	std::set<lldb::LanguageType> &languages_for_types,
	std::set<lldb::LanguageType> &languages_for_expressions) {
	static std::vector<lldb::LanguageType> s_supported_languages_for_types(
	{lldb::eLanguageTypeGo});

	static std::vector<lldb::LanguageType> s_supported_languages_for_expressions(
	{});

	languages_for_types.insert(s_supported_languages_for_types.begin(),
	s_supported_languages_for_types.end());
	languages_for_expressions.insert(
	s_supported_languages_for_expressions.begin(),
	s_supported_languages_for_expressions.end());
	}

	void GoASTContext::Initialize() {
	PluginManager::RegisterPlugin(GetPluginNameStatic(), "AST context plug-in",
	CreateInstance, EnumerateSupportedLanguages);
	}

	void GoASTContext::Terminate() {
	PluginManager::UnregisterPlugin(CreateInstance);
	}

	//----------------------------------------------------------------------
	// Tests
	//----------------------------------------------------------------------

	bool GoASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
	CompilerType element_type, uint64_t size,
	bool *is_incomplete) {
	if (element_type)
	element_type->Clear();
	if (size)
	*size = 0;
	if (is_incomplete)
	*is_incomplete = false;
	GoArray array = static_cast<GoType >(type)->GetArray();
	if (array) {
	if (size)
	*size = array->GetLength();
	if (element_type)
	*element_type = array->GetElementType();
	return true;
	}
	return false;
	}

	bool GoASTContext::IsVectorType(lldb::opaque_compiler_type_t type,
	CompilerType element_type, uint64_t size) {
	if (element_type)
	element_type->Clear();
	if (size)
	*size = 0;
	return false;
	}

	bool GoASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
	int kind = static_cast<GoType *>(type)->GetGoKind();
	if (kind < GoType::KIND_ARRAY)
	return false;
	if (kind == GoType::KIND_PTR)
	return false;
	if (kind == GoType::KIND_CHAN)
	return false;
	if (kind == GoType::KIND_MAP)
	return false;
	if (kind == GoType::KIND_STRING)
	return false;
	if (kind == GoType::KIND_UNSAFEPOINTER)
	return false;
	return true;
	}

	bool GoASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
	return false;
	}

	bool GoASTContext::IsCharType(lldb::opaque_compiler_type_t type) {
	// Go's DWARF doesn't distinguish between rune and int32.
	return false;
	}

	bool GoASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) {
	if (!type)
	return false;
	GoType t = static_cast<GoType >(type);
	if (GoStruct *s = t->GetStruct())
	return s->IsComplete();
	if (t->IsTypedef() \|\| t->GetGoKind() == GoType::KIND_PTR)
	return t->GetElementType().IsCompleteType();
	return true;
	}

	bool GoASTContext::IsConst(lldb::opaque_compiler_type_t type) { return false; }

	bool GoASTContext::IsCStringType(lldb::opaque_compiler_type_t type,
	uint32_t &length) {
	return false;
	}

	bool GoASTContext::IsDefined(lldb::opaque_compiler_type_t type) {
	return type != nullptr;
	}

	bool GoASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type,
	uint32_t &count, bool &is_complex) {
	int kind = static_cast<GoType *>(type)->GetGoKind();
	if (kind >= GoType::KIND_FLOAT32 && kind <= GoType::KIND_COMPLEX128) {
	if (kind >= GoType::KIND_COMPLEX64) {
	is_complex = true;
	count = 2;
	} else {
	is_complex = false;
	count = 1;
	}
	return true;
	}
	count = 0;
	is_complex = false;
	return false;
	}

	bool GoASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
	bool *is_variadic_ptr) {
	GoFunction func = static_cast<GoType >(type)->GetFunction();
	if (func) {
	if (is_variadic_ptr)
	*is_variadic_ptr = func->IsVariadic();
	return true;
	}
	if (is_variadic_ptr)
	*is_variadic_ptr = false;
	return false;
	}

	uint32_t GoASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
	CompilerType *base_type_ptr) {
	return false;
	}

	size_t
	GoASTContext::GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) {
	return 0;
	}

	CompilerType
	GoASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
	const size_t index) {
	return CompilerType();
	}

	bool GoASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
	return IsFunctionType(type);
	}

	bool GoASTContext::IsBlockPointerType(lldb::opaque_compiler_type_t type,
	CompilerType *function_pointer_type_ptr) {
	return false;
	}

	bool GoASTContext::IsIntegerType(lldb::opaque_compiler_type_t type,
	bool &is_signed) {
	is_signed = false;
	// TODO: Is bool an integer?
	if (type) {
	int kind = static_cast<GoType *>(type)->GetGoKind();
	if (kind <= GoType::KIND_UINTPTR) {
	is_signed = (kind != GoType::KIND_BOOL) & (kind <= GoType::KIND_INT64);
	return true;
	}
	}
	return false;
	}

	bool GoASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
	return false;
	}

	bool GoASTContext::IsPossibleDynamicType(
	lldb::opaque_compiler_type_t type,
	CompilerType *target_type, // Can pass NULL
	bool check_cplusplus, bool check_objc) {
	if (target_type)
	target_type->Clear();
	if (type)
	return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_INTERFACE;
	return false;
	}

	bool GoASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) {
	return false;
	}

	bool GoASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
	CompilerType *pointee_type) {
	if (!type)
	return false;
	GoType t = static_cast<GoType >(type);
	if (pointee_type) {
	*pointee_type = t->GetElementType();
	}
	switch (t->GetGoKind()) {
	case GoType::KIND_PTR:
	case GoType::KIND_UNSAFEPOINTER:
	case GoType::KIND_CHAN:
	case GoType::KIND_MAP:
	// TODO: is function a pointer?
	return true;
	default:
	return false;
	}
	}

	bool GoASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
	CompilerType *pointee_type) {
	return IsPointerType(type, pointee_type);
	}

	bool GoASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
	CompilerType *pointee_type,
	bool *is_rvalue) {
	return false;
	}

	bool GoASTContext::IsScalarType(lldb::opaque_compiler_type_t type) {
	return !IsAggregateType(type);
	}

	bool GoASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) {
	if (type)
	return static_cast<GoType *>(type)->IsTypedef();
	return false;
	}

	bool GoASTContext::IsVoidType(lldb::opaque_compiler_type_t type) {
	if (!type)
	return false;
	return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_LLDB_VOID;
	}

	bool GoASTContext::SupportsLanguage(lldb::LanguageType language) {
	return language == eLanguageTypeGo;
	}

	//----------------------------------------------------------------------
	// Type Completion
	//----------------------------------------------------------------------

	bool GoASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) {
	if (!type)
	return false;
	GoType t = static_cast<GoType >(type);
	if (t->IsTypedef() \|\| t->GetGoKind() == GoType::KIND_PTR \|\| t->GetArray())
	return t->GetElementType().GetCompleteType();
	if (GoStruct *s = t->GetStruct()) {
	if (s->IsComplete())
	return true;
	CompilerType compiler_type(this, s);
	SymbolFile *symbols = GetSymbolFile();
	return symbols && symbols->CompleteType(compiler_type);
	}
	return true;
	}

	//----------------------------------------------------------------------
	// AST related queries
	//----------------------------------------------------------------------

	uint32_t GoASTContext::GetPointerByteSize() { return m_pointer_byte_size; }

	//----------------------------------------------------------------------
	// Accessors
	//----------------------------------------------------------------------

	ConstString GoASTContext::GetTypeName(lldb::opaque_compiler_type_t type) {
	if (type)
	return static_cast<GoType *>(type)->GetName();
	return ConstString();
	}

	uint32_t
	GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
	CompilerType *pointee_or_element_compiler_type) {
	if (pointee_or_element_compiler_type)
	pointee_or_element_compiler_type->Clear();
	if (!type)
	return 0;
	GoType t = static_cast<GoType >(type);
	if (pointee_or_element_compiler_type)
	*pointee_or_element_compiler_type = t->GetElementType();
	int kind = t->GetGoKind();
	if (kind == GoType::KIND_ARRAY)
	return eTypeHasChildren \| eTypeIsArray;
	if (kind < GoType::KIND_ARRAY) {
	uint32_t builtin_type_flags = eTypeIsBuiltIn \| eTypeHasValue;
	if (kind < GoType::KIND_FLOAT32) {
	builtin_type_flags \|= eTypeIsInteger \| eTypeIsScalar;
	if (kind >= GoType::KIND_INT && kind <= GoType::KIND_INT64)
	builtin_type_flags \|= eTypeIsSigned;
	} else {
	builtin_type_flags \|= eTypeIsFloat;
	if (kind < GoType::KIND_COMPLEX64)
	builtin_type_flags \|= eTypeIsComplex;
	else
	builtin_type_flags \|= eTypeIsScalar;
	}
	return builtin_type_flags;
	}
	if (kind == GoType::KIND_STRING)
	return eTypeHasValue \| eTypeIsBuiltIn;
	if (kind == GoType::KIND_FUNC)
	return eTypeIsFuncPrototype \| eTypeHasValue;
	if (IsPointerType(type))
	return eTypeIsPointer \| eTypeHasValue \| eTypeHasChildren;
	if (kind == GoType::KIND_LLDB_VOID)
	return 0;
	return eTypeHasChildren \| eTypeIsStructUnion;
	}

	lldb::TypeClass GoASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
	if (!type)
	return eTypeClassInvalid;
	int kind = static_cast<GoType *>(type)->GetGoKind();
	if (kind == GoType::KIND_FUNC)
	return eTypeClassFunction;
	if (IsPointerType(type))
	return eTypeClassPointer;
	if (kind < GoType::KIND_COMPLEX64)
	return eTypeClassBuiltin;
	if (kind <= GoType::KIND_COMPLEX128)
	return eTypeClassComplexFloat;
	if (kind == GoType::KIND_LLDB_VOID)
	return eTypeClassInvalid;
	return eTypeClassStruct;
	}

	lldb::BasicType
	GoASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
	ConstString name = GetTypeName(type);
	if (name) {
	typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
	static TypeNameToBasicTypeMap g_type_map;
	static llvm::once_flag g_once_flag;
	llvm::call_once(g_once_flag, []() {
	// "void"
	g_type_map.Append(ConstString("void"), eBasicTypeVoid);
	// "int"
	g_type_map.Append(ConstString("int"), eBasicTypeInt);
	g_type_map.Append(ConstString("uint"), eBasicTypeUnsignedInt);

	// Miscellaneous
	g_type_map.Append(ConstString("bool"), eBasicTypeBool);

	// Others. Should these map to C types?
	g_type_map.Append(ConstString("byte"), eBasicTypeOther);
	g_type_map.Append(ConstString("uint8"), eBasicTypeOther);
	g_type_map.Append(ConstString("uint16"), eBasicTypeOther);
	g_type_map.Append(ConstString("uint32"), eBasicTypeOther);
	g_type_map.Append(ConstString("uint64"), eBasicTypeOther);
	g_type_map.Append(ConstString("int8"), eBasicTypeOther);
	g_type_map.Append(ConstString("int16"), eBasicTypeOther);
	g_type_map.Append(ConstString("int32"), eBasicTypeOther);
	g_type_map.Append(ConstString("int64"), eBasicTypeOther);
	g_type_map.Append(ConstString("float32"), eBasicTypeOther);
	g_type_map.Append(ConstString("float64"), eBasicTypeOther);
	g_type_map.Append(ConstString("uintptr"), eBasicTypeOther);

	g_type_map.Sort();
	});

	return g_type_map.Find(name, eBasicTypeInvalid);
	}
	return eBasicTypeInvalid;
	}

	lldb::LanguageType
	GoASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
	return lldb::eLanguageTypeGo;
	}

	unsigned GoASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
	return 0;
	}

	//----------------------------------------------------------------------
	// Creating related types
	//----------------------------------------------------------------------

	CompilerType
	GoASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type,
	uint64_t *stride) {
	GoArray array = static_cast<GoType >(type)->GetArray();
	if (array) {
	if (stride) {
	*stride = array->GetElementType().GetByteSize(nullptr);
	}
	return array->GetElementType();
	}
	return CompilerType();
	}

	CompilerType GoASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) {
	GoType t = static_cast<GoType >(type);
	if (t->IsTypedef())
	return t->GetElementType();
	return CompilerType(this, type);
	}

	CompilerType
	GoASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
	return CompilerType(this, type);
	}

	// Returns -1 if this isn't a function of if the function doesn't have a
	// prototype Returns a value >= 0 if there is a prototype.
	int GoASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) {
	return GetNumberOfFunctionArguments(type);
	}

	CompilerType
	GoASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
	size_t idx) {
	return GetFunctionArgumentAtIndex(type, idx);
	}

	CompilerType
	GoASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
	CompilerType result;
	if (type) {
	GoType t = static_cast<GoType >(type);
	if (t->GetGoKind() == GoType::KIND_FUNC)
	result = t->GetElementType();
	}
	return result;
	}

	size_t GoASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
	return 0;
	}

	TypeMemberFunctionImpl
	GoASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
	size_t idx) {
	return TypeMemberFunctionImpl();
	}

	CompilerType
	GoASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
	return CompilerType(this, type);
	}

	CompilerType GoASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) {
	if (!type)
	return CompilerType();
	return static_cast<GoType *>(type)->GetElementType();
	}

	CompilerType GoASTContext::GetPointerType(lldb::opaque_compiler_type_t type) {
	if (!type)
	return CompilerType();
	ConstString type_name = GetTypeName(type);
	ConstString pointer_name(std::string("*") + type_name.GetCString());
	GoType pointer = (m_types)[pointer_name].get();
	if (pointer == nullptr) {
	pointer =
	new GoElem(GoType::KIND_PTR, pointer_name, CompilerType(this, type));
	(*m_types)[pointer_name].reset(pointer);
	}
	return CompilerType(this, pointer);
	}

	// If the current object represents a typedef type, get the underlying type
	CompilerType GoASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
	if (IsTypedefType(type))
	return static_cast<GoType *>(type)->GetElementType();
	return CompilerType();
	}

	//----------------------------------------------------------------------
	// Create related types using the current type's AST
	//----------------------------------------------------------------------
	CompilerType GoASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
	return CompilerType();
	}

	CompilerType
	GoASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
	size_t bit_size) {
	return CompilerType();
	}

	//----------------------------------------------------------------------
	// Exploring the type
	//----------------------------------------------------------------------

	uint64_t GoASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
	ExecutionContextScope *exe_scope) {
	if (!type)
	return 0;
	if (!GetCompleteType(type))
	return 0;
	GoType t = static_cast<GoType >(type);
	GoArray *array = nullptr;
	switch (t->GetGoKind()) {
	case GoType::KIND_BOOL:
	case GoType::KIND_INT8:
	case GoType::KIND_UINT8:
	return 8;
	case GoType::KIND_INT16:
	case GoType::KIND_UINT16:
	return 16;
	case GoType::KIND_INT32:
	case GoType::KIND_UINT32:
	case GoType::KIND_FLOAT32:
	return 32;
	case GoType::KIND_INT64:
	case GoType::KIND_UINT64:
	case GoType::KIND_FLOAT64:
	case GoType::KIND_COMPLEX64:
	return 64;
	case GoType::KIND_COMPLEX128:
	return 128;
	case GoType::KIND_INT:
	case GoType::KIND_UINT:
	return m_int_byte_size * 8;
	case GoType::KIND_UINTPTR:
	case GoType::KIND_FUNC: // I assume this is a pointer?
	case GoType::KIND_CHAN:
	case GoType::KIND_PTR:
	case GoType::KIND_UNSAFEPOINTER:
	case GoType::KIND_MAP:
	return m_pointer_byte_size * 8;
	case GoType::KIND_ARRAY:
	array = t->GetArray();
	return array->GetLength() * array->GetElementType().GetBitSize(exe_scope);
	case GoType::KIND_INTERFACE:
	return t->GetElementType().GetBitSize(exe_scope);
	case GoType::KIND_SLICE:
	case GoType::KIND_STRING:
	case GoType::KIND_STRUCT:
	return t->GetStruct()->GetByteSize() * 8;
	default:
	assert(false);
	}
	return 0;
	}

	lldb::Encoding GoASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
	uint64_t &count) {
	count = 1;
	bool is_signed;
	if (IsIntegerType(type, is_signed))
	return is_signed ? lldb::eEncodingSint : eEncodingUint;
	bool is_complex;
	uint32_t complex_count;
	if (IsFloatingPointType(type, complex_count, is_complex)) {
	count = complex_count;
	return eEncodingIEEE754;
	}
	if (IsPointerType(type))
	return eEncodingUint;
	return eEncodingInvalid;
	}

	lldb::Format GoASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
	if (!type)
	return eFormatDefault;
	switch (static_cast<GoType *>(type)->GetGoKind()) {
	case GoType::KIND_BOOL:
	return eFormatBoolean;
	case GoType::KIND_INT:
	case GoType::KIND_INT8:
	case GoType::KIND_INT16:
	case GoType::KIND_INT32:
	case GoType::KIND_INT64:
	return eFormatDecimal;
	case GoType::KIND_UINT:
	case GoType::KIND_UINT8:
	case GoType::KIND_UINT16:
	case GoType::KIND_UINT32:
	case GoType::KIND_UINT64:
	return eFormatUnsigned;
	case GoType::KIND_FLOAT32:
	case GoType::KIND_FLOAT64:
	return eFormatFloat;
	case GoType::KIND_COMPLEX64:
	case GoType::KIND_COMPLEX128:
	return eFormatComplexFloat;
	case GoType::KIND_UINTPTR:
	case GoType::KIND_CHAN:
	case GoType::KIND_PTR:
	case GoType::KIND_MAP:
	case GoType::KIND_UNSAFEPOINTER:
	return eFormatHex;
	case GoType::KIND_STRING:
	return eFormatCString;
	case GoType::KIND_ARRAY:
	case GoType::KIND_INTERFACE:
	case GoType::KIND_SLICE:
	case GoType::KIND_STRUCT:
	default:
	// Don't know how to display this.
	return eFormatBytes;
	}
	}

	size_t GoASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
	return 0;
	}

	uint32_t GoASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
	bool omit_empty_base_classes) {
	if (!type \|\| !GetCompleteType(type))
	return 0;
	GoType t = static_cast<GoType >(type);
	if (t->GetGoKind() == GoType::KIND_PTR) {
	CompilerType elem = t->GetElementType();
	if (elem.IsAggregateType())
	return elem.GetNumChildren(omit_empty_base_classes);
	return 1;
	} else if (GoArray *array = t->GetArray()) {
	return array->GetLength();
	} else if (t->IsTypedef()) {
	return t->GetElementType().GetNumChildren(omit_empty_base_classes);
	}

	return GetNumFields(type);
	}

	uint32_t GoASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
	if (!type \|\| !GetCompleteType(type))
	return 0;
	GoType t = static_cast<GoType >(type);
	if (t->IsTypedef())
	return t->GetElementType().GetNumFields();
	GoStruct *s = t->GetStruct();
	if (s)
	return s->GetNumFields();
	return 0;
	}

	CompilerType GoASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
	size_t idx, std::string &name,
	uint64_t *bit_offset_ptr,
	uint32_t *bitfield_bit_size_ptr,
	bool *is_bitfield_ptr) {
	if (bit_offset_ptr)
	*bit_offset_ptr = 0;
	if (bitfield_bit_size_ptr)
	*bitfield_bit_size_ptr = 0;
	if (is_bitfield_ptr)
	*is_bitfield_ptr = false;

	if (!type \|\| !GetCompleteType(type))
	return CompilerType();

	GoType t = static_cast<GoType >(type);
	if (t->IsTypedef())
	return t->GetElementType().GetFieldAtIndex(
	idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr);

	GoStruct *s = t->GetStruct();
	if (s) {
	const auto *field = s->GetField(idx);
	if (field) {
	name = field->m_name.GetStringRef();
	if (bit_offset_ptr)
	bit_offset_ptr = field->m_byte_offset 8;
	return field->m_type;
	}
	}
	return CompilerType();
	}

	CompilerType GoASTContext::GetChildCompilerTypeAtIndex(
	lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
	bool transparent_pointers, bool omit_empty_base_classes,
	bool ignore_array_bounds, std::string &child_name,
	uint32_t &child_byte_size, int32_t &child_byte_offset,
	uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
	bool &child_is_base_class, bool &child_is_deref_of_parent,
	ValueObject *valobj, uint64_t &language_flags) {
	child_name.clear();
	child_byte_size = 0;
	child_byte_offset = 0;
	child_bitfield_bit_size = 0;
	child_bitfield_bit_offset = 0;
	child_is_base_class = false;
	child_is_deref_of_parent = false;
	language_flags = 0;

	if (!type \|\| !GetCompleteType(type))
	return CompilerType();

	GoType t = static_cast<GoType >(type);
	if (t->GetStruct()) {
	uint64_t bit_offset;
	CompilerType ret =
	GetFieldAtIndex(type, idx, child_name, &bit_offset, nullptr, nullptr);
	child_byte_size = ret.GetByteSize(
	exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
	child_byte_offset = bit_offset / 8;
	return ret;
	} else if (t->GetGoKind() == GoType::KIND_PTR) {
	CompilerType pointee = t->GetElementType();
	if (!pointee.IsValid() \|\| pointee.IsVoidType())
	return CompilerType();
	if (transparent_pointers && pointee.IsAggregateType()) {
	bool tmp_child_is_deref_of_parent = false;
	return pointee.GetChildCompilerTypeAtIndex(
	exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
	ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
	child_bitfield_bit_size, child_bitfield_bit_offset,
	child_is_base_class, tmp_child_is_deref_of_parent, valobj,
	language_flags);
	} else {
	child_is_deref_of_parent = true;
	const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
	if (parent_name) {
	child_name.assign(1, '*');
	child_name += parent_name;
	}

	// We have a pointer to an simple type
	if (idx == 0 && pointee.GetCompleteType()) {
	child_byte_size = pointee.GetByteSize(
	exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
	child_byte_offset = 0;
	return pointee;
	}
	}
	} else if (GoArray *a = t->GetArray()) {
	if (ignore_array_bounds \|\| idx < a->GetLength()) {
	CompilerType element_type = a->GetElementType();
	if (element_type.GetCompleteType()) {
	char element_name[64];
	::snprintf(element_name, sizeof(element_name), "[%zu]", idx);
	child_name.assign(element_name);
	child_byte_size = element_type.GetByteSize(
	exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
	child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
	return element_type;
	}
	}
	} else if (t->IsTypedef()) {
	return t->GetElementType().GetChildCompilerTypeAtIndex(
	exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
	ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
	child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
	child_is_deref_of_parent, valobj, language_flags);
	}
	return CompilerType();
	}

	// Lookup a child given a name. This function will match base class names and
	// member member names in "clang_type" only, not descendants.
	uint32_t
	GoASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
	const char *name,
	bool omit_empty_base_classes) {
	if (!type \|\| !GetCompleteType(type))
	return UINT_MAX;

	GoType t = static_cast<GoType >(type);
	GoStruct *s = t->GetStruct();
	if (s) {
	for (uint32_t i = 0; i < s->GetNumFields(); ++i) {
	const GoStruct::Field *f = s->GetField(i);
	if (f->m_name.GetStringRef() == name)
	return i;
	}
	} else if (t->GetGoKind() == GoType::KIND_PTR \|\| t->IsTypedef()) {
	return t->GetElementType().GetIndexOfChildWithName(name,
	omit_empty_base_classes);
	}
	return UINT_MAX;
	}

	// Lookup a child member given a name. This function will match member names
	// only and will descend into "clang_type" children in search for the first
	// member in this class, or any base class that matches "name".
	// TODO: Return all matches for a given name by returning a
	// vector<vector<uint32_t>>
	// so we catch all names that match a given child name, not just the first.
	size_t GoASTContext::GetIndexOfChildMemberWithName(
	lldb::opaque_compiler_type_t type, const char *name,
	bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
	uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes);
	if (index == UINT_MAX)
	return 0;
	child_indexes.push_back(index);
	return 1;
	}

	// Converts "s" to a floating point value and place resulting floating point
	// bytes in the "dst" buffer.
	size_t
	GoASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
	const char s, uint8_t dst,
	size_t dst_size) {
	assert(false);
	return 0;
	}
	//----------------------------------------------------------------------
	// Dumping types
	//----------------------------------------------------------------------
	#define DEPTH_INCREMENT 2

	void GoASTContext::DumpValue(lldb::opaque_compiler_type_t type,
	ExecutionContext exe_ctx, Stream s,
	lldb::Format format, const DataExtractor &data,
	lldb::offset_t data_byte_offset,
	size_t data_byte_size, uint32_t bitfield_bit_size,
	uint32_t bitfield_bit_offset, bool show_types,
	bool show_summary, bool verbose, uint32_t depth) {
	if (IsTypedefType(type))
	type = GetTypedefedType(type).GetOpaqueQualType();
	if (!type)
	return;
	GoType t = static_cast<GoType >(type);

	if (GoStruct *st = t->GetStruct()) {
	if (GetCompleteType(type)) {
	uint32_t field_idx = 0;
	for (auto *field = st->GetField(field_idx); field != nullptr;
	field_idx++) {
	// Print the starting squiggly bracket (if this is the first member) or
	// comma (for member 2 and beyond) for the struct/union/class member.
	if (field_idx == 0)
	s->PutChar('{');
	else
	s->PutChar(',');

	// Indent
	s->Printf("\n%*s", depth + DEPTH_INCREMENT, "");

	// Print the member type if requested
	if (show_types) {
	ConstString field_type_name = field->m_type.GetTypeName();
	s->Printf("(%s) ", field_type_name.AsCString());
	}
	// Print the member name and equal sign
	s->Printf("%s = ", field->m_name.AsCString());

	// Dump the value of the member
	CompilerType field_type = field->m_type;
	field_type.DumpValue(
	exe_ctx,
	s, // Stream to dump to
	field_type
	.GetFormat(), // The format with which to display the member
	data, // Data buffer containing all bytes for this type
	data_byte_offset + field->m_byte_offset, // Offset into "data" where
	// to grab value from
	field->m_type.GetByteSize(
	exe_ctx->GetBestExecutionContextScope()), // Size of this type
	// in bytes
	0, // Bitfield bit size
	0, // Bitfield bit offset
	show_types, // Boolean indicating if we should show the variable
	// types
	show_summary, // Boolean indicating if we should show a summary for
	// the current type
	verbose, // Verbose output?
	depth + DEPTH_INCREMENT); // Scope depth for any types that have
	// children
	}

	// Indent the trailing squiggly bracket
	if (field_idx > 0)
	s->Printf("\n%*s}", depth, "");
	}
	}

	if (GoArray *a = t->GetArray()) {
	CompilerType element_clang_type = a->GetElementType();
	lldb::Format element_format = element_clang_type.GetFormat();
	uint32_t element_byte_size =
	element_clang_type.GetByteSize(exe_ctx->GetBestExecutionContextScope());

	uint64_t element_idx;
	for (element_idx = 0; element_idx < a->GetLength(); ++element_idx) {
	// Print the starting squiggly bracket (if this is the first member) or
	// comman (for member 2 and beyong) for the struct/union/class member.
	if (element_idx == 0)
	s->PutChar('{');
	else
	s->PutChar(',');

	// Indent and print the index
	s->Printf("\n%*s[%" PRIu64 "] ", depth + DEPTH_INCREMENT, "",
	element_idx);

	// Figure out the field offset within the current struct/union/class type
	uint64_t element_offset = element_idx * element_byte_size;

	// Dump the value of the member
	element_clang_type.DumpValue(
	exe_ctx,
	s, // Stream to dump to
	element_format, // The format with which to display the element
	data, // Data buffer containing all bytes for this type
	data_byte_offset +
	element_offset, // Offset into "data" where to grab value from
	element_byte_size, // Size of this type in bytes
	0, // Bitfield bit size
	0, // Bitfield bit offset
	show_types, // Boolean indicating if we should show the variable types
	show_summary, // Boolean indicating if we should show a summary for
	// the current type
	verbose, // Verbose output?
	depth +
	DEPTH_INCREMENT); // Scope depth for any types that have children
	}

	// Indent the trailing squiggly bracket
	if (element_idx > 0)
	s->Printf("\n%*s}", depth, "");
	}

	if (show_summary)
	DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
	}

	bool GoASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
	lldb::Format format, const DataExtractor &data,
	lldb::offset_t byte_offset, size_t byte_size,
	uint32_t bitfield_bit_size,
	uint32_t bitfield_bit_offset,
	ExecutionContextScope *exe_scope) {
	if (!type)
	return false;
	if (IsAggregateType(type)) {
	return false;
	} else {
	GoType t = static_cast<GoType >(type);
	if (t->IsTypedef()) {
	CompilerType typedef_compiler_type = t->GetElementType();
	if (format == eFormatDefault)
	format = typedef_compiler_type.GetFormat();
	uint64_t typedef_byte_size = typedef_compiler_type.GetByteSize(exe_scope);

	return typedef_compiler_type.DumpTypeValue(
	s,
	format, // The format with which to display the element
	data, // Data buffer containing all bytes for this type
	byte_offset, // Offset into "data" where to grab value from
	typedef_byte_size, // Size of this type in bytes
	bitfield_bit_size, // Size in bits of a bitfield value, if zero don't
	// treat as a bitfield
	bitfield_bit_offset, // Offset in bits of a bitfield value if
	// bitfield_bit_size != 0
	exe_scope);
	}

	uint32_t item_count = 1;
	// A few formats, we might need to modify our size and count for depending
	// on how we are trying to display the value...
	switch (format) {
	default:
	case eFormatBoolean:
	case eFormatBinary:
	case eFormatComplex:
	case eFormatCString: // NULL terminated C strings
	case eFormatDecimal:
	case eFormatEnum:
	case eFormatHex:
	case eFormatHexUppercase:
	case eFormatFloat:
	case eFormatOctal:
	case eFormatOSType:
	case eFormatUnsigned:
	case eFormatPointer:
	case eFormatVectorOfChar:
	case eFormatVectorOfSInt8:
	case eFormatVectorOfUInt8:
	case eFormatVectorOfSInt16:
	case eFormatVectorOfUInt16:
	case eFormatVectorOfSInt32:
	case eFormatVectorOfUInt32:
	case eFormatVectorOfSInt64:
	case eFormatVectorOfUInt64:
	case eFormatVectorOfFloat32:
	case eFormatVectorOfFloat64:
	case eFormatVectorOfUInt128:
	break;

	case eFormatChar:
	case eFormatCharPrintable:
	case eFormatCharArray:
	case eFormatBytes:
	case eFormatBytesWithASCII:
	item_count = byte_size;
	byte_size = 1;
	break;

	case eFormatUnicode16:
	item_count = byte_size / 2;
	byte_size = 2;
	break;

	case eFormatUnicode32:
	item_count = byte_size / 4;
	byte_size = 4;
	break;
	}
	return DumpDataExtractor(data, s, byte_offset, format, byte_size,
	item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
	bitfield_bit_size, bitfield_bit_offset, exe_scope);
	}
	return 0;
	}

	void GoASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
	ExecutionContext exe_ctx, Stream s,
	const DataExtractor &data,
	lldb::offset_t data_offset,
	size_t data_byte_size) {
	if (type && GoType::KIND_STRING == static_cast<GoType *>(type)->GetGoKind()) {
	// TODO(ribrdb): read length and data
	}
	}

	void GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
	// Dump to stdout
	StreamFile s(stdout, false);
	DumpTypeDescription(type, &s);
	}

	void GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type,
	Stream *s) {
	if (!type)
	return;
	ConstString name = GetTypeName(type);
	GoType t = static_cast<GoType >(type);

	if (GoStruct *st = t->GetStruct()) {
	if (GetCompleteType(type)) {
	if (NULL == strchr(name.AsCString(), '{'))
	s->Printf("type %s ", name.AsCString());
	s->PutCString("struct {");
	if (st->GetNumFields() == 0) {
	s->PutChar('}');
	return;
	}
	s->IndentMore();
	uint32_t field_idx = 0;
	for (auto *field = st->GetField(field_idx); field != nullptr;
	field_idx++) {
	s->PutChar('\n');
	s->Indent();
	s->Printf("%s %s", field->m_name.AsCString(),
	field->m_type.GetTypeName().AsCString());
	}
	s->IndentLess();
	s->PutChar('\n');
	s->Indent("}");
	return;
	}
	}

	s->PutCString(name.AsCString());
	}

	CompilerType GoASTContext::CreateArrayType(const ConstString &name,
	const CompilerType &element_type,
	uint64_t length) {
	GoType *type = new GoArray(name, length, element_type);
	(*m_types)[name].reset(type);
	return CompilerType(this, type);
	}

	CompilerType GoASTContext::CreateBaseType(int go_kind,
	const lldb_private::ConstString &name,
	uint64_t byte_size) {
	if (go_kind == GoType::KIND_UINT \|\| go_kind == GoType::KIND_INT)
	m_int_byte_size = byte_size;
	GoType *type = new GoType(go_kind, name);
	(*m_types)[name].reset(type);
	return CompilerType(this, type);
	}

	CompilerType GoASTContext::CreateTypedefType(int kind, const ConstString &name,
	CompilerType impl) {
	GoType *type = new GoElem(kind, name, impl);
	(*m_types)[name].reset(type);
	return CompilerType(this, type);
	}

	CompilerType
	GoASTContext::CreateVoidType(const lldb_private::ConstString &name) {
	GoType *type = new GoType(GoType::KIND_LLDB_VOID, name);
	(*m_types)[name].reset(type);
	return CompilerType(this, type);
	}

	CompilerType
	GoASTContext::CreateStructType(int kind, const lldb_private::ConstString &name,
	uint32_t byte_size) {
	GoType *type = new GoStruct(kind, name, byte_size);
	(*m_types)[name].reset(type);
	return CompilerType(this, type);
	}

	void GoASTContext::AddFieldToStruct(
	const lldb_private::CompilerType &struct_type,
	const lldb_private::ConstString &name,
	const lldb_private::CompilerType &field_type, uint32_t byte_offset) {
	if (!struct_type)
	return;
	GoASTContext *ast =
	llvm::dyn_cast_or_null<GoASTContext>(struct_type.GetTypeSystem());
	if (!ast)
	return;
	GoType type = static_cast<GoType >(struct_type.GetOpaqueQualType());
	if (GoStruct *s = type->GetStruct())
	s->AddField(name, field_type, byte_offset);
	}

	void GoASTContext::CompleteStructType(
	const lldb_private::CompilerType &struct_type) {
	if (!struct_type)
	return;
	GoASTContext *ast =
	llvm::dyn_cast_or_null<GoASTContext>(struct_type.GetTypeSystem());
	if (!ast)
	return;
	GoType type = static_cast<GoType >(struct_type.GetOpaqueQualType());
	if (GoStruct *s = type->GetStruct())
	s->SetComplete();
	}

	CompilerType
	GoASTContext::CreateFunctionType(const lldb_private::ConstString &name,
	CompilerType *params, size_t params_count,
	bool is_variadic) {
	GoType *type = new GoFunction(name, is_variadic);
	(*m_types)[name].reset(type);
	return CompilerType(this, type);
	}

	bool GoASTContext::IsGoString(const lldb_private::CompilerType &type) {
	if (!type.IsValid() \|\|
	!llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
	return false;
	return GoType::KIND_STRING ==
	static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
	}

	bool GoASTContext::IsGoSlice(const lldb_private::CompilerType &type) {
	if (!type.IsValid() \|\|
	!llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
	return false;
	return GoType::KIND_SLICE ==
	static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
	}

	bool GoASTContext::IsGoInterface(const lldb_private::CompilerType &type) {
	if (!type.IsValid() \|\|
	!llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
	return false;
	return GoType::KIND_INTERFACE ==
	static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
	}

	bool GoASTContext::IsPointerKind(uint8_t kind) {
	return (kind & GoType::KIND_MASK) == GoType::KIND_PTR;
	}

	bool GoASTContext::IsDirectIface(uint8_t kind) {
	return (kind & GoType::KIND_DIRECT_IFACE) == GoType::KIND_DIRECT_IFACE;
	}

	DWARFASTParser *GoASTContext::GetDWARFParser() {
	if (!m_dwarf_ast_parser_ap)
	m_dwarf_ast_parser_ap.reset(new DWARFASTParserGo(*this));
	return m_dwarf_ast_parser_ap.get();
	}

	UserExpression *GoASTContextForExpr::GetUserExpression(
	llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
	Expression::ResultType desired_type,
	const EvaluateExpressionOptions &options) {
	TargetSP target = m_target_wp.lock();
	if (target)
	return new GoUserExpression(*target, expr, prefix, language, desired_type,
	options);
	return nullptr;
	}

tools/lldb-test/SystemInitializerTest.cpp

//===-- SystemInitializerTest.cpp -------------------------------- C++ --===//		//===-- SystemInitializerTest.cpp -------------------------------- C++ --===//
//		//
// The LLVM Compiler Infrastructure		// The LLVM Compiler Infrastructure
//		//
// This file is distributed under the University of Illinois Open Source		// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.		// License. See LICENSE.TXT for details.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "SystemInitializerTest.h"		#include "SystemInitializerTest.h"

#include "lldb/Core/Debugger.h"		#include "lldb/Core/Debugger.h"
#include "lldb/Host/Host.h"		#include "lldb/Host/Host.h"
#include "lldb/Initialization/SystemInitializerCommon.h"		#include "lldb/Initialization/SystemInitializerCommon.h"
#include "lldb/Interpreter/CommandInterpreter.h"		#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/ClangASTContext.h"		#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/GoASTContext.h"
#include "lldb/Symbol/JavaASTContext.h"		#include "lldb/Symbol/JavaASTContext.h"
#include "lldb/Symbol/OCamlASTContext.h"		#include "lldb/Symbol/OCamlASTContext.h"
#include "lldb/Utility/Timer.h"		#include "lldb/Utility/Timer.h"

#include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"		#include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"
#include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h"		#include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h"
#include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"		#include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"
#include "Plugins/ABI/SysV-arm/ABISysV_arm.h"		#include "Plugins/ABI/SysV-arm/ABISysV_arm.h"
Show All 17 Lines
#include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"		#include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"
#include "Plugins/Instruction/PPC64/EmulateInstructionPPC64.h"		#include "Plugins/Instruction/PPC64/EmulateInstructionPPC64.h"
#include "Plugins/InstrumentationRuntime/ASan/ASanRuntime.h"		#include "Plugins/InstrumentationRuntime/ASan/ASanRuntime.h"
#include "Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.h"		#include "Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.h"
#include "Plugins/InstrumentationRuntime/TSan/TSanRuntime.h"		#include "Plugins/InstrumentationRuntime/TSan/TSanRuntime.h"
#include "Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h"		#include "Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h"
#include "Plugins/JITLoader/GDB/JITLoaderGDB.h"		#include "Plugins/JITLoader/GDB/JITLoaderGDB.h"
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"		#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
#include "Plugins/Language/Go/GoLanguage.h"
#include "Plugins/Language/Java/JavaLanguage.h"		#include "Plugins/Language/Java/JavaLanguage.h"
#include "Plugins/Language/OCaml/OCamlLanguage.h"		#include "Plugins/Language/OCaml/OCamlLanguage.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h"		#include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"		#include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"
#include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"		#include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"
#include "Plugins/LanguageRuntime/Go/GoLanguageRuntime.h"
#include "Plugins/LanguageRuntime/Java/JavaLanguageRuntime.h"		#include "Plugins/LanguageRuntime/Java/JavaLanguageRuntime.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"		#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"		#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"
#include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"		#include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"
#include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"		#include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"
#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"		#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
#include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"		#include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"		#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
#include "Plugins/OperatingSystem/Go/OperatingSystemGo.h"
#include "Plugins/Platform/Android/PlatformAndroid.h"		#include "Plugins/Platform/Android/PlatformAndroid.h"
#include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"		#include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"
#include "Plugins/Platform/Kalimba/PlatformKalimba.h"		#include "Plugins/Platform/Kalimba/PlatformKalimba.h"
#include "Plugins/Platform/Linux/PlatformLinux.h"		#include "Plugins/Platform/Linux/PlatformLinux.h"
#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"		#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"		#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
#include "Plugins/Platform/NetBSD/PlatformNetBSD.h"		#include "Plugins/Platform/NetBSD/PlatformNetBSD.h"
#include "Plugins/Platform/OpenBSD/PlatformOpenBSD.h"		#include "Plugins/Platform/OpenBSD/PlatformOpenBSD.h"
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines	void SystemInitializerTest::Initialize() {
SystemInitializerCommon::Initialize();		SystemInitializerCommon::Initialize();

ObjectFileELF::Initialize();		ObjectFileELF::Initialize();
ObjectFileMachO::Initialize();		ObjectFileMachO::Initialize();
ObjectFilePECOFF::Initialize();		ObjectFilePECOFF::Initialize();

ScriptInterpreterNone::Initialize();		ScriptInterpreterNone::Initialize();

OperatingSystemGo::Initialize();

platform_freebsd::PlatformFreeBSD::Initialize();		platform_freebsd::PlatformFreeBSD::Initialize();
platform_linux::PlatformLinux::Initialize();		platform_linux::PlatformLinux::Initialize();
platform_netbsd::PlatformNetBSD::Initialize();		platform_netbsd::PlatformNetBSD::Initialize();
platform_openbsd::PlatformOpenBSD::Initialize();		platform_openbsd::PlatformOpenBSD::Initialize();
PlatformWindows::Initialize();		PlatformWindows::Initialize();
PlatformKalimba::Initialize();		PlatformKalimba::Initialize();
platform_android::PlatformAndroid::Initialize();		platform_android::PlatformAndroid::Initialize();
PlatformRemoteiOS::Initialize();		PlatformRemoteiOS::Initialize();
PlatformMacOSX::Initialize();		PlatformMacOSX::Initialize();
#if defined(__APPLE__)		#if defined(__APPLE__)
PlatformiOSSimulator::Initialize();		PlatformiOSSimulator::Initialize();
PlatformDarwinKernel::Initialize();		PlatformDarwinKernel::Initialize();
#endif		#endif

// Initialize LLVM and Clang		// Initialize LLVM and Clang
llvm::InitializeAllTargets();		llvm::InitializeAllTargets();
llvm::InitializeAllAsmPrinters();		llvm::InitializeAllAsmPrinters();
llvm::InitializeAllTargetMCs();		llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();		llvm::InitializeAllDisassemblers();

ClangASTContext::Initialize();		ClangASTContext::Initialize();
GoASTContext::Initialize();
JavaASTContext::Initialize();		JavaASTContext::Initialize();
OCamlASTContext::Initialize();		OCamlASTContext::Initialize();

ABIMacOSX_i386::Initialize();		ABIMacOSX_i386::Initialize();
ABIMacOSX_arm::Initialize();		ABIMacOSX_arm::Initialize();
ABIMacOSX_arm64::Initialize();		ABIMacOSX_arm64::Initialize();
ABISysV_arm::Initialize();		ABISysV_arm::Initialize();
ABISysV_arm64::Initialize();		ABISysV_arm64::Initialize();
Show All 29 Lines	#endif
EmulateInstructionARM64::Initialize();		EmulateInstructionARM64::Initialize();
EmulateInstructionPPC64::Initialize();		EmulateInstructionPPC64::Initialize();
SymbolFileDWARFDebugMap::Initialize();		SymbolFileDWARFDebugMap::Initialize();
ItaniumABILanguageRuntime::Initialize();		ItaniumABILanguageRuntime::Initialize();
AppleObjCRuntimeV2::Initialize();		AppleObjCRuntimeV2::Initialize();
AppleObjCRuntimeV1::Initialize();		AppleObjCRuntimeV1::Initialize();
SystemRuntimeMacOSX::Initialize();		SystemRuntimeMacOSX::Initialize();
RenderScriptRuntime::Initialize();		RenderScriptRuntime::Initialize();
GoLanguageRuntime::Initialize();
JavaLanguageRuntime::Initialize();		JavaLanguageRuntime::Initialize();

CPlusPlusLanguage::Initialize();		CPlusPlusLanguage::Initialize();
GoLanguage::Initialize();
JavaLanguage::Initialize();		JavaLanguage::Initialize();
ObjCLanguage::Initialize();		ObjCLanguage::Initialize();
ObjCPlusPlusLanguage::Initialize();		ObjCPlusPlusLanguage::Initialize();
OCamlLanguage::Initialize();		OCamlLanguage::Initialize();

#if defined(_WIN32)		#if defined(_WIN32)
ProcessWindows::Initialize();		ProcessWindows::Initialize();
#endif		#endif
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines	void SystemInitializerTest::Terminate() {
Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);		Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);

Debugger::SettingsTerminate();		Debugger::SettingsTerminate();

// Terminate and unload and loaded system or user LLDB plug-ins		// Terminate and unload and loaded system or user LLDB plug-ins
PluginManager::Terminate();		PluginManager::Terminate();

ClangASTContext::Terminate();		ClangASTContext::Terminate();
GoASTContext::Terminate();
JavaASTContext::Terminate();		JavaASTContext::Terminate();
OCamlASTContext::Terminate();		OCamlASTContext::Terminate();

ABIMacOSX_i386::Terminate();		ABIMacOSX_i386::Terminate();
ABIMacOSX_arm::Terminate();		ABIMacOSX_arm::Terminate();
ABIMacOSX_arm64::Terminate();		ABIMacOSX_arm64::Terminate();
ABISysV_arm::Terminate();		ABISysV_arm::Terminate();
ABISysV_arm64::Terminate();		ABISysV_arm64::Terminate();
Show All 27 Lines	void SystemInitializerTest::Terminate() {
ItaniumABILanguageRuntime::Terminate();		ItaniumABILanguageRuntime::Terminate();
AppleObjCRuntimeV2::Terminate();		AppleObjCRuntimeV2::Terminate();
AppleObjCRuntimeV1::Terminate();		AppleObjCRuntimeV1::Terminate();
SystemRuntimeMacOSX::Terminate();		SystemRuntimeMacOSX::Terminate();
RenderScriptRuntime::Terminate();		RenderScriptRuntime::Terminate();
JavaLanguageRuntime::Terminate();		JavaLanguageRuntime::Terminate();

CPlusPlusLanguage::Terminate();		CPlusPlusLanguage::Terminate();
GoLanguage::Terminate();
JavaLanguage::Terminate();		JavaLanguage::Terminate();
ObjCLanguage::Terminate();		ObjCLanguage::Terminate();
ObjCPlusPlusLanguage::Terminate();		ObjCPlusPlusLanguage::Terminate();
OCamlLanguage::Terminate();		OCamlLanguage::Terminate();

#if defined(__APPLE__)		#if defined(__APPLE__)
DynamicLoaderDarwinKernel::Terminate();		DynamicLoaderDarwinKernel::Terminate();
ProcessMachCore::Terminate();		ProcessMachCore::Terminate();
Show All 15 Lines	#endif
StructuredDataDarwinLog::Terminate();		StructuredDataDarwinLog::Terminate();

DynamicLoaderMacOSXDYLD::Terminate();		DynamicLoaderMacOSXDYLD::Terminate();
DynamicLoaderMacOS::Terminate();		DynamicLoaderMacOS::Terminate();
DynamicLoaderPOSIXDYLD::Terminate();		DynamicLoaderPOSIXDYLD::Terminate();
DynamicLoaderStatic::Terminate();		DynamicLoaderStatic::Terminate();
DynamicLoaderWindowsDYLD::Terminate();		DynamicLoaderWindowsDYLD::Terminate();

OperatingSystemGo::Terminate();

platform_freebsd::PlatformFreeBSD::Terminate();		platform_freebsd::PlatformFreeBSD::Terminate();
platform_linux::PlatformLinux::Terminate();		platform_linux::PlatformLinux::Terminate();
platform_netbsd::PlatformNetBSD::Terminate();		platform_netbsd::PlatformNetBSD::Terminate();
platform_openbsd::PlatformOpenBSD::Terminate();		platform_openbsd::PlatformOpenBSD::Terminate();
PlatformWindows::Terminate();		PlatformWindows::Terminate();
PlatformKalimba::Terminate();		PlatformKalimba::Terminate();
platform_android::PlatformAndroid::Terminate();		platform_android::PlatformAndroid::Terminate();
Show All 14 Lines

unittests/Expression/CMakeLists.txt

	add_lldb_unittest(ExpressionTests			add_lldb_unittest(ExpressionTests
	ClangParserTest.cpp			ClangParserTest.cpp
	GoParserTest.cpp

	LINK_LIBS			LINK_LIBS
	lldbCore			lldbCore
	lldbPluginExpressionParserClang			lldbPluginExpressionParserClang
	lldbPluginExpressionParserGo
	lldbUtility			lldbUtility
	lldbUtilityHelpers			lldbUtilityHelpers
	)			)

unittests/Expression/GoParserTest.cpp

This file was deleted.

	//===-- GoParserTest.cpp ------------------------------------------*- C++
	//-*-===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include <sstream>

	#include "gtest/gtest.h"

	#include "Plugins/ExpressionParser/Go/GoParser.h"
	#include "lldb/Utility/Status.h"

	using namespace lldb_private;

	namespace {
	struct ASTPrinter {
	ASTPrinter(GoASTNode n) { (this)(n); }

	void operator()(GoASTNode *n) {
	if (n == nullptr) {
	m_stream << "nil ";
	return;
	}
	m_stream << "(" << n->GetKindName() << " ";
	n->WalkChildren(*this);
	if (auto *nn = llvm::dyn_cast<GoASTAssignStmt>(n))
	m_stream << nn->GetDefine() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTBasicLit>(n))
	m_stream << nn->GetValue().m_value.str() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTBinaryExpr>(n))
	m_stream << GoLexer::LookupToken(nn->GetOp()).str() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTIdent>(n))
	m_stream << nn->GetName().m_value.str() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTBranchStmt>(n))
	m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTCallExpr>(n))
	m_stream << (nn->GetEllipsis() ? "..." : "") << " ";
	if (auto *nn = llvm::dyn_cast<GoASTChanType>(n))
	m_stream << nn->GetDir() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTGenDecl>(n))
	m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTIncDecStmt>(n))
	m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTRangeStmt>(n))
	m_stream << nn->GetDefine() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTSliceExpr>(n))
	m_stream << nn->GetSlice3() << " ";
	if (auto *nn = llvm::dyn_cast<GoASTUnaryExpr>(n))
	m_stream << GoLexer::LookupToken(nn->GetOp()).str() << " ";
	m_stream << ") ";
	}

	const std::string str() const { return m_stream.str(); }
	std::stringstream m_stream;
	};

	testing::AssertionResult CheckStatement(const char _s, const char c_expr,
	const char sexpr, const char code) {
	GoParser parser(code);
	std::unique_ptr<GoASTStmt> stmt(parser.Statement());
	if (parser.Failed() \|\| !stmt) {
	Status err;
	parser.GetError(err);
	return testing::AssertionFailure() << "Error parsing " << c_expr << "\n\t"
	<< err.AsCString();
	}
	std::string actual_sexpr = ASTPrinter(stmt.get()).str();
	if (actual_sexpr == sexpr)
	return testing::AssertionSuccess();
	return testing::AssertionFailure() << "Parsing: " << c_expr
	<< "\nExpected: " << sexpr
	<< "\nGot: " << actual_sexpr;
	}
	} // namespace

	#define EXPECT_PARSE(s, c) EXPECT_PRED_FORMAT2(CheckStatement, s, c)

	TEST(GoParserTest, ParseBasicLiterals) {
	EXPECT_PARSE("(ExprStmt (BasicLit 0 ) ) ", "0");
	EXPECT_PARSE("(ExprStmt (BasicLit 42 ) ) ", "42");
	EXPECT_PARSE("(ExprStmt (BasicLit 0600 ) ) ", "0600");
	EXPECT_PARSE("(ExprStmt (BasicLit 0xBadFace ) ) ", "0xBadFace");
	EXPECT_PARSE(
	"(ExprStmt (BasicLit 170141183460469231731687303715884105727 ) ) ",
	"170141183460469231731687303715884105727");

	EXPECT_PARSE("(ExprStmt (BasicLit 0. ) ) ", "0.");
	EXPECT_PARSE("(ExprStmt (BasicLit 72.40 ) ) ", "72.40");
	EXPECT_PARSE("(ExprStmt (BasicLit 072.40 ) ) ", "072.40");
	EXPECT_PARSE("(ExprStmt (BasicLit 2.71828 ) ) ", "2.71828");
	EXPECT_PARSE("(ExprStmt (BasicLit 1.e+0 ) ) ", "1.e+0");
	EXPECT_PARSE("(ExprStmt (BasicLit 6.67428e-11 ) ) ", "6.67428e-11");
	EXPECT_PARSE("(ExprStmt (BasicLit 1E6 ) ) ", "1E6");
	EXPECT_PARSE("(ExprStmt (BasicLit .12345E+6 ) ) ", ".12345E+6");

	EXPECT_PARSE("(ExprStmt (BasicLit 0i ) ) ", "0i");
	EXPECT_PARSE("(ExprStmt (BasicLit 011i ) ) ", "011i");
	EXPECT_PARSE("(ExprStmt (BasicLit 0.i ) ) ", "0.i");
	EXPECT_PARSE("(ExprStmt (BasicLit 2.71828i ) ) ", "2.71828i");
	EXPECT_PARSE("(ExprStmt (BasicLit 6.67428e-11i ) ) ", "6.67428e-11i");
	EXPECT_PARSE("(ExprStmt (BasicLit 1E6i ) ) ", "1E6i");
	EXPECT_PARSE("(ExprStmt (BasicLit .12345E+6i ) ) ", ".12345E+6i");

	EXPECT_PARSE("(ExprStmt (BasicLit 'a' ) ) ", "'a'");
	EXPECT_PARSE("(ExprStmt (BasicLit '本' ) ) ", "'本'");
	EXPECT_PARSE("(ExprStmt (BasicLit \"abc\" ) ) ", "\"abc\"");
	EXPECT_PARSE("(ExprStmt (BasicLit `abc` ) ) ", "`abc`");
	EXPECT_PARSE("(ExprStmt (BasicLit `ab\nc` ) ) ", "`ab\nc`");
	}

	TEST(GoParserTest, ParseOperand) {
	EXPECT_PARSE("(ExprStmt (Ident a ) ) ", "a");
	EXPECT_PARSE("(ExprStmt (Ident _x9 ) ) ", "_x9");
	EXPECT_PARSE("(ExprStmt (Ident ThisVariableIsExported ) ) ",
	"ThisVariableIsExported");
	EXPECT_PARSE("(ExprStmt (Ident αβ ) ) ", "αβ");

	EXPECT_PARSE("(ExprStmt (SelectorExpr (Ident math ) (Ident Sin ) ) ) ",
	"math.Sin");
	}

	TEST(GoParserTest, ParseCompositeLiterals) {
	EXPECT_PARSE("(ExprStmt (CompositeLit (Ident Point3D ) ) ) ", "Point3D{}");
	EXPECT_PARSE("(ExprStmt (CompositeLit (Ident Line ) (Ident origin ) "
	"(CompositeLit (Ident Point3D ) (KeyValueExpr "
	"(Ident y ) (UnaryExpr (BasicLit 4 ) - ) ) (KeyValueExpr (Ident "
	"z ) (BasicLit 12.3 ) ) ) ) ) ",
	"Line{origin, Point3D{y: -4, z: 12.3}}");
	EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 10 ) (Ident "
	"string ) ) ) ) ",
	"[10]string{}");
	EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 6 ) (Ident int ) "
	") (BasicLit 1 ) (BasicLit 2 ) "
	"(BasicLit 3 ) (BasicLit 5 ) ) ) ",
	"[6]int {1, 2, 3, 5}");
	EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType nil (Ident int ) ) "
	"(BasicLit 2 ) (BasicLit 3 ) (BasicLit 5 ) "
	"(BasicLit 7 ) (BasicLit 9 ) (BasicLit 2147483647 ) ) ) ",
	"[]int{2, 3, 5, 7, 9, 2147483647}");
	EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 128 ) (Ident bool "
	") ) (KeyValueExpr (BasicLit 'a' ) "
	"(Ident true ) ) (KeyValueExpr (BasicLit 'e' ) (Ident true ) ) "
	"(KeyValueExpr (BasicLit 'i' ) (Ident "
	"true ) ) (KeyValueExpr (BasicLit 'o' ) (Ident true ) ) "
	"(KeyValueExpr (BasicLit 'u' ) (Ident true ) ) "
	"(KeyValueExpr (BasicLit 'y' ) (Ident true ) ) ) ) ",
	"[128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': "
	"true, 'y': true}");
	EXPECT_PARSE(
	"(ExprStmt (CompositeLit (ArrayType (BasicLit 10 ) (Ident float32 ) ) "
	"(UnaryExpr (BasicLit 1 ) - ) "
	"(KeyValueExpr (BasicLit 4 ) (UnaryExpr (BasicLit 0.1 ) - ) ) (UnaryExpr "
	"(BasicLit 0.1 ) - ) "
	"(KeyValueExpr (BasicLit 9 ) (UnaryExpr (BasicLit 1 ) - ) ) ) ) ",
	"[10]float32{-1, 4: -0.1, -0.1, 9: -1}");
	}

	TEST(GoParserTest, ParseEllipsisArray) {
	EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (Ellipsis nil ) (Ident "
	"string ) ) (BasicLit `Sat` ) (BasicLit `Sun` ) ) ) ",
	"[...]string {`Sat`, `Sun`}");
	EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (Ellipsis nil ) (Ident "
	"Point ) ) (CompositeLit nil (BasicLit 1.5 "
	") (UnaryExpr (BasicLit 3.5 ) - ) ) (CompositeLit nil (BasicLit "
	"0 ) (BasicLit 0 ) ) ) ) ",
	"[...]Point{{1.5, -3.5}, {0, 0}}");
	}

	TEST(GoParserTest, ParseMap) {
	EXPECT_PARSE("(ExprStmt (CompositeLit (MapType (Ident string ) (Ident "
	"float32 ) ) (KeyValueExpr (BasicLit `C0` ) "
	"(BasicLit 16.35 ) ) (KeyValueExpr (BasicLit `D0` ) (BasicLit "
	"18.35 ) ) ) ) ",
	"map[string]float32{`C0`: 16.35, `D0`: 18.35, }");
	}

	TEST(GoParserTest, UnaryExpr) {
	EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) + ) ) ", "+x");
	EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) - ) ) ", "-x");
	EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) ! ) ) ", "!x");
	EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) ^ ) ) ", "^x");
	EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) & ) ) ", "&x");
	EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) <- ) ) ", "<-x");
	EXPECT_PARSE("(ExprStmt (StarExpr (Ident x ) ) ) ", "*x");
	}

	TEST(GoParserTest, BinaryExpr) {
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) \|\| ) ) ", "a \|\| b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) && ) ) ", "a && b");

	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) == ) ) ", "a == b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) != ) ) ", "a != b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) < ) ) ", "a < b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) <= ) ) ", "a <= b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) > ) ) ", "a > b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) >= ) ) ", "a >= b");

	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) + ) ) ", "a + b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) - ) ) ", "a - b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) \| ) ) ", "a \| b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) ^ ) ) ", "a ^ b");

	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) * ) ) ", "a * b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) / ) ) ", "a / b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) % ) ) ", "a % b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) << ) ) ", "a << b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) >> ) ) ", "a >> b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) & ) ) ", "a & b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) &^ ) ) ", "a &^ b");

	EXPECT_PARSE("(ExprStmt (BinaryExpr (BasicLit 23 ) (BinaryExpr (BasicLit 3 ) "
	"(IndexExpr (Ident x ) (Ident i ) ) * ) + ) ) ",
	"23 + 3*x[i]");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (UnaryExpr (UnaryExpr (Ident "
	"a ) + ) + ) + ) ) ",
	"a + + + a");
	EXPECT_PARSE(
	"(ExprStmt (BinaryExpr (UnaryExpr (Ident a ) ^ ) (Ident b ) >> ) ) ",
	"^a >> b");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (CallExpr (Ident f ) ) (CallExpr (Ident "
	"g ) ) \|\| ) ) ",
	"f() \|\| g()");
	EXPECT_PARSE(
	"(ExprStmt (BinaryExpr (BinaryExpr (Ident x ) (BinaryExpr (Ident y ) "
	"(BasicLit 1 ) + ) == ) "
	"(BinaryExpr (UnaryExpr (Ident chanPtr ) <- ) (BasicLit 0 ) > ) && ) ) ",
	"x == y+1 && <-chanPtr > 0");
	}

	TEST(GoParserTest, PrimaryExpr) {
	EXPECT_PARSE(
	"(ExprStmt (BinaryExpr (Ident x ) (CallExpr (Ident f ) ) <= ) ) ",
	"x <= f()");
	EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident s ) (BasicLit `.txt` ) + ) ) ",
	"(s + `.txt`)");
	EXPECT_PARSE(
	"(ExprStmt (CallExpr (Ident f ) (BasicLit 3.1415 ) (Ident true ) ) ) ",
	"f(3.1415, true)");
	EXPECT_PARSE(
	"(ExprStmt (CallExpr (Ident f ) (BasicLit 3.1415 ) (Ident a ) ... ) ) ",
	"f(3.1415, a...)");
	EXPECT_PARSE("(ExprStmt (IndexExpr (Ident m ) (BasicLit '1' ) ) ) ",
	"m['1']");
	EXPECT_PARSE("(ExprStmt (SliceExpr (Ident s ) (Ident i ) (BinaryExpr (Ident "
	"j ) (BasicLit 1 ) + ) nil 0 ) ) ",
	"s[i : j + 1]");
	EXPECT_PARSE("(ExprStmt (SelectorExpr (Ident obj ) (Ident color ) ) ) ",
	"obj.color");
	EXPECT_PARSE("(ExprStmt (CallExpr (SelectorExpr (IndexExpr (SelectorExpr "
	"(Ident f ) (Ident p ) ) (Ident i ) ) "
	"(Ident x ) ) ) ) ",
	"f.p[i].x()");
	}

	TEST(GoParserTest, Conversions) {
	EXPECT_PARSE(
	"(ExprStmt (StarExpr (CallExpr (Ident Point ) (Ident p ) ) ) ) ",
	"*Point(p)");
	EXPECT_PARSE(
	"(ExprStmt (CallExpr (StarExpr (Ident Point ) ) (Ident p ) ) ) ",
	"(*Point)(p)");
	EXPECT_PARSE("(ExprStmt (UnaryExpr (CallExpr (ChanType (Ident int ) 0 ) "
	"(Ident c ) ) <- ) ) ",
	"<-chan int(c)");
	EXPECT_PARSE("(ExprStmt (TypeAssertExpr (Ident y ) (SelectorExpr (Ident io ) "
	"(Ident Reader ) ) ) ) ",
	"y.(io.Reader)");
	}

unittests/Language/Highlighting/CMakeLists.txt

	add_lldb_unittest(HighlighterTests			add_lldb_unittest(HighlighterTests
	HighlighterTest.cpp			HighlighterTest.cpp

	LINK_LIBS			LINK_LIBS
	lldbPluginCPlusPlusLanguage			lldbPluginCPlusPlusLanguage
	lldbPluginObjCLanguage			lldbPluginObjCLanguage
	lldbPluginObjCPlusPlusLanguage			lldbPluginObjCPlusPlusLanguage
	lldbPluginJavaLanguage			lldbPluginJavaLanguage
	lldbPluginOCamlLanguage			lldbPluginOCamlLanguage
	lldbPluginGoLanguage
	)			)

unittests/Language/Highlighting/HighlighterTest.cpp

	//===-- HighlighterTest.cpp -------------------------------------- C++ --===//			//===-- HighlighterTest.cpp -------------------------------------- C++ --===//
	//			//
	// The LLVM Compiler Infrastructure			// The LLVM Compiler Infrastructure
	//			//
	// This file is distributed under the University of Illinois Open Source			// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.			// License. See LICENSE.TXT for details.
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "gtest/gtest.h"			#include "gtest/gtest.h"

	#include "lldb/Core/Highlighter.h"			#include "lldb/Core/Highlighter.h"

	#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"			#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
	#include "Plugins/Language/Go/GoLanguage.h"
	#include "Plugins/Language/Java/JavaLanguage.h"			#include "Plugins/Language/Java/JavaLanguage.h"
	#include "Plugins/Language/OCaml/OCamlLanguage.h"			#include "Plugins/Language/OCaml/OCamlLanguage.h"
	#include "Plugins/Language/ObjC/ObjCLanguage.h"			#include "Plugins/Language/ObjC/ObjCLanguage.h"
	#include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"			#include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"

	using namespace lldb_private;			using namespace lldb_private;

	namespace {			namespace {
	class HighlighterTest : public testing::Test {			class HighlighterTest : public testing::Test {
	public:			public:
	static void SetUpTestCase();			static void SetUpTestCase();
	static void TearDownTestCase();			static void TearDownTestCase();
	};			};
	} // namespace			} // namespace

	void HighlighterTest::SetUpTestCase() {			void HighlighterTest::SetUpTestCase() {
	// The HighlighterManager uses the language plugins under the hood, so we			// The HighlighterManager uses the language plugins under the hood, so we
	// have to initialize them here for our test process.			// have to initialize them here for our test process.
	CPlusPlusLanguage::Initialize();			CPlusPlusLanguage::Initialize();
	GoLanguage::Initialize();
	JavaLanguage::Initialize();			JavaLanguage::Initialize();
	ObjCLanguage::Initialize();			ObjCLanguage::Initialize();
	ObjCPlusPlusLanguage::Initialize();			ObjCPlusPlusLanguage::Initialize();
	OCamlLanguage::Initialize();			OCamlLanguage::Initialize();
	}			}

	void HighlighterTest::TearDownTestCase() {			void HighlighterTest::TearDownTestCase() {
	CPlusPlusLanguage::Terminate();			CPlusPlusLanguage::Terminate();
	GoLanguage::Terminate();
	JavaLanguage::Terminate();			JavaLanguage::Terminate();
	ObjCLanguage::Terminate();			ObjCLanguage::Terminate();
	ObjCPlusPlusLanguage::Terminate();			ObjCPlusPlusLanguage::Terminate();
	OCamlLanguage::Terminate();			OCamlLanguage::Terminate();
	}			}

	static std::string getName(lldb::LanguageType type) {			static std::string getName(lldb::LanguageType type) {
	HighlighterManager m;			HighlighterManager m;
	▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

unittests/Symbol/TestClangASTContext.cpp

Show All 12 Lines

#include "clang/AST/DeclCXX.h"		#include "clang/AST/DeclCXX.h"

#include "lldb/Host/FileSystem.h"		#include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostInfo.h"		#include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/ClangASTContext.h"		#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangUtil.h"		#include "lldb/Symbol/ClangUtil.h"
#include "lldb/Symbol/Declaration.h"		#include "lldb/Symbol/Declaration.h"
#include "lldb/Symbol/GoASTContext.h"

using namespace clang;		using namespace clang;
using namespace lldb;		using namespace lldb;
using namespace lldb_private;		using namespace lldb_private;

class TestClangASTContext : public testing::Test {		class TestClangASTContext : public testing::Test {
public:		public:
static void SetUpTestCase() {		static void SetUpTestCase() {
▲ Show 20 Lines • Show All 204 Lines • ▼ Show 20 Lines	CompilerType record_type = m_ast->CreateRecordType(
nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,		nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
lldb::eLanguageTypeC_plus_plus, nullptr);		lldb::eLanguageTypeC_plus_plus, nullptr);
// Clang builtin type and record type should pass		// Clang builtin type and record type should pass
EXPECT_TRUE(ClangUtil::IsClangType(bool_type));		EXPECT_TRUE(ClangUtil::IsClangType(bool_type));
EXPECT_TRUE(ClangUtil::IsClangType(record_type));		EXPECT_TRUE(ClangUtil::IsClangType(record_type));

// Default constructed type should fail		// Default constructed type should fail
EXPECT_FALSE(ClangUtil::IsClangType(CompilerType()));		EXPECT_FALSE(ClangUtil::IsClangType(CompilerType()));

// Go type should fail
GoASTContext go_ast;
CompilerType go_type(&go_ast, bool_ctype);
EXPECT_FALSE(ClangUtil::IsClangType(go_type));
}		}

TEST_F(TestClangASTContext, TestRemoveFastQualifiers) {		TEST_F(TestClangASTContext, TestRemoveFastQualifiers) {
CompilerType record_type = m_ast->CreateRecordType(		CompilerType record_type = m_ast->CreateRecordType(
nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,		nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
lldb::eLanguageTypeC_plus_plus, nullptr);		lldb::eLanguageTypeC_plus_plus, nullptr);
QualType qt;		QualType qt;

▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

Remove Go debugger pluginClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 172458

include/lldb/Symbol/GoASTContext.h

include/lldb/lldb-forward.h

packages/Python/lldbsuite/test/decorators.py

packages/Python/lldbsuite/test/lang/go/expressions/TestExpressions.py

packages/Python/lldbsuite/test/lang/go/expressions/main.go

packages/Python/lldbsuite/test/lang/go/formatters/TestGoFormatters.py

packages/Python/lldbsuite/test/lang/go/formatters/main.go

packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py

packages/Python/lldbsuite/test/lang/go/goroutines/main.go

packages/Python/lldbsuite/test/lang/go/runtime/TestGoLanguageRuntime

packages/Python/lldbsuite/test/lang/go/runtime/main.go

packages/Python/lldbsuite/test/lang/go/types/TestGoASTContext.py

packages/Python/lldbsuite/test/lang/go/types/main.go

packages/Python/lldbsuite/test/lldbtest.py

source/API/SystemInitializerFull.cpp

source/Plugins/ExpressionParser/CMakeLists.txt

source/Plugins/ExpressionParser/Go/CMakeLists.txt

source/Plugins/ExpressionParser/Go/GoAST.h

source/Plugins/ExpressionParser/Go/GoLexer.h

source/Plugins/ExpressionParser/Go/GoLexer.cpp

source/Plugins/ExpressionParser/Go/GoParser.h

source/Plugins/ExpressionParser/Go/GoParser.cpp

source/Plugins/ExpressionParser/Go/GoUserExpression.h

source/Plugins/ExpressionParser/Go/GoUserExpression.cpp

source/Plugins/ExpressionParser/Go/gen_go_ast.py

source/Plugins/Language/CMakeLists.txt

source/Plugins/Language/Go/CMakeLists.txt

source/Plugins/Language/Go/GoFormatterFunctions.h

source/Plugins/Language/Go/GoFormatterFunctions.cpp

source/Plugins/Language/Go/GoLanguage.h

source/Plugins/Language/Go/GoLanguage.cpp

source/Plugins/LanguageRuntime/CMakeLists.txt

source/Plugins/LanguageRuntime/Go/CMakeLists.txt

source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.h

source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.cpp

source/Plugins/OperatingSystem/CMakeLists.txt

source/Plugins/OperatingSystem/Go/CMakeLists.txt

source/Plugins/OperatingSystem/Go/OperatingSystemGo.h

source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

source/Plugins/SymbolFile/DWARF/CMakeLists.txt

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp

source/Symbol/CMakeLists.txt

source/Symbol/GoASTContext.cpp

tools/lldb-test/SystemInitializerTest.cpp

unittests/Expression/CMakeLists.txt

unittests/Expression/GoParserTest.cpp

unittests/Language/Highlighting/CMakeLists.txt

unittests/Language/Highlighting/HighlighterTest.cpp

unittests/Symbol/TestClangASTContext.cpp

Remove Go debugger plugin
ClosedPublic