Attachment #719343 for bug #789717




  endif() # if (CCACHE_PROGRAM)
endif() # if (ROCM_CCACHE_BUILD)

project(amd_comgr VERSION "1.6.0" LANGUAGES C CXX)

set(PROJECT_VERSION_MAJOR "1")
set(PROJECT_VERSION_MINOR "6")
set(PROJECT_VERSION_PATCH "0")
set(PROJECT_VERSION
  "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")

find_package(ROCM PATHS "/opt/rocm")
if (ROCM_FOUND)
  include(ROCMSetupVersion)
  rocm_setup_version(VERSION "${amd_comgr_VERSION}")
endif()

find_package(Clang REQUIRED CONFIG PATHS ${LLVM_DIR} "/opt/rocm/llvm" NO_DEFAULT_PATH)

message("--CLANG_INCLUDE_DIRS: ${CLANG_INCLUDE_DIRS}")
message("----LLD_INCLUDE_DIRS: ${LLD_INCLUDE_DIRS}")
message("---AMDDeviceLibs_DIR: ${AMDDeviceLibs_DIR}")
message("------------ROCM_DIR: ${ROCM_DIR}")
message("")

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")

set_target_properties(amd_comgr PROPERTIES
  CXX_STANDARD 14
  CXX_STANDARD_REQUIRED Yes
  CXX_EXTENSIONS No)
if (ROCM_FOUND)
  rocm_set_soversion(amd_comgr "${amd_comgr_VERSION_MAJOR}.${amd_comgr_VERSION_MINOR}")
else()
  set_target_properties(amd_comgr PROPERTIES
    SOVERSION "${amd_comgr_VERSION_MAJOR}"
    VERSION "${amd_comgr_VERSION_MAJOR}.${amd_comgr_VERSION_MINOR}.${amd_comgr_VERSION_PATCH}")
endif()
target_compile_options(amd_comgr
  PRIVATE "${AMD_COMGR_PRIVATE_COMPILE_OPTIONS}")
target_compile_definitions(amd_comgr
  PRIVATE "${AMD_COMGR_PRIVATE_COMPILE_DEFINITIONS}")
target_include_directories(amd_comgr
  PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
    $<INSTALL_INTERFACE:include>)

set(AMD_COMGR_CONFIG_NAME amd_comgr-config.cmake)

  "${AMD_COMGR_PACKAGE_PREFIX}/${AMD_COMGR_CONFIG_NAME}"
  @ONLY)
write_basic_package_version_file("${AMD_COMGR_VERSION_PATH}"
  VERSION "${amd_comgr_VERSION}"
  COMPATIBILITY SameMajorVersion)

install(TARGETS amd_comgr

  lldELF
  lldCommon)

if (LLVM_LINK_LLVM_DYLIB)
  set(LLVM_LIBS LLVM)
else()
  llvm_map_components_to_libnames(LLVM_LIBS
    ${LLVM_TARGETS_TO_BUILD}
    Option
    DebugInfoDWARF
    Symbolize
    Support
    Object
    BitWriter
    MC
    MCParser
    MCDisassembler
    Core
    IRReader
    CodeGen
    Linker
    BinaryFormat)
endif()

