SymbolTable.cpp revision 1e4b0e54a3db31bdbcb9385bf22bab4b96096d1f
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 "process/SymbolTable.h" 18 19#include <iostream> 20 21#include "android-base/logging.h" 22#include "android-base/stringprintf.h" 23#include "androidfw/AssetManager.h" 24#include "androidfw/ResourceTypes.h" 25 26#include "ConfigDescription.h" 27#include "NameMangler.h" 28#include "Resource.h" 29#include "ResourceUtils.h" 30#include "ValueVisitor.h" 31#include "util/Util.h" 32 33using android::StringPiece; 34 35namespace aapt { 36 37SymbolTable::SymbolTable(NameMangler* mangler) 38 : mangler_(mangler), 39 delegate_(util::make_unique<DefaultSymbolTableDelegate>()), 40 cache_(200), 41 id_cache_(200) { 42} 43 44void SymbolTable::SetDelegate(std::unique_ptr<ISymbolTableDelegate> delegate) { 45 CHECK(delegate != nullptr) << "can't set a nullptr delegate"; 46 delegate_ = std::move(delegate); 47 48 // Clear the cache in case this delegate changes the order of lookup. 49 cache_.clear(); 50} 51 52void SymbolTable::AppendSource(std::unique_ptr<ISymbolSource> source) { 53 sources_.push_back(std::move(source)); 54 55 // We do not clear the cache, because sources earlier in the list take 56 // precedent. 57} 58 59void SymbolTable::PrependSource(std::unique_ptr<ISymbolSource> source) { 60 sources_.insert(sources_.begin(), std::move(source)); 61 62 // We must clear the cache in case we did a lookup before adding this 63 // resource. 64 cache_.clear(); 65} 66 67const SymbolTable::Symbol* SymbolTable::FindByName(const ResourceName& name) { 68 const ResourceName* name_with_package = &name; 69 70 // Fill in the package name if necessary. 71 // If there is no package in `name`, we will need to copy the ResourceName 72 // and store it somewhere; we use the Maybe<> class to reserve storage. 73 Maybe<ResourceName> name_with_package_impl; 74 if (name.package.empty()) { 75 name_with_package_impl = ResourceName(mangler_->GetTargetPackageName(), name.type, name.entry); 76 name_with_package = &name_with_package_impl.value(); 77 } 78 79 // We store the name unmangled in the cache, so look it up as-is. 80 if (const std::shared_ptr<Symbol>& s = cache_.get(*name_with_package)) { 81 return s.get(); 82 } 83 84 // The name was not found in the cache. Mangle it (if necessary) and find it in our sources. 85 // Again, here we use a Maybe<> object to reserve storage if we need to mangle. 86 const ResourceName* mangled_name = name_with_package; 87 Maybe<ResourceName> mangled_name_impl; 88 if (mangler_->ShouldMangle(name_with_package->package)) { 89 mangled_name_impl = mangler_->MangleName(*name_with_package); 90 mangled_name = &mangled_name_impl.value(); 91 } 92 93 std::unique_ptr<Symbol> symbol = delegate_->FindByName(*mangled_name, sources_); 94 if (symbol == nullptr) { 95 return nullptr; 96 } 97 98 // Take ownership of the symbol into a shared_ptr. We do this because 99 // LruCache doesn't support unique_ptr. 100 std::shared_ptr<Symbol> shared_symbol(std::move(symbol)); 101 102 // Since we look in the cache with the unmangled, but package prefixed 103 // name, we must put the same name into the cache. 104 cache_.put(*name_with_package, shared_symbol); 105 106 if (shared_symbol->id) { 107 // The symbol has an ID, so we can also cache this! 108 id_cache_.put(shared_symbol->id.value(), shared_symbol); 109 } 110 111 // Returns the raw pointer. Callers are not expected to hold on to this 112 // between calls to Find*. 113 return shared_symbol.get(); 114} 115 116const SymbolTable::Symbol* SymbolTable::FindById(const ResourceId& id) { 117 if (const std::shared_ptr<Symbol>& s = id_cache_.get(id)) { 118 return s.get(); 119 } 120 121 // We did not find it in the cache, so look through the sources. 122 std::unique_ptr<Symbol> symbol = delegate_->FindById(id, sources_); 123 if (symbol == nullptr) { 124 return nullptr; 125 } 126 127 // Take ownership of the symbol into a shared_ptr. We do this because LruCache 128 // doesn't support unique_ptr. 129 std::shared_ptr<Symbol> shared_symbol(std::move(symbol)); 130 id_cache_.put(id, shared_symbol); 131 132 // Returns the raw pointer. Callers are not expected to hold on to this 133 // between calls to Find*. 134 return shared_symbol.get(); 135} 136 137const SymbolTable::Symbol* SymbolTable::FindByReference(const Reference& ref) { 138 // First try the ID. This is because when we lookup by ID, we only fill in the ID cache. 139 // Looking up by name fills in the name and ID cache. So a cache miss will cause a failed 140 // ID lookup, then a successful name lookup. Subsequent look ups will hit immediately 141 // because the ID is cached too. 142 // 143 // If we looked up by name first, a cache miss would mean we failed to lookup by name, then 144 // succeeded to lookup by ID. Subsequent lookups will miss then hit. 145 const SymbolTable::Symbol* symbol = nullptr; 146 if (ref.id) { 147 symbol = FindById(ref.id.value()); 148 } 149 150 if (ref.name && !symbol) { 151 symbol = FindByName(ref.name.value()); 152 } 153 return symbol; 154} 155 156std::unique_ptr<SymbolTable::Symbol> DefaultSymbolTableDelegate::FindByName( 157 const ResourceName& name, const std::vector<std::unique_ptr<ISymbolSource>>& sources) { 158 for (auto& source : sources) { 159 std::unique_ptr<SymbolTable::Symbol> symbol = source->FindByName(name); 160 if (symbol) { 161 return symbol; 162 } 163 } 164 return {}; 165} 166 167std::unique_ptr<SymbolTable::Symbol> DefaultSymbolTableDelegate::FindById( 168 ResourceId id, const std::vector<std::unique_ptr<ISymbolSource>>& sources) { 169 for (auto& source : sources) { 170 std::unique_ptr<SymbolTable::Symbol> symbol = source->FindById(id); 171 if (symbol) { 172 return symbol; 173 } 174 } 175 return {}; 176} 177 178std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::FindByName( 179 const ResourceName& name) { 180 Maybe<ResourceTable::SearchResult> result = table_->FindResource(name); 181 if (!result) { 182 if (name.type == ResourceType::kAttr) { 183 // Recurse and try looking up a private attribute. 184 return FindByName(ResourceName(name.package, ResourceType::kAttrPrivate, name.entry)); 185 } 186 return {}; 187 } 188 189 ResourceTable::SearchResult sr = result.value(); 190 191 std::unique_ptr<SymbolTable::Symbol> symbol = util::make_unique<SymbolTable::Symbol>(); 192 symbol->is_public = (sr.entry->symbol_status.state == SymbolState::kPublic); 193 194 if (sr.package->id && sr.type->id && sr.entry->id) { 195 symbol->id = ResourceId(sr.package->id.value(), sr.type->id.value(), sr.entry->id.value()); 196 } 197 198 if (name.type == ResourceType::kAttr || name.type == ResourceType::kAttrPrivate) { 199 const ConfigDescription kDefaultConfig; 200 ResourceConfigValue* config_value = sr.entry->FindValue(kDefaultConfig); 201 if (config_value) { 202 // This resource has an Attribute. 203 if (Attribute* attr = ValueCast<Attribute>(config_value->value.get())) { 204 symbol->attribute = std::make_shared<Attribute>(*attr); 205 } else { 206 return {}; 207 } 208 } 209 } 210 return symbol; 211} 212 213bool AssetManagerSymbolSource::AddAssetPath(const StringPiece& path) { 214 int32_t cookie = 0; 215 return assets_.addAssetPath(android::String8(path.data(), path.size()), &cookie); 216} 217 218std::map<size_t, std::string> AssetManagerSymbolSource::GetAssignedPackageIds() const { 219 std::map<size_t, std::string> package_map; 220 const android::ResTable& table = assets_.getResources(false); 221 const size_t package_count = table.getBasePackageCount(); 222 for (size_t i = 0; i < package_count; i++) { 223 package_map[table.getBasePackageId(i)] = 224 util::Utf16ToUtf8(android::StringPiece16(table.getBasePackageName(i).string())); 225 } 226 return package_map; 227} 228 229static std::unique_ptr<SymbolTable::Symbol> LookupAttributeInTable( 230 const android::ResTable& table, ResourceId id) { 231 // Try as a bag. 232 const android::ResTable::bag_entry* entry; 233 ssize_t count = table.lockBag(id.id, &entry); 234 if (count < 0) { 235 table.unlockBag(entry); 236 return nullptr; 237 } 238 239 // We found a resource. 240 std::unique_ptr<SymbolTable::Symbol> s = util::make_unique<SymbolTable::Symbol>(); 241 s->id = id; 242 243 // Check to see if it is an attribute. 244 for (size_t i = 0; i < (size_t)count; i++) { 245 if (entry[i].map.name.ident == android::ResTable_map::ATTR_TYPE) { 246 s->attribute = std::make_shared<Attribute>(false); 247 s->attribute->type_mask = entry[i].map.value.data; 248 break; 249 } 250 } 251 252 if (s->attribute) { 253 for (size_t i = 0; i < (size_t)count; i++) { 254 const android::ResTable_map& map_entry = entry[i].map; 255 if (Res_INTERNALID(map_entry.name.ident)) { 256 switch (map_entry.name.ident) { 257 case android::ResTable_map::ATTR_MIN: 258 s->attribute->min_int = static_cast<int32_t>(map_entry.value.data); 259 break; 260 case android::ResTable_map::ATTR_MAX: 261 s->attribute->max_int = static_cast<int32_t>(map_entry.value.data); 262 break; 263 } 264 continue; 265 } 266 267 android::ResTable::resource_name entry_name; 268 if (!table.getResourceName(map_entry.name.ident, false, &entry_name)) { 269 table.unlockBag(entry); 270 return nullptr; 271 } 272 273 Maybe<ResourceName> parsed_name = ResourceUtils::ToResourceName(entry_name); 274 if (!parsed_name) { 275 return nullptr; 276 } 277 278 Attribute::Symbol symbol; 279 symbol.symbol.name = parsed_name.value(); 280 symbol.symbol.id = ResourceId(map_entry.name.ident); 281 symbol.value = map_entry.value.data; 282 s->attribute->symbols.push_back(std::move(symbol)); 283 } 284 } 285 table.unlockBag(entry); 286 return s; 287} 288 289std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindByName( 290 const ResourceName& name) { 291 const android::ResTable& table = assets_.getResources(false); 292 293 const std::u16string package16 = util::Utf8ToUtf16(name.package); 294 const std::u16string type16 = util::Utf8ToUtf16(ToString(name.type)); 295 const std::u16string entry16 = util::Utf8ToUtf16(name.entry); 296 297 uint32_t type_spec_flags = 0; 298 ResourceId res_id = table.identifierForName( 299 entry16.data(), entry16.size(), type16.data(), type16.size(), 300 package16.data(), package16.size(), &type_spec_flags); 301 if (!res_id.is_valid()) { 302 return {}; 303 } 304 305 std::unique_ptr<SymbolTable::Symbol> s; 306 if (name.type == ResourceType::kAttr) { 307 s = LookupAttributeInTable(table, res_id); 308 } else { 309 s = util::make_unique<SymbolTable::Symbol>(); 310 s->id = res_id; 311 } 312 313 if (s) { 314 s->is_public = (type_spec_flags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0; 315 return s; 316 } 317 return {}; 318} 319 320static Maybe<ResourceName> GetResourceName(const android::ResTable& table, 321 ResourceId id) { 322 android::ResTable::resource_name res_name = {}; 323 if (!table.getResourceName(id.id, true, &res_name)) { 324 return {}; 325 } 326 return ResourceUtils::ToResourceName(res_name); 327} 328 329std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindById( 330 ResourceId id) { 331 if (!id.is_valid()) { 332 // Exit early and avoid the error logs from AssetManager. 333 return {}; 334 } 335 336 const android::ResTable& table = assets_.getResources(false); 337 Maybe<ResourceName> maybe_name = GetResourceName(table, id); 338 if (!maybe_name) { 339 return {}; 340 } 341 342 uint32_t type_spec_flags = 0; 343 table.getResourceFlags(id.id, &type_spec_flags); 344 345 std::unique_ptr<SymbolTable::Symbol> s; 346 if (maybe_name.value().type == ResourceType::kAttr) { 347 s = LookupAttributeInTable(table, id); 348 } else { 349 s = util::make_unique<SymbolTable::Symbol>(); 350 s->id = id; 351 } 352 353 if (s) { 354 s->is_public = (type_spec_flags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0; 355 return s; 356 } 357 return {}; 358} 359 360std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindByReference( 361 const Reference& ref) { 362 // AssetManager always prefers IDs. 363 if (ref.id) { 364 return FindById(ref.id.value()); 365 } else if (ref.name) { 366 return FindByName(ref.name.value()); 367 } 368 return {}; 369} 370 371} // namespace aapt 372