| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <android/librsloader.h> |
| #include <cutils/log.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <sys/mman.h> |
| |
| #include "utils_llvm.h" |
| |
| #include "class_loader.h" |
| #include "object.h" |
| #include "object_utils.h" |
| |
| namespace art { |
| |
| std::string MangleForLLVM(const std::string& s) { |
| std::string result; |
| size_t char_count = CountModifiedUtf8Chars(s.c_str()); |
| const char* cp = &s[0]; |
| for (size_t i = 0; i < char_count; ++i) { |
| uint16_t ch = GetUtf16FromUtf8(&cp); |
| if (ch == '$' || ch == '<' || ch == '>' || ch > 127) { |
| StringAppendF(&result, "_0%04x", ch); |
| } else { |
| switch (ch) { |
| case '_': |
| result += "_1"; |
| break; |
| case ';': |
| result += "_2"; |
| break; |
| case '[': |
| result += "_3"; |
| break; |
| case '/': |
| result += "_"; |
| break; |
| default: |
| result.push_back(ch); |
| break; |
| } |
| } |
| } |
| return result; |
| } |
| |
| std::string LLVMShortName(const Method* m) { |
| MethodHelper mh(m); |
| std::string class_name(mh.GetDeclaringClassDescriptor()); |
| // Remove the leading 'L' and trailing ';'... |
| CHECK_EQ(class_name[0], 'L') << class_name; |
| CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name; |
| class_name.erase(0, 1); |
| class_name.erase(class_name.size() - 1, 1); |
| |
| std::string method_name(mh.GetName()); |
| |
| std::string short_name; |
| short_name += "Art_"; |
| short_name += MangleForLLVM(class_name); |
| short_name += "_"; |
| short_name += MangleForLLVM(method_name); |
| return short_name; |
| } |
| |
| std::string LLVMLongName(const Method* m) { |
| std::string long_name; |
| long_name += LLVMShortName(m); |
| long_name += "__"; |
| |
| std::string signature(MethodHelper(m).GetSignature()); |
| signature.erase(0, 1); |
| signature.erase(signature.begin() + signature.find(')'), signature.end()); |
| |
| long_name += MangleForLLVM(signature); |
| |
| return long_name; |
| } |
| |
| std::string LLVMStubName(const Method* m) { |
| MethodHelper mh(m); |
| std::string stub_name; |
| if (m->IsStatic()) { |
| stub_name += "ArtSUpcall_"; |
| } else { |
| stub_name += "ArtUpcall_"; |
| } |
| stub_name += mh.GetShorty(); |
| |
| return stub_name; |
| } |
| |
| // TODO: Remove these when art_llvm.ll runtime support is ready. |
| void art_push_shadow_frame_from_code(void* frame) { |
| } |
| |
| void art_pop_shadow_frame_from_code() { |
| } |
| |
| int art_is_exception_pending_from_code() { |
| return 0; |
| } |
| |
| void art_test_suspend_from_code() { |
| } |
| |
| void art_set_current_thread_from_code(void* thread_object_addr) { |
| } |
| |
| // Linker's call back function. Added some for debugging. |
| void* find_sym(void* context, char const* name) { |
| struct func_entry_t { |
| char const* name; |
| size_t name_len; |
| void* addr; |
| }; |
| |
| static struct func_entry_t const tab[] = { |
| #define DEF(NAME, ADDR) \ |
| { NAME, sizeof(NAME) - 1, (void *)(&(ADDR)) }, |
| |
| DEF("art_push_shadow_frame_from_code", art_push_shadow_frame_from_code) |
| DEF("art_pop_shadow_frame_from_code", art_pop_shadow_frame_from_code) |
| DEF("art_is_exception_pending_from_code", art_is_exception_pending_from_code) |
| DEF("art_test_suspend_from_code", art_test_suspend_from_code) |
| DEF("art_set_current_thread_from_code", art_set_current_thread_from_code) |
| DEF("printf", printf) |
| DEF("scanf", scanf) |
| DEF("__isoc99_scanf", scanf) |
| DEF("rand", rand) |
| DEF("time", time) |
| DEF("srand", srand) |
| #undef DEF |
| }; |
| |
| static size_t const tab_size = sizeof(tab) / sizeof(struct func_entry_t); |
| |
| // Note: Since our table is small, we are using trivial O(n) searching |
| // function. For bigger table, it will be better to use binary |
| // search or hash function. |
| size_t i; |
| size_t name_len = strlen(name); |
| for (i = 0; i < tab_size; ++i) { |
| if (name_len == tab[i].name_len && strcmp(name, tab[i].name) == 0) { |
| return tab[i].addr; |
| } |
| } |
| |
| LOG(FATAL) << "Error: Can't find symbol " << name; |
| return 0; |
| } |
| |
| void LLVMLinkLoadMethod(const std::string& file_name, Method* method) { |
| CHECK(method != NULL); |
| |
| int fd = open(file_name.c_str(), O_RDONLY); |
| CHECK(fd >= 0) << "Error: ELF not found: " << file_name; |
| |
| struct stat sb; |
| CHECK(fstat(fd, &sb) == 0) << "Error: Unable to stat ELF: " << file_name; |
| |
| unsigned char const *image = (unsigned char const *) |
| mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0); |
| CHECK(image != MAP_FAILED) << "Error: Unable to mmap ELF: " << file_name; |
| |
| RSExecRef relocatable = rsloaderCreateExec(image, sb.st_size, find_sym, 0); |
| CHECK(relocatable) << "Error: Unable to load ELF: " << file_name; |
| |
| const void *addr = rsloaderGetSymbolAddress(relocatable, LLVMLongName(method).c_str()); |
| CHECK(addr) << "Error: ELF (" << file_name << ") has no symbol " << LLVMLongName(method); |
| method->SetCode(reinterpret_cast<const uint32_t*>(addr)); |
| |
| method->SetFrameSizeInBytes(0); |
| method->SetCoreSpillMask(0); |
| method->SetFpSpillMask(0); |
| method->SetMappingTable(reinterpret_cast<const uint32_t*>(NULL)); |
| method->SetVmapTable(reinterpret_cast<const uint16_t*>(NULL)); |
| method->SetGcMap(reinterpret_cast<const uint8_t*>(NULL)); |
| |
| addr = rsloaderGetSymbolAddress(relocatable, LLVMStubName(method).c_str()); |
| CHECK(addr) << "Error: ELF (" << file_name << ") has no symbol " << LLVMStubName(method); |
| method->SetInvokeStub(reinterpret_cast<void (*)(const art::Method*, art::Object*, art::Thread*, |
| art::byte*, art::JValue*)>(addr)); |
| |
| close(fd); |
| } |
| |
| } // namespace art |