target_link_libraries(amd_comgr
  PUBLIC

set(CPACK_PACKAGE_NAME comgr)
set(CPACK_PACKAGE_VENDOR "AMD")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Library to provide support functions")
set(CPACK_PACKAGE_VERSION "${amd_comgr_VERSION}")
set(CPACK_PACKAGE_VERSION_MAJOR "${amd_comgr_VERSION_MAJOR}")
set(CPACK_PACKAGE_VERSION_MINOR "${amd_comgr_VERSION_MINOR}")
set(CPACK_PACKAGE_VERSION_PATCH "${amd_comgr_VERSION_PATCH}")
set(CPACK_PACKAGE_CONTACT "Advanced Micro Devices Inc.")
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt")





Build the Code Object Manager
-----------------------------

Comgr depends on [LLVM](https://github.com/RadeonOpenCompute/llvm-project) and
[AMDDeviceLibs](https://github.com/RadeonOpenCompute/ROCm-Device-Libs). The
`CMAKE_PREFIX_PATH` must include either the build directory or install prefix
of both of these components. Both should be built using sources with the same
ROCm release tag, or from the amd-stg-open branch. LLVM should be built with at
least `LLVM_ENABLE_PROJECTS='llvm;clang;lld'` and
`LLVM_TARGETS_TO_BUILD='AMDGPU;X86'`.
Comgr depends on Clang and LLD, which should be built as a part of the LLVM
distribution used. The LLVM, Clang, and LLD used must be from the amd-common
branches of their respective repositories on the [RadeonOpenCompute
Github](https://github.com/RadeonOpenCompute) organisation.

An example command-line to build Comgr on Linux is:

    $ cd ~/llvm-project/
    $ mkdir build
    $ cd build
    $ cmake -DCMAKE_BUILD_TYPE=Release \
        -DLLVM_ENABLE_PROJECTS="llvm;clang;lld" \
        -DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" ../llvm
    $ make
    $ cd ~/device-libs/
    $ mkdir build
    $ cd build
    $ cmake -DLLVM_DIR=~/llvm-project/build ..
    $ make
    $ make install
    $ # build AMDDeviceLibs
    $ cd ~/support/lib/comgr
    $ mkdir build
    $ cd build
    $ cmake -DCMAKE_BUILD_TYPE=Release \
        -DCMAKE_PREFIX_PATH="~/llvm/build;~/device-libs/build" ..
    $ make
    $ make test

The equivalent on Windows will use another build tool, such as msbuild or
Visual Studio:

    $ cd "%HOMEPATH%\llvm-project"
    $ mkdir build
    $ cd build
    $ cmake -DCMAKE_BUILD_TYPE=Release \
        -DLLVM_ENABLE_PROJECTS='llvm;clang;lld' \
        -DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" "..\llvm"
    $ msbuild ALL_BUILD.vcxproj
    $ cd "%HOMEPATH%\device-libs"
    $ mkdir build
    $ cd build
    $ cmake -DLLVM_DIR="%HOMEPATH%\llvm-project\build" ..
    $ msbuild ALL_BUILD.vcxproj
    $ msbuild INSTALL.vcxproj
    $ rem build AMDDeviceLibs
    $ cd "%HOMEPATH%\support\lib\comgr"
    $ mkdir build
    $ cd build
    $ cmake -DCMAKE_BUILD_TYPE=Release \
        -DCMAKE_PREFIX_PATH="%HOMEPATH%\llvm\build;%HOMEPATH%\device-libs\build" ..
    $ msbuild ALL_BUILD.vcxproj
    $ msbuild RUN_TESTS.vcxproj





  MCInst Inst;
  std::string Annotations;
  raw_string_ostream AnnotationsStream(Annotations);
  if (DisAsm->getInstruction(Inst, Size, Buffer, Address,
                             AnnotationsStream) != MCDisassembler::Success)
    return AMD_COMGR_STATUS_ERROR;

  std::string InstStr;
  raw_string_ostream InstStream(InstStr);
  IP->printInst(&Inst, Address, AnnotationsStream.str(), *STI, InstStream);

  PrintInstruction(InstStream.str().c_str(), UserData);





      dumpBytes(Bytes, OS);
    }
    if (MI)
      IP.printInst(MI, Address.Address, "", STI, OS);
    else
      OS << " <unknown>";
  }

    std::string Buffer;
    {
      raw_string_ostream TempStream(Buffer);
      IP.printInst(MI, Address.Address, "", STI, TempStream);
    }
    StringRef Contents(Buffer);
    // Split off bundle attributes

    SmallString<40> InstStr;
    raw_svector_ostream IS(InstStr);

    IP.printInst(MI, Address.Address, "", STI, IS);

    OS << left_justify(IS.str(), 60)
       << format("// %012" PRIX64 ": ", Address.Address);

      dumpBytes(Bytes, OS);
    }
    if (MI)
      IP.printInst(MI, Address.Address, "", STI, OS);
    else
      OS << " <unknown>";
  }

      // COMGR TBD: Get rid of ".text:"??
      OutS << '\n' << std::get<1>(Symbols[si]) << ":\n";

#ifndef NDEBUG
      raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
#else
      raw_ostream &DebugOut = nulls();
#endif

      for (Index = Start; Index < End; Index += Size) {
        MCInst Inst;


        // Disassemble a real instruction or a data when disassemble all is
        // provided
        bool Disassembled = DisAsm->getInstruction(
            Inst, Size, Bytes.slice(Index), SectionAddr + Index, CommentStream);
            CommentStream);
        if (Size == 0)
          Size = 1;


Return to bug 789717

Lines 14-31 if (ROCM_CCACHE_BUILD) Link Here

(-)old/CMakeLists.txt (-33 / +37 lines)
14	endif() # if (CCACHE_PROGRAM)	14	endif() # if (CCACHE_PROGRAM)
15	endif() # if (ROCM_CCACHE_BUILD)	15	endif() # if (ROCM_CCACHE_BUILD)
16		16
17	project(amd_comgr)	17	project(amd_comgr VERSION "1.6.0" LANGUAGES C CXX)
18
19	set(PROJECT_VERSION_MAJOR "1")
20	set(PROJECT_VERSION_MINOR "6")
21	set(PROJECT_VERSION_PATCH "0")
22	set(PROJECT_VERSION
23	"${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
24		18
25	find_package(ROCM PATHS "/opt/rocm")	19	find_package(ROCM PATHS "/opt/rocm")
26	if (ROCM_FOUND)	20	if (ROCM_FOUND)
27	include(ROCMSetupVersion)	21	include(ROCMSetupVersion)
28	rocm_setup_version(VERSION "${PROJECT_VERSION}")	22	rocm_setup_version(VERSION "${amd_comgr_VERSION}")
29	endif()	23	endif()
30		24
31	find_package(Clang REQUIRED CONFIG PATHS ${LLVM_DIR} "/opt/rocm/llvm" NO_DEFAULT_PATH)	25	find_package(Clang REQUIRED CONFIG PATHS ${LLVM_DIR} "/opt/rocm/llvm" NO_DEFAULT_PATH)
Lines 47-52 message("-----------Clang_DIR: ${Clang_D Link Here
47	message("--CLANG_INCLUDE_DIRS: ${CLANG_INCLUDE_DIRS}")	41	message("--CLANG_INCLUDE_DIRS: ${CLANG_INCLUDE_DIRS}")
48	message("----LLD_INCLUDE_DIRS: ${LLD_INCLUDE_DIRS}")	42	message("----LLD_INCLUDE_DIRS: ${LLD_INCLUDE_DIRS}")
49	message("---AMDDeviceLibs_DIR: ${AMDDeviceLibs_DIR}")	43	message("---AMDDeviceLibs_DIR: ${AMDDeviceLibs_DIR}")
		44	message("------------ROCM_DIR: ${ROCM_DIR}")
50	message("")	45	message("")
51		46
52	list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")	47	list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
Lines 112-127 endif() Link Here
112	set_target_properties(amd_comgr PROPERTIES	111	set_target_properties(amd_comgr PROPERTIES
113	CXX_STANDARD 14	112	CXX_STANDARD 14
114	CXX_STANDARD_REQUIRED Yes	113	CXX_STANDARD_REQUIRED Yes
115	CXX_EXTENSIONS No	114	CXX_EXTENSIONS No)
116	SOVERSION "${PROJECT_VERSION_MAJOR}"	115	if (ROCM_FOUND)
117	VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")	116	rocm_set_soversion(amd_comgr "${amd_comgr_VERSION_MAJOR}.${amd_comgr_VERSION_MINOR}")
		117	else()
		118	set_target_properties(amd_comgr PROPERTIES
		119	SOVERSION "${amd_comgr_VERSION_MAJOR}"
		120	VERSION "${amd_comgr_VERSION_MAJOR}.${amd_comgr_VERSION_MINOR}.${amd_comgr_VERSION_PATCH}")
		121	endif()
118	target_compile_options(amd_comgr	122	target_compile_options(amd_comgr
119	PRIVATE "${AMD_COMGR_PRIVATE_COMPILE_OPTIONS}")	123	PRIVATE "${AMD_COMGR_PRIVATE_COMPILE_OPTIONS}")
120	target_compile_definitions(amd_comgr	124	target_compile_definitions(amd_comgr
121	PRIVATE "${AMD_COMGR_PRIVATE_COMPILE_DEFINITIONS}")	125	PRIVATE "${AMD_COMGR_PRIVATE_COMPILE_DEFINITIONS}")
122	target_include_directories(amd_comgr	126	target_include_directories(amd_comgr
123	PUBLIC	127	PUBLIC
124	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>	128	$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
125	$<INSTALL_INTERFACE:include>)	129	$<INSTALL_INTERFACE:include>)
126		130
127	set(AMD_COMGR_CONFIG_NAME amd_comgr-config.cmake)	131	set(AMD_COMGR_CONFIG_NAME amd_comgr-config.cmake)
Lines 141-147 configure_file("cmake/${AMD_COMGR_CONFIG Link Here
141	"${AMD_COMGR_PACKAGE_PREFIX}/${AMD_COMGR_CONFIG_NAME}"	145	"${AMD_COMGR_PACKAGE_PREFIX}/${AMD_COMGR_CONFIG_NAME}"
142	@ONLY)	146	@ONLY)
143	write_basic_package_version_file("${AMD_COMGR_VERSION_PATH}"	147	write_basic_package_version_file("${AMD_COMGR_VERSION_PATH}"
144	VERSION "${PROJECT_VERSION}"	148	VERSION "${amd_comgr_VERSION}"
145	COMPATIBILITY SameMajorVersion)	149	COMPATIBILITY SameMajorVersion)
146		150
147	install(TARGETS amd_comgr	151	install(TARGETS amd_comgr
Lines 193-214 set(LLD_LIBS Link Here
193	lldELF	197	lldELF
194	lldCommon)	198	lldCommon)
195		199
196	llvm_map_components_to_libnames(LLVM_LIBS	200	if (LLVM_LINK_LLVM_DYLIB)
197	${LLVM_TARGETS_TO_BUILD}	201	set(LLVM_LIBS LLVM)
198	Option	202	else()
199	DebugInfoDWARF	203	llvm_map_components_to_libnames(LLVM_LIBS
200	Symbolize	204	${LLVM_TARGETS_TO_BUILD}
201	Support	205	Option
202	Object	206	DebugInfoDWARF
203	BitWriter	207	Symbolize
204	MC	208	Support
205	MCParser	209	Object
206	MCDisassembler	210	BitWriter
207	Core	211	MC
208	IRReader	212	MCParser
209	CodeGen	213	MCDisassembler
210	Linker	214	Core
211	BinaryFormat)	215	IRReader
		216	CodeGen
		217	Linker
		218	BinaryFormat)
		219	endif()
212		220
213	target_link_libraries(amd_comgr	221	target_link_libraries(amd_comgr
214	PUBLIC	222	PUBLIC
Lines 232-241 add_subdirectory(test) Link Here
232	set(CPACK_PACKAGE_NAME comgr)	240	set(CPACK_PACKAGE_NAME comgr)
233	set(CPACK_PACKAGE_VENDOR "AMD")	241	set(CPACK_PACKAGE_VENDOR "AMD")
234	set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Library to provide support functions")	242	set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Library to provide support functions")
235	set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")	243	set(CPACK_PACKAGE_VERSION "${amd_comgr_VERSION}")
236	set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")	244	set(CPACK_PACKAGE_VERSION_MAJOR "${amd_comgr_VERSION_MAJOR}")
237	set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")	245	set(CPACK_PACKAGE_VERSION_MINOR "${amd_comgr_VERSION_MINOR}")
238	set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")	246	set(CPACK_PACKAGE_VERSION_PATCH "${amd_comgr_VERSION_PATCH}")
239	set(CPACK_PACKAGE_CONTACT "Advanced Micro Devices Inc.")	247	set(CPACK_PACKAGE_CONTACT "Advanced Micro Devices Inc.")
240	set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt")	248	set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt")
241		249

Lines 138-150 amd_comgr_status_t DisassemblyInfo::disa Link Here

(-)old/src/comgr-disassembly.cpp (-2 / +2 lines)
138	MCInst Inst;	138	MCInst Inst;
139	std::string Annotations;	139	std::string Annotations;
140	raw_string_ostream AnnotationsStream(Annotations);	140	raw_string_ostream AnnotationsStream(Annotations);
141	if (DisAsm->getInstruction(Inst, Size, Buffer, Address, nulls(),	141	if (DisAsm->getInstruction(Inst, Size, Buffer, Address,
142	AnnotationsStream) != MCDisassembler::Success)	142	AnnotationsStream) != MCDisassembler::Success)
143	return AMD_COMGR_STATUS_ERROR;	143	return AMD_COMGR_STATUS_ERROR;
144		144
145	std::string InstStr;	145	std::string InstStr;
146	raw_string_ostream InstStream(InstStr);	146	raw_string_ostream InstStream(InstStr);
147	IP->printInst(&Inst, InstStream, AnnotationsStream.str(), *STI);	147	IP->printInst(&Inst, Address, AnnotationsStream.str(), *STI, InstStream);
148		148
149	PrintInstruction(InstStream.str().c_str(), UserData);	149	PrintInstruction(InstStream.str().c_str(), UserData);
150		150

Lines 560-566 public: Link Here

(-)old/src/comgr-objdump.cpp (-12 / +5 lines)
560	dumpBytes(Bytes, OS);	560	dumpBytes(Bytes, OS);
561	}	561	}
562	if (MI)	562	if (MI)
563	IP.printInst(MI, OS, "", STI);	563	IP.printInst(MI, Address.Address, "", STI, OS);
564	else	564	else
565	OS << " <unknown>";	565	OS << " <unknown>";
566	}	566	}
Lines 593-599 public: Link Here
593	std::string Buffer;	593	std::string Buffer;
594	{	594	{
595	raw_string_ostream TempStream(Buffer);	595	raw_string_ostream TempStream(Buffer);
596	IP.printInst(MI, TempStream, "", STI);	596	IP.printInst(MI, Address.Address, "", STI, TempStream);
597	}	597	}
598	StringRef Contents(Buffer);	598	StringRef Contents(Buffer);
599	// Split off bundle attributes	599	// Split off bundle attributes
Lines 645-651 public: Link Here
645	SmallString<40> InstStr;	645	SmallString<40> InstStr;
646	raw_svector_ostream IS(InstStr);	646	raw_svector_ostream IS(InstStr);
647		647
648	IP.printInst(MI, IS, "", STI);	648	IP.printInst(MI, Address.Address, "", STI, IS);
649		649
650	OS << left_justify(IS.str(), 60)	650	OS << left_justify(IS.str(), 60)
651	<< format("// %012" PRIX64 ": ", Address.Address);	651	<< format("// %012" PRIX64 ": ", Address.Address);
Lines 677-683 public: Link Here
677	dumpBytes(Bytes, OS);	677	dumpBytes(Bytes, OS);
678	}	678	}
679	if (MI)	679	if (MI)
680	IP.printInst(MI, OS, "", STI);	680	IP.printInst(MI, Address.Address, "", STI, OS);
681	else	681	else
682	OS << " <unknown>";	682	OS << " <unknown>";
683	}	683	}
Lines 1474-1485 void llvm::DisassemHelper::DisassembleOb Link Here
1474	// COMGR TBD: Get rid of ".text:"??	1474	// COMGR TBD: Get rid of ".text:"??
1475	OutS << '\n' << std::get<1>(Symbols[si]) << ":\n";	1475	OutS << '\n' << std::get<1>(Symbols[si]) << ":\n";
1476		1476
1477	#ifndef NDEBUG
1478	raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
1479	#else
1480	raw_ostream &DebugOut = nulls();
1481	#endif
1482
1483	for (Index = Start; Index < End; Index += Size) {	1477	for (Index = Start; Index < End; Index += Size) {
1484	MCInst Inst;	1478	MCInst Inst;
1485		1479
Lines 1601-1608 void llvm::DisassemHelper::DisassembleOb Link Here
1601	// Disassemble a real instruction or a data when disassemble all is	1595	// Disassemble a real instruction or a data when disassemble all is
1602	// provided	1596	// provided
1603	bool Disassembled = DisAsm->getInstruction(	1597	bool Disassembled = DisAsm->getInstruction(
1604	Inst, Size, Bytes.slice(Index), SectionAddr + Index, DebugOut,	1598	Inst, Size, Bytes.slice(Index), SectionAddr + Index, CommentStream);
1605	CommentStream);
1606	if (Size == 0)	1599	if (Size == 0)
1607	Size = 1;	1600	Size = 1;
1608		1601

Lines 7-60 objects. The API is documented in the [h Link Here

(-)old/README.md (-21 / +23 lines)
7	Build the Code Object Manager	7	Build the Code Object Manager
8	-----------------------------	8	-----------------------------
9		9
10	Comgr depends on LLVM, and optionally depends on	10	Comgr depends on [LLVM](https://github.com/RadeonOpenCompute/llvm-project) and
11	[AMDDeviceLibs](https://github.com/RadeonOpenCompute/ROCm-Device-Libs). The	11	[AMDDeviceLibs](https://github.com/RadeonOpenCompute/ROCm-Device-Libs). The
12	`CMAKE_PREFIX_PATH` must include either the build directory or install prefix	12	`CMAKE_PREFIX_PATH` must include either the build directory or install prefix
13	of both of these components. Comgr also depends on yaml-cpp, but version	13	of both of these components. Both should be built using sources with the same
14	[0.6.2](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.2) is	14	ROCm release tag, or from the amd-stg-open branch. LLVM should be built with at
15	included in-tree.	15	least `LLVM_ENABLE_PROJECTS='llvm;clang;lld'` and
16		16	`LLVM_TARGETS_TO_BUILD='AMDGPU;X86'`.
17	Comgr depends on Clang and LLD, which should be built as a part of the LLVM
18	distribution used. The LLVM, Clang, and LLD used must be from the amd-common
19	branches of their respective repositories on the [RadeonOpenCompute
20	Github](https://github.com/RadeonOpenCompute) organisation.
21		17
22	An example command-line to build Comgr on Linux is:	18	An example command-line to build Comgr on Linux is:
23		19
24	$ cd ~/llvm/	20	$ cd ~/llvm-project/
25	$ mkdir build	21	$ mkdir build
26	$ cd build	22	$ cd build
27	$ cmake -DCMAKE_BUILD_TYPE=Release \	23	$ cmake -DCMAKE_BUILD_TYPE=Release \
28	-DCMAKE_INSTALL_PREFIX=dist \	24	-DLLVM_ENABLE_PROJECTS="llvm;clang;lld" \
29	-DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" ..	25	-DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" ../llvm
		26	$ make
		27	$ cd ~/device-libs/
		28	$ mkdir build
		29	$ cd build
		30	$ cmake -DLLVM_DIR=~/llvm-project/build ..
30	$ make	31	$ make
31	$ make install
32	$ # build AMDDeviceLibs
33	$ cd ~/support/lib/comgr	32	$ cd ~/support/lib/comgr
34	$ mkdir build	33	$ mkdir build
35	$ cd build	34	$ cd build
36	$ cmake -DCMAKE_BUILD_TYPE=Release \	35	$ cmake -DCMAKE_BUILD_TYPE=Release \
37	-DCMAKE_PREFIX_PATH="~/llvm/build/dist;path/to/device-libs" ..	36	-DCMAKE_PREFIX_PATH="~/llvm/build;~/device-libs/build" ..
38	$ make	37	$ make
39	$ make test	38	$ make test
40		39
41	The equivalent on Windows will use another build tool, such as msbuild or	40	The equivalent on Windows will use another build tool, such as msbuild or
42	Visual Studio:	41	Visual Studio:
43		42
44	$ cd "%HOMEPATH%\llvm"	43	$ cd "%HOMEPATH%\llvm-project"
45	$ mkdir build	44	$ mkdir build
46	$ cd build	45	$ cd build
47	$ cmake -DCMAKE_BUILD_TYPE=Release \	46	$ cmake -DCMAKE_BUILD_TYPE=Release \
48	-DCMAKE_INSTALL_PREFIX=dist \	47	-DLLVM_ENABLE_PROJECTS='llvm;clang;lld' \
49	-DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" ..	48	-DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" "..\llvm"
		49	$ msbuild ALL_BUILD.vcxproj
		50	$ cd "%HOMEPATH%\device-libs"
		51	$ mkdir build
		52	$ cd build
		53	$ cmake -DLLVM_DIR="%HOMEPATH%\llvm-project\build" ..
50	$ msbuild ALL_BUILD.vcxproj	54	$ msbuild ALL_BUILD.vcxproj
51	$ msbuild INSTALL.vcxproj
52	$ rem build AMDDeviceLibs
53	$ cd "%HOMEPATH%\support\lib\comgr"	55	$ cd "%HOMEPATH%\support\lib\comgr"
54	$ mkdir build	56	$ mkdir build
55	$ cd build	57	$ cd build
56	$ cmake -DCMAKE_BUILD_TYPE=Release \	58	$ cmake -DCMAKE_BUILD_TYPE=Release \
57	-DCMAKE_PREFIX_PATH="%HOMEPATH%\llvm\build\dist;path\to\device-libs" ..	59	-DCMAKE_PREFIX_PATH="%HOMEPATH%\llvm\build;%HOMEPATH%\device-libs\build" ..
58	$ msbuild ALL_BUILD.vcxproj	60	$ msbuild ALL_BUILD.vcxproj
59	$ msbuild RUN_TESTS.vcxproj	61	$ msbuild RUN_TESTS.vcxproj
60		62