Skip to content

Commit 3d9e2ea

Browse files
mi-acCommit bot
mi-ac
authored and
Commit bot
committed
Revert of [TypeFeedbackVector] Root literal arrays in function literals slots (patchset v8#7 id:120001 of https://codereview.chromium.org/2620753003/ )
Reason for revert: gc stress: https://build.chromium.org/p/client.v8/builders/V8%20Linux%20-%20gc%20stress/builds/8105 also on mac Original issue's description: > [TypeFeedbackVector] Root literal arrays in function literals slots > > Literal arrays and feedback vectors for a function can be garbage > collected if we don't have a rooted closure for the function, which > happens often. It's expensive to come back from this (recreating > boilerplates and gathering feedback again), and the cost is > disproportionate if the function was inlined into optimized code. > > To guard against losing these arrays when we need them, we'll now > create literal arrays when creating the feedback vector for the outer > closure, and root them strongly in that vector. > > BUG=v8:5456 > > Review-Url: https://codereview.chromium.org/2620753003 > Cr-Commit-Position: refs/heads/master@{#42258} > Committed: https://chromium.googlesource.com/v8/v8/+/31887804107bf5c103d915f5c601cfaaf1cd7cb6 TBR=bmeurer@chromium.org,mstarzinger@chromium.org,yangguo@chromium.org,mvstanton@chromium.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=v8:5456 Review-Url: https://codereview.chromium.org/2626863004 Cr-Commit-Position: refs/heads/master@{#42260}
1 parent cfc2e5e commit 3d9e2ea

24 files changed

Lines changed: 524 additions & 320 deletions

‎src/builtins/arm/builtins-arm.cc‎

Lines changed: 19 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1337,26 +1337,20 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13371337
Register argument_count = r0;
13381338
Register closure = r1;
13391339
Register new_target = r3;
1340-
Register map = argument_count;
1341-
Register index = r2;
1342-
1343-
// Do we have a valid feedback vector?
1344-
__ ldr(index, FieldMemOperand(closure, JSFunction::kLiteralsOffset));
1345-
__ ldr(index, FieldMemOperand(index, LiteralsArray::kFeedbackVectorOffset));
1346-
__ JumpIfRoot(index, Heap::kUndefinedValueRootIndex,
1347-
&gotta_call_runtime_no_stack);
1348-
13491340
__ push(argument_count);
13501341
__ push(new_target);
13511342
__ push(closure);
13521343

1344+
Register map = argument_count;
1345+
Register index = r2;
13531346
__ ldr(map, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
13541347
__ ldr(map,
13551348
FieldMemOperand(map, SharedFunctionInfo::kOptimizedCodeMapOffset));
13561349
__ ldr(index, FieldMemOperand(map, FixedArray::kLengthOffset));
13571350
__ cmp(index, Operand(Smi::FromInt(2)));
13581351
__ b(lt, &gotta_call_runtime);
13591352

1353+
// Find literals.
13601354
// r3 : native context
13611355
// r2 : length / index
13621356
// r0 : optimized code map
@@ -1376,6 +1370,20 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13761370
__ ldr(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
13771371
__ cmp(temp, native_context);
13781372
__ b(ne, &loop_bottom);
1373+
// Literals available?
1374+
__ ldr(temp, FieldMemOperand(array_pointer,
1375+
SharedFunctionInfo::kOffsetToPreviousLiterals));
1376+
__ ldr(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
1377+
__ JumpIfSmi(temp, &gotta_call_runtime);
1378+
1379+
// Save the literals in the closure.
1380+
__ ldr(r4, MemOperand(sp, 0));
1381+
__ str(temp, FieldMemOperand(r4, JSFunction::kLiteralsOffset));
1382+
__ push(index);
1383+
__ RecordWriteField(r4, JSFunction::kLiteralsOffset, temp, index,
1384+
kLRHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
1385+
OMIT_SMI_CHECK);
1386+
__ pop(index);
13791387

13801388
// Code available?
13811389
Register entry = r4;
@@ -1385,7 +1393,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13851393
__ ldr(entry, FieldMemOperand(entry, WeakCell::kValueOffset));
13861394
__ JumpIfSmi(entry, &try_shared);
13871395

1388-
// Found code. Get it into the closure and return.
1396+
// Found literals and code. Get them into the closure and return.
13891397
__ pop(closure);
13901398
// Store code entry in the closure.
13911399
__ add(entry, entry, Operand(Code::kHeaderSize - kHeapObjectTag));
@@ -1420,7 +1428,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
14201428
__ cmp(index, Operand(Smi::FromInt(1)));
14211429
__ b(gt, &loop_top);
14221430

1423-
// We found no code.
1431+
// We found neither literals nor code.
14241432
__ jmp(&gotta_call_runtime);
14251433

14261434
__ bind(&try_shared);

‎src/builtins/arm64/builtins-arm64.cc‎

Lines changed: 14 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1347,19 +1347,14 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13471347
Register closure = x1;
13481348
Register map = x13;
13491349
Register index = x2;
1350-
1351-
// Do we have a valid feedback vector?
1352-
__ Ldr(index, FieldMemOperand(closure, JSFunction::kLiteralsOffset));
1353-
__ Ldr(index, FieldMemOperand(index, LiteralsArray::kFeedbackVectorOffset));
1354-
__ JumpIfRoot(index, Heap::kUndefinedValueRootIndex, &gotta_call_runtime);
1355-
13561350
__ Ldr(map, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
13571351
__ Ldr(map,
13581352
FieldMemOperand(map, SharedFunctionInfo::kOptimizedCodeMapOffset));
13591353
__ Ldrsw(index, UntagSmiFieldMemOperand(map, FixedArray::kLengthOffset));
13601354
__ Cmp(index, Operand(2));
13611355
__ B(lt, &gotta_call_runtime);
13621356

1357+
// Find literals.
13631358
// x3 : native context
13641359
// x2 : length / index
13651360
// x13 : optimized code map
@@ -1379,6 +1374,17 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13791374
__ Ldr(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
13801375
__ Cmp(temp, native_context);
13811376
__ B(ne, &loop_bottom);
1377+
// Literals available?
1378+
__ Ldr(temp, FieldMemOperand(array_pointer,
1379+
SharedFunctionInfo::kOffsetToPreviousLiterals));
1380+
__ Ldr(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
1381+
__ JumpIfSmi(temp, &gotta_call_runtime);
1382+
1383+
// Save the literals in the closure.
1384+
__ Str(temp, FieldMemOperand(closure, JSFunction::kLiteralsOffset));
1385+
__ RecordWriteField(closure, JSFunction::kLiteralsOffset, temp, x7,
1386+
kLRHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
1387+
OMIT_SMI_CHECK);
13821388

13831389
// Code available?
13841390
Register entry = x7;
@@ -1388,7 +1394,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13881394
__ Ldr(entry, FieldMemOperand(entry, WeakCell::kValueOffset));
13891395
__ JumpIfSmi(entry, &try_shared);
13901396

1391-
// Found code. Get it into the closure and return.
1397+
// Found literals and code. Get them into the closure and return.
13921398
__ Add(entry, entry, Operand(Code::kHeaderSize - kHeapObjectTag));
13931399
__ Str(entry, FieldMemOperand(closure, JSFunction::kCodeEntryOffset));
13941400
__ RecordWriteCodeEntryField(closure, entry, x5);
@@ -1417,7 +1423,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
14171423
__ Cmp(index, Operand(1));
14181424
__ B(gt, &loop_top);
14191425

1420-
// We found no code.
1426+
// We found neither literals nor code.
14211427
__ B(&gotta_call_runtime);
14221428

14231429
__ Bind(&try_shared);

‎src/builtins/builtins-constructor.cc‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -120,14 +120,13 @@ Node* ConstructorBuiltinsAssembler::EmitFastNewClosure(Node* shared_info,
120120

121121
// Initialize the rest of the function.
122122
Node* empty_fixed_array = HeapConstant(factory->empty_fixed_array());
123+
Node* empty_literals_array = HeapConstant(factory->empty_literals_array());
123124
StoreObjectFieldNoWriteBarrier(result, JSObject::kPropertiesOffset,
124125
empty_fixed_array);
125126
StoreObjectFieldNoWriteBarrier(result, JSObject::kElementsOffset,
126127
empty_fixed_array);
127-
Node* literals_array = LoadFixedArrayElement(
128-
feedback_vector, slot, 0, CodeStubAssembler::SMI_PARAMETERS);
129128
StoreObjectFieldNoWriteBarrier(result, JSFunction::kLiteralsOffset,
130-
literals_array);
129+
empty_literals_array);
131130
StoreObjectFieldNoWriteBarrier(
132131
result, JSFunction::kPrototypeOrInitialMapOffset, TheHoleConstant());
133132
StoreObjectFieldNoWriteBarrier(result, JSFunction::kSharedFunctionInfoOffset,

‎src/builtins/ia32/builtins-ia32.cc‎

Lines changed: 17 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1025,12 +1025,6 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
10251025
Register new_target = edx;
10261026
Register argument_count = eax;
10271027

1028-
// Do we have a valid feedback vector?
1029-
__ mov(ebx, FieldOperand(closure, JSFunction::kLiteralsOffset));
1030-
__ mov(ebx, FieldOperand(ebx, LiteralsArray::kFeedbackVectorOffset));
1031-
__ cmp(ebx, masm->isolate()->factory()->undefined_value());
1032-
__ j(equal, &gotta_call_runtime_no_stack);
1033-
10341028
__ push(argument_count);
10351029
__ push(new_target);
10361030
__ push(closure);
@@ -1043,6 +1037,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
10431037
__ cmp(index, Immediate(Smi::FromInt(2)));
10441038
__ j(less, &gotta_call_runtime);
10451039

1040+
// Find literals.
10461041
// edx : native context
10471042
// ebx : length / index
10481043
// eax : optimized code map
@@ -1060,14 +1055,28 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
10601055
__ mov(temp, FieldOperand(temp, WeakCell::kValueOffset));
10611056
__ cmp(temp, native_context);
10621057
__ j(not_equal, &loop_bottom);
1058+
// Literals available?
1059+
__ mov(temp, FieldOperand(map, index, times_half_pointer_size,
1060+
SharedFunctionInfo::kOffsetToPreviousLiterals));
1061+
__ mov(temp, FieldOperand(temp, WeakCell::kValueOffset));
1062+
__ JumpIfSmi(temp, &gotta_call_runtime);
1063+
1064+
// Save the literals in the closure.
1065+
__ mov(ecx, Operand(esp, 0));
1066+
__ mov(FieldOperand(ecx, JSFunction::kLiteralsOffset), temp);
1067+
__ push(index);
1068+
__ RecordWriteField(ecx, JSFunction::kLiteralsOffset, temp, index,
1069+
kDontSaveFPRegs, EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
1070+
__ pop(index);
1071+
10631072
// Code available?
10641073
Register entry = ecx;
10651074
__ mov(entry, FieldOperand(map, index, times_half_pointer_size,
10661075
SharedFunctionInfo::kOffsetToPreviousCachedCode));
10671076
__ mov(entry, FieldOperand(entry, WeakCell::kValueOffset));
10681077
__ JumpIfSmi(entry, &try_shared);
10691078

1070-
// Found code. Get it into the closure and return.
1079+
// Found literals and code. Get them into the closure and return.
10711080
__ pop(closure);
10721081
// Store code entry in the closure.
10731082
__ lea(entry, FieldOperand(entry, Code::kHeaderSize));
@@ -1101,7 +1110,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
11011110
__ cmp(index, Immediate(Smi::FromInt(1)));
11021111
__ j(greater, &loop_top);
11031112

1104-
// We found no code.
1113+
// We found neither literals nor code.
11051114
__ jmp(&gotta_call_runtime);
11061115

11071116
__ bind(&try_shared);

‎src/builtins/mips/builtins-mips.cc‎

Lines changed: 19 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1349,24 +1349,18 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13491349
Register argument_count = a0;
13501350
Register closure = a1;
13511351
Register new_target = a3;
1352-
Register map = a0;
1353-
Register index = a2;
1354-
1355-
// Do we have a valid feedback vector?
1356-
__ lw(index, FieldMemOperand(closure, JSFunction::kLiteralsOffset));
1357-
__ lw(index, FieldMemOperand(index, LiteralsArray::kFeedbackVectorOffset));
1358-
__ JumpIfRoot(index, Heap::kUndefinedValueRootIndex,
1359-
&gotta_call_runtime_no_stack);
1360-
13611352
__ push(argument_count);
13621353
__ push(new_target);
13631354
__ push(closure);
13641355

1356+
Register map = a0;
1357+
Register index = a2;
13651358
__ lw(map, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
13661359
__ lw(map, FieldMemOperand(map, SharedFunctionInfo::kOptimizedCodeMapOffset));
13671360
__ lw(index, FieldMemOperand(map, FixedArray::kLengthOffset));
13681361
__ Branch(&gotta_call_runtime, lt, index, Operand(Smi::FromInt(2)));
13691362

1363+
// Find literals.
13701364
// a3 : native context
13711365
// a2 : length / index
13721366
// a0 : optimized code map
@@ -1386,6 +1380,20 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13861380
SharedFunctionInfo::kOffsetToPreviousContext));
13871381
__ lw(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
13881382
__ Branch(&loop_bottom, ne, temp, Operand(native_context));
1383+
// Literals available?
1384+
__ lw(temp, FieldMemOperand(array_pointer,
1385+
SharedFunctionInfo::kOffsetToPreviousLiterals));
1386+
__ lw(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
1387+
__ JumpIfSmi(temp, &gotta_call_runtime);
1388+
1389+
// Save the literals in the closure.
1390+
__ lw(t0, MemOperand(sp, 0));
1391+
__ sw(temp, FieldMemOperand(t0, JSFunction::kLiteralsOffset));
1392+
__ push(index);
1393+
__ RecordWriteField(t0, JSFunction::kLiteralsOffset, temp, index,
1394+
kRAHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
1395+
OMIT_SMI_CHECK);
1396+
__ pop(index);
13891397

13901398
// Code available?
13911399
Register entry = t0;
@@ -1395,7 +1403,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13951403
__ lw(entry, FieldMemOperand(entry, WeakCell::kValueOffset));
13961404
__ JumpIfSmi(entry, &try_shared);
13971405

1398-
// Found code. Get it into the closure and return.
1406+
// Found literals and code. Get them into the closure and return.
13991407
__ pop(closure);
14001408
// Store code entry in the closure.
14011409
__ Addu(entry, entry, Operand(Code::kHeaderSize - kHeapObjectTag));
@@ -1430,7 +1438,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
14301438
Operand(Smi::FromInt(SharedFunctionInfo::kEntryLength)));
14311439
__ Branch(&loop_top, gt, index, Operand(Smi::FromInt(1)));
14321440

1433-
// We found no code.
1441+
// We found neither literals nor code.
14341442
__ jmp(&gotta_call_runtime);
14351443

14361444
__ bind(&try_shared);

‎src/builtins/mips64/builtins-mips64.cc‎

Lines changed: 19 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1340,24 +1340,18 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13401340
Register argument_count = a0;
13411341
Register closure = a1;
13421342
Register new_target = a3;
1343-
Register map = a0;
1344-
Register index = a2;
1345-
1346-
// Do we have a valid feedback vector?
1347-
__ ld(index, FieldMemOperand(closure, JSFunction::kLiteralsOffset));
1348-
__ ld(index, FieldMemOperand(index, LiteralsArray::kFeedbackVectorOffset));
1349-
__ JumpIfRoot(index, Heap::kUndefinedValueRootIndex,
1350-
&gotta_call_runtime_no_stack);
1351-
13521343
__ push(argument_count);
13531344
__ push(new_target);
13541345
__ push(closure);
13551346

1347+
Register map = a0;
1348+
Register index = a2;
13561349
__ ld(map, FieldMemOperand(closure, JSFunction::kSharedFunctionInfoOffset));
13571350
__ ld(map, FieldMemOperand(map, SharedFunctionInfo::kOptimizedCodeMapOffset));
13581351
__ ld(index, FieldMemOperand(map, FixedArray::kLengthOffset));
13591352
__ Branch(&gotta_call_runtime, lt, index, Operand(Smi::FromInt(2)));
13601353

1354+
// Find literals.
13611355
// a3 : native context
13621356
// a2 : length / index
13631357
// a0 : optimized code map
@@ -1377,6 +1371,20 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13771371
SharedFunctionInfo::kOffsetToPreviousContext));
13781372
__ ld(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
13791373
__ Branch(&loop_bottom, ne, temp, Operand(native_context));
1374+
// Literals available?
1375+
__ ld(temp, FieldMemOperand(array_pointer,
1376+
SharedFunctionInfo::kOffsetToPreviousLiterals));
1377+
__ ld(temp, FieldMemOperand(temp, WeakCell::kValueOffset));
1378+
__ JumpIfSmi(temp, &gotta_call_runtime);
1379+
1380+
// Save the literals in the closure.
1381+
__ ld(a4, MemOperand(sp, 0));
1382+
__ sd(temp, FieldMemOperand(a4, JSFunction::kLiteralsOffset));
1383+
__ push(index);
1384+
__ RecordWriteField(a4, JSFunction::kLiteralsOffset, temp, index,
1385+
kRAHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
1386+
OMIT_SMI_CHECK);
1387+
__ pop(index);
13801388

13811389
// Code available?
13821390
Register entry = a4;
@@ -1386,7 +1394,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
13861394
__ ld(entry, FieldMemOperand(entry, WeakCell::kValueOffset));
13871395
__ JumpIfSmi(entry, &try_shared);
13881396

1389-
// Found code. Get it into the closure and return.
1397+
// Found literals and code. Get them into the closure and return.
13901398
__ pop(closure);
13911399
// Store code entry in the closure.
13921400
__ Daddu(entry, entry, Operand(Code::kHeaderSize - kHeapObjectTag));
@@ -1421,7 +1429,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
14211429
Operand(Smi::FromInt(SharedFunctionInfo::kEntryLength)));
14221430
__ Branch(&loop_top, gt, index, Operand(Smi::FromInt(1)));
14231431

1424-
// We found no code.
1432+
// We found neither literals nor code.
14251433
__ jmp(&gotta_call_runtime);
14261434

14271435
__ bind(&try_shared);

‎src/builtins/x64/builtins-x64.cc‎

Lines changed: 14 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -994,18 +994,13 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
994994
Register closure = rdi;
995995
Register map = r8;
996996
Register index = r9;
997-
998-
// Do we have a valid feedback vector?
999-
__ movp(rbx, FieldOperand(closure, JSFunction::kLiteralsOffset));
1000-
__ movp(rbx, FieldOperand(rbx, LiteralsArray::kFeedbackVectorOffset));
1001-
__ JumpIfRoot(rbx, Heap::kUndefinedValueRootIndex, &gotta_call_runtime);
1002-
1003997
__ movp(map, FieldOperand(closure, JSFunction::kSharedFunctionInfoOffset));
1004998
__ movp(map, FieldOperand(map, SharedFunctionInfo::kOptimizedCodeMapOffset));
1005999
__ SmiToInteger32(index, FieldOperand(map, FixedArray::kLengthOffset));
10061000
__ cmpl(index, Immediate(2));
10071001
__ j(less, &gotta_call_runtime);
10081002

1003+
// Find literals.
10091004
// r14 : native context
10101005
// r9 : length / index
10111006
// r8 : optimized code map
@@ -1022,6 +1017,17 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
10221017
__ movp(temp, FieldOperand(temp, WeakCell::kValueOffset));
10231018
__ cmpp(temp, native_context);
10241019
__ j(not_equal, &loop_bottom);
1020+
// Literals available?
1021+
__ movp(temp, FieldOperand(map, index, times_pointer_size,
1022+
SharedFunctionInfo::kOffsetToPreviousLiterals));
1023+
__ movp(temp, FieldOperand(temp, WeakCell::kValueOffset));
1024+
__ JumpIfSmi(temp, &gotta_call_runtime);
1025+
1026+
// Save the literals in the closure.
1027+
__ movp(FieldOperand(closure, JSFunction::kLiteralsOffset), temp);
1028+
__ movp(r15, index);
1029+
__ RecordWriteField(closure, JSFunction::kLiteralsOffset, temp, r15,
1030+
kDontSaveFPRegs, EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
10251031

10261032
// Code available?
10271033
Register entry = rcx;
@@ -1030,7 +1036,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
10301036
__ movp(entry, FieldOperand(entry, WeakCell::kValueOffset));
10311037
__ JumpIfSmi(entry, &try_shared);
10321038

1033-
// Found code. Get it into the closure and return.
1039+
// Found literals and code. Get them into the closure and return.
10341040
__ leap(entry, FieldOperand(entry, Code::kHeaderSize));
10351041
__ movp(FieldOperand(closure, JSFunction::kCodeEntryOffset), entry);
10361042
__ RecordWriteCodeEntryField(closure, entry, r15);
@@ -1061,7 +1067,7 @@ void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
10611067
__ cmpl(index, Immediate(1));
10621068
__ j(greater, &loop_top);
10631069

1064-
// We found no code.
1070+
// We found neither literals nor code.
10651071
__ jmp(&gotta_call_runtime);
10661072

10671073
__ bind(&try_shared);

0 commit comments

Comments
 (0)