Reset failure flag before retrying stub compilation.

src/stub-cache.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 95 matching lines @@
   primary->key = name;
   primary->value = code;
   return code;
 }
 
 
 Handle<Code> LoadStubCompiler::CompileLoadNonexistent(Handle<String> name,
                                                       Handle<JSObject> object,
                                                       Handle<JSObject> last) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadNonexistent(*name, *object, *last),
+                     (set_failure(NULL),
+                      CompileLoadNonexistent(*name, *object, *last)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeLoadNonexistent(Handle<String> name,
                                                Handle<JSObject> receiver) {
   ASSERT(receiver->IsGlobalObject() || receiver->HasFastProperties());
   // If no global objects are present in the prototype chain, the load
   // nonexistent IC stub can be shared for all names for a given map
   // and we use the empty string for the map cache in that case.  If
@@ skipping 22 matching lines @@
   JSObject::UpdateMapCodeCache(isolate_, receiver, cache_name, code);
   return code;
 }
 
 
 Handle<Code> LoadStubCompiler::CompileLoadField(Handle<JSObject> object,
                                                 Handle<JSObject> holder,
                                                 int index,
                                                 Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadField(*object, *holder, index, *name),
+                     (set_failure(NULL),
+                      CompileLoadField(*object, *holder, index, *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeLoadField(Handle<String> name,
                                          Handle<JSObject> receiver,
                                          Handle<JSObject> holder,
                                          int field_index) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   LoadStubCompiler compiler(isolate_);
   Handle<Code> code =
       compiler.CompileLoadField(receiver, holder, field_index, name);
   PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> LoadStubCompiler::CompileLoadCallback(
     Handle<String> name,
     Handle<JSObject> object,
     Handle<JSObject> holder,
     Handle<AccessorInfo> callback) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadCallback(*name, *object, *holder, *callback),
+                     (set_failure(NULL),
+                      CompileLoadCallback(*name, *object, *holder, *callback)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeLoadCallback(Handle<String> name,
                                             Handle<JSObject> receiver,
                                             Handle<JSObject> holder,
                                             Handle<AccessorInfo> callback) {
   ASSERT(v8::ToCData<Address>(callback->getter()) != 0);
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   LoadStubCompiler compiler(isolate_);
   Handle<Code> code =
       compiler.CompileLoadCallback(name, receiver, holder, callback);
   PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> LoadStubCompiler::CompileLoadConstant(Handle<JSObject> object,
                                                    Handle<JSObject> holder,
                                                    Handle<Object> value,
                                                    Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadConstant(*object, *holder, *value, *name),
+                     (set_failure(NULL),
+                      CompileLoadConstant(*object, *holder, *value, *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeLoadConstant(Handle<String> name,
                                             Handle<JSObject> receiver,
                                             Handle<JSObject> holder,
                                             Handle<Object> value) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   LoadStubCompiler compiler(isolate_);
   Handle<Code> code =
         compiler.CompileLoadConstant(receiver, holder, value, name);
   PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> LoadStubCompiler::CompileLoadInterceptor(Handle<JSObject> object,
                                                       Handle<JSObject> holder,
                                                       Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadInterceptor(*object, *holder, *name),
+                     (set_failure(NULL),
+                      CompileLoadInterceptor(*object, *holder, *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeLoadInterceptor(Handle<String> name,
                                                Handle<JSObject> receiver,
                                                Handle<JSObject> holder) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
@@ skipping 13 matching lines @@
   return isolate_->builtins()->LoadIC_Normal();
 }
 
 Handle<Code> LoadStubCompiler::CompileLoadGlobal(
     Handle<JSObject> object,
     Handle<GlobalObject> holder,
     Handle<JSGlobalPropertyCell> cell,
     Handle<String> name,
     bool is_dont_delete) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadGlobal(*object,
-                                       *holder,
-                                       *cell,
-                                       *name,
-                                       is_dont_delete),
+                     (set_failure(NULL),
+                      CompileLoadGlobal(
+                          *object, *holder, *cell, *name, is_dont_delete)),
                      Code);
 }
 Handle<Code> StubCache::ComputeLoadGlobal(Handle<String> name,
                                           Handle<JSObject> receiver,
                                           Handle<GlobalObject> holder,
                                           Handle<JSGlobalPropertyCell> cell,
                                           bool is_dont_delete) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, NORMAL);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   LoadStubCompiler compiler(isolate_);
   Handle<Code> code =
       compiler.CompileLoadGlobal(receiver, holder, cell, name, is_dont_delete);
   PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> KeyedLoadStubCompiler::CompileLoadField(Handle<String> name,
                                                      Handle<JSObject> object,
                                                      Handle<JSObject> holder,
                                                      int index) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadField(*name, *object, *holder, index),
+                     (set_failure(NULL),
+                      CompileLoadField(*name, *object, *holder, index)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeKeyedLoadField(Handle<String> name,
                                               Handle<JSObject> receiver,
                                               Handle<JSObject> holder,
                                               int field_index) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   KeyedLoadStubCompiler compiler(isolate_);
   Handle<Code> code =
       compiler.CompileLoadField(name, receiver, holder, field_index);
   PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> KeyedLoadStubCompiler::CompileLoadConstant(Handle<String> name,
                                                         Handle<JSObject> object,
                                                         Handle<JSObject> holder,
                                                         Handle<Object> value) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadConstant(*name, *object, *holder, *value),
+                     (set_failure(NULL),
+                      CompileLoadConstant(*name, *object, *holder, *value)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<String> name,
                                                  Handle<JSObject> receiver,
                                                  Handle<JSObject> holder,
                                                  Handle<Object> value) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   KeyedLoadStubCompiler compiler(isolate_);
   Handle<Code> code =
       compiler.CompileLoadConstant(name, receiver, holder, value);
   PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> KeyedLoadStubCompiler::CompileLoadInterceptor(
     Handle<JSObject> object,
     Handle<JSObject> holder,
     Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadInterceptor(*object, *holder, *name),
+                     (set_failure(NULL),
+                      CompileLoadInterceptor(*object, *holder, *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<String> name,
                                                     Handle<JSObject> receiver,
                                                     Handle<JSObject> holder) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   KeyedLoadStubCompiler compiler(isolate_);
   Handle<Code> code = compiler.CompileLoadInterceptor(receiver, holder, name);
   PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> KeyedLoadStubCompiler::CompileLoadCallback(
     Handle<String> name,
     Handle<JSObject> object,
     Handle<JSObject> holder,
     Handle<AccessorInfo> callback) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadCallback(*name, *object, *holder, *callback),
+                     (set_failure(NULL),
+                      CompileLoadCallback(*name, *object, *holder, *callback)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeKeyedLoadCallback(
     Handle<String> name,
     Handle<JSObject> receiver,
     Handle<JSObject> holder,
     Handle<AccessorInfo> callback) {
   ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   KeyedLoadStubCompiler compiler(isolate_);
   Handle<Code> code =
       compiler.CompileLoadCallback(name, receiver, holder, callback);
   PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> KeyedLoadStubCompiler::CompileLoadArrayLength(
     Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadArrayLength(*name),
+                     (set_failure(NULL),
+                      CompileLoadArrayLength(*name)),
                      Code);
 }
 
 Handle<Code> StubCache::ComputeKeyedLoadArrayLength(Handle<String> name,
                                                     Handle<JSArray> receiver) {
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   KeyedLoadStubCompiler compiler(isolate_);
   Handle<Code> code = compiler.CompileLoadArrayLength(name);
   PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> KeyedLoadStubCompiler::CompileLoadStringLength(
     Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadStringLength(*name),
+                     (set_failure(NULL),
+                      CompileLoadStringLength(*name)),
                      Code);
 }
 
 Handle<Code> StubCache::ComputeKeyedLoadStringLength(Handle<String> name,
                                                      Handle<String> receiver) {
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
   Handle<Map> map(receiver->map());
   Handle<Object> probe(map->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   KeyedLoadStubCompiler compiler(isolate_);
   Handle<Code> code = compiler.CompileLoadStringLength(name);
   PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
   Map::UpdateCodeCache(map, name, code);
   return code;
 }
 
 
 Handle<Code> KeyedLoadStubCompiler::CompileLoadFunctionPrototype(
     Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileLoadFunctionPrototype(*name),
+                     (set_failure(NULL),
+                      CompileLoadFunctionPrototype(*name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeKeyedLoadFunctionPrototype(
     Handle<String> name,
     Handle<JSFunction> receiver) {
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   KeyedLoadStubCompiler compiler(isolate_);
   Handle<Code> code = compiler.CompileLoadFunctionPrototype(name);
   PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,
                                                   int index,
                                                   Handle<Map> transition,
                                                   Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileStoreField(*object,
-                                       index,
-                                       (transition.is_null()
-                                           ? NULL
-                                           : *transition),
-                                       *name),
+                     (set_failure(NULL),
+                      CompileStoreField(
+                          *object,
+                          index,
+                          (transition.is_null() ? NULL : *transition),
+                          *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeStoreField(Handle<String> name,
                                           Handle<JSObject> receiver,
                                           int field_index,
                                           Handle<Map> transition,
                                           StrictModeFlag strict_mode) {
   PropertyType type = (transition.is_null()) ? FIELD : MAP_TRANSITION;
@@ skipping 83 matching lines @@
       ? isolate_->builtins()->Builtins::StoreIC_Normal_Strict()
       : isolate_->builtins()->Builtins::StoreIC_Normal();
 }
 
 
 Handle<Code> StoreStubCompiler::CompileStoreGlobal(
     Handle<GlobalObject> object,
     Handle<JSGlobalPropertyCell> holder,
     Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileStoreGlobal(*object, *holder, *name),
+                     (set_failure(NULL),
+                      CompileStoreGlobal(*object, *holder, *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeStoreGlobal(Handle<String> name,
                                            Handle<GlobalObject> receiver,
                                            Handle<JSGlobalPropertyCell> cell,
                                            StrictModeFlag strict_mode) {
   Code::Flags flags = Code::ComputeMonomorphicFlags(
       Code::STORE_IC, NORMAL, strict_mode);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   StoreStubCompiler compiler(isolate_, strict_mode);
   Handle<Code> code = compiler.CompileStoreGlobal(receiver, cell, name);
   PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> StoreStubCompiler::CompileStoreCallback(
     Handle<JSObject> object,
     Handle<AccessorInfo> callback,
     Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileStoreCallback(*object, *callback, *name),
+                     (set_failure(NULL),
+                      CompileStoreCallback(*object, *callback, *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeStoreCallback(Handle<String> name,
                                              Handle<JSObject> receiver,
                                              Handle<AccessorInfo> callback,
                                              StrictModeFlag strict_mode) {
   ASSERT(v8::ToCData<Address>(callback->setter()) != 0);
   Code::Flags flags = Code::ComputeMonomorphicFlags(
       Code::STORE_IC, CALLBACKS, strict_mode);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   StoreStubCompiler compiler(isolate_, strict_mode);
   Handle<Code> code = compiler.CompileStoreCallback(receiver, callback, name);
   PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
 Handle<Code> StoreStubCompiler::CompileStoreInterceptor(Handle<JSObject> object,
                                                         Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileStoreInterceptor(*object, *name),
+                     (set_failure(NULL),
+                      CompileStoreInterceptor(*object, *name)),
                      Code);
 }
 
 
 Handle<Code> StubCache::ComputeStoreInterceptor(Handle<String> name,
                                                 Handle<JSObject> receiver,
                                                 StrictModeFlag strict_mode) {
   Code::Flags flags = Code::ComputeMonomorphicFlags(
       Code::STORE_IC, INTERCEPTOR, strict_mode);
   Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   StoreStubCompiler compiler(isolate_, strict_mode);
   Handle<Code> code = compiler.CompileStoreInterceptor(receiver, name);
   PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
   GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
   JSObject::UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 Handle<Code> KeyedStoreStubCompiler::CompileStoreField(Handle<JSObject> object,
                                                        int index,
                                                        Handle<Map> transition,
                                                        Handle<String> name) {
   CALL_HEAP_FUNCTION(isolate(),
-                     CompileStoreField(*object, index,
-                                       (transition.is_null()
-                                           ? NULL
-                                           : *transition),
-                                       *name),
+                     (set_failure(NULL),
+                      CompileStoreField(
+                          *object,
+                          index,
+                          (transition.is_null() ? NULL : *transition),
+                          *name)),
                      Code);
 }
 
 Handle<Code> StubCache::ComputeKeyedStoreField(Handle<String> name,
                                                Handle<JSObject> receiver,
                                                int field_index,
                                                Handle<Map> transition,
                                                StrictModeFlag strict_mode) {
   PropertyType type = (transition.is_null()) ? FIELD : MAP_TRANSITION;
   Code::Flags flags = Code::ComputeMonomorphicFlags(
@@ skipping 1225 matching lines @@
       expected_receiver_type_ =
           FunctionTemplateInfo::cast(signature->receiver());
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal