1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <string> 18#include <vector> 19#include <sstream> 20 21#include "common_runtime_test.h" 22 23#include "base/stringprintf.h" 24#include "runtime/arch/instruction_set.h" 25#include "runtime/gc/heap.h" 26#include "runtime/gc/space/image_space.h" 27#include "runtime/os.h" 28#include "runtime/utils.h" 29#include "utils.h" 30 31#include <sys/types.h> 32#include <unistd.h> 33 34namespace art { 35 36class OatDumpTest : public CommonRuntimeTest { 37 protected: 38 virtual void SetUp() { 39 CommonRuntimeTest::SetUp(); 40 core_art_location_ = GetCoreArtLocation(); 41 core_oat_location_ = GetSystemImageFilename(GetCoreOatLocation().c_str(), kRuntimeISA); 42 } 43 44 // Returns path to the oatdump binary. 45 std::string GetOatDumpFilePath() { 46 std::string root = GetTestAndroidRoot(); 47 root += "/bin/oatdump"; 48 if (kIsDebugBuild) { 49 root += "d"; 50 } 51 return root; 52 } 53 54 enum Mode { 55 kModeOat, 56 kModeArt, 57 kModeSymbolize, 58 }; 59 60 // Run the test with custom arguments. 61 bool Exec(Mode mode, const std::vector<std::string>& args, std::string* error_msg) { 62 std::string file_path = GetOatDumpFilePath(); 63 64 EXPECT_TRUE(OS::FileExists(file_path.c_str())) << file_path << " should be a valid file path"; 65 66 std::vector<std::string> exec_argv = { file_path }; 67 if (mode == kModeSymbolize) { 68 exec_argv.push_back("--symbolize=" + core_oat_location_); 69 exec_argv.push_back("--output=" + core_oat_location_ + ".symbolize"); 70 } else if (mode == kModeArt) { 71 exec_argv.push_back("--image=" + core_art_location_); 72 exec_argv.push_back("--instruction-set=" + std::string(GetInstructionSetString(kRuntimeISA))); 73 exec_argv.push_back("--output=/dev/null"); 74 } else { 75 CHECK_EQ(static_cast<size_t>(mode), static_cast<size_t>(kModeOat)); 76 exec_argv.push_back("--oat-file=" + core_oat_location_); 77 exec_argv.push_back("--output=/dev/null"); 78 } 79 exec_argv.insert(exec_argv.end(), args.begin(), args.end()); 80 return ::art::Exec(exec_argv, error_msg); 81 } 82 83 private: 84 std::string core_art_location_; 85 std::string core_oat_location_; 86}; 87 88// Disable tests on arm and mips as they are taking too long to run. b/27824283. 89#if !defined(__arm__) && !defined(__mips__) 90TEST_F(OatDumpTest, TestImage) { 91 std::string error_msg; 92 ASSERT_TRUE(Exec(kModeArt, {}, &error_msg)) << error_msg; 93} 94 95TEST_F(OatDumpTest, TestOatImage) { 96 std::string error_msg; 97 ASSERT_TRUE(Exec(kModeOat, {}, &error_msg)) << error_msg; 98} 99 100TEST_F(OatDumpTest, TestNoDumpVmap) { 101 std::string error_msg; 102 ASSERT_TRUE(Exec(kModeArt, {"--no-dump:vmap"}, &error_msg)) << error_msg; 103} 104 105TEST_F(OatDumpTest, TestNoDisassemble) { 106 std::string error_msg; 107 ASSERT_TRUE(Exec(kModeArt, {"--no-disassemble"}, &error_msg)) << error_msg; 108} 109 110TEST_F(OatDumpTest, TestListClasses) { 111 std::string error_msg; 112 ASSERT_TRUE(Exec(kModeArt, {"--list-classes"}, &error_msg)) << error_msg; 113} 114 115TEST_F(OatDumpTest, TestListMethods) { 116 std::string error_msg; 117 ASSERT_TRUE(Exec(kModeArt, {"--list-methods"}, &error_msg)) << error_msg; 118} 119 120TEST_F(OatDumpTest, TestSymbolize) { 121 std::string error_msg; 122 ASSERT_TRUE(Exec(kModeSymbolize, {}, &error_msg)) << error_msg; 123} 124#endif 125} // namespace art 126