Lines Matching defs:literal
1105 // Make sure calling a macro-assembler instruction will generate literal pools
1183 // literal.
1209 // literal that is already in the literal pool.
1219 // literal.
1223 // Add a large string to the literal pool, but only *after* l1, so the
1253 // This test stresses loading a literal that is already in the literal pool,
1254 // for various positionings on the existing load from that literal. We try to
1256 // literal pool.
1284 // literal.
1334 // This test generates multiple loads from the same literal in order to
1368 // Make sure calling a macro-assembler instruction will generate literal pools
1382 // generated before we need to generate the literal pool.
1393 // We should not have emitted the literal pool at this point.
1429 // Create one literal pool entry.
1459 // We want to emit code up to the maximum literal load range and ensure the
1476 // Create one literal pool entry.
1484 // Opening the scope should not have triggered the emission of the literal
1526 // With the old pool manager, the adr above would overflow the literal pool
1575 // With the old pool manager, the adr above would overflow the literal pool
1601 // Test loading a literal when the size of the literal pool is close to the
1607 // not assert on the size of the literal pool in this test.
1727 // Multiple uses of the same literal object should not make the
1747 // A test with two loads literal which go out of range at the same time.
1785 // This mov will put the two loads literal out of range and will force
1786 // the literal pool emission.
1940 // Each ldr instruction will force a new literal value to be added
1941 // to the pool. Check that the literal pool grows accordingly.
1959 // This ldr will force the literal pool to be emitted before emitting
1960 // the load and will create a new pool for the new literal used by this ldr.
1962 Literal<uint32_t> literal(test_case.literal_value);
1963 (masm.*test_case.instruction)(test_case.result_reg, &literal);
2004 Literal<uint32_t> literal(test_case.literal_value);
2005 (masm.*test_case.instruction)(test_case.result_reg, &literal);
2009 // literal we just emitted.
2017 // The literal pool should have been emitted now.
2018 VIXL_CHECK(literal.IsBound());
2129 // Manually generate a literal pool.
2250 // the literal when placing it. We keep a margin to account for this.
2253 // Take PC offset into account and make sure the literal is in the range.
2259 // instructions to cover the range and the literal would end up being
2443 // Create one literal pool entry.
2676 // This test manually places a 32-bit literal after a 16-bit branch
2677 // which branches over the literal to an unaligned PC.
2686 // Manually generate a literal pool.
2704 // Check that the literal was loaded correctly.
2971 StringLiteral literal("extra string");
2972 __ Adr(r2, &literal);
3444 // Create a single literal.
3449 // Generate code to fill all the margin we have before generating the literal
3455 // Opening the scope should not have triggered the emission of the literal
3464 // There should be no margin left to emit the literal pool.
3664 // - "literal vs veneers"
3681 // Create new literal values.
4014 Literal<uint64_t>* literal =
4018 // Refer to the literal so that it is emitted early.
4019 __ Ldr(r0, literal);
4044 // The literal has already been emitted, and is out of range of all of these
4047 __ Ldr(r1, literal);
4049 __ Ldrb(r2, literal);
4051 __ Ldrsb(r3, literal);
4053 __ Ldrh(r4, literal);
4055 __ Ldrsh(r5, literal);
4057 __ Ldrd(r6, r7, literal);
4059 __ Vldr(d0, literal);
4061 __ Vldr(s3, literal);
4086 Literal<uint64_t>* literal =
4090 // Refer to the literal so that it is emitted early.
4091 __ Ldr(r0, literal);
4116 // The literal has already been emitted, and is out of range of all of these
4119 __ Ldr(r1, literal);
4121 __ Ldrb(r2, literal);
4123 __ Ldrsb(r3, literal);
4125 __ Ldrh(r4, literal);
4127 __ Ldrsh(r5, literal);
4129 __ Ldrd(r6, r7, literal);
4151 __ Vldr(d0, literal);
4153 __ Vldr(s3, literal);
4179 Literal<uint64_t>* literal =
4183 // Refer to the literal so that it is emitted early.
4184 __ Vldr(s4, literal);
4210 // The literal has already been emitted, and is out of range of all of these
4213 __ Ldr(r1, literal);
4215 __ Ldrb(r2, literal);
4217 __ Ldrsb(r3, literal);
4219 __ Ldrh(r4, literal);
4221 __ Ldrsh(r5, literal);
4223 __ Ldrd(r6, r7, literal);
4225 __ Vldr(d0, literal);
4227 __ Vldr(s3, literal);
4252 Literal<uint64_t>* literal =
4256 // Refer to the literal so that it is emitted early.
4257 __ Vldr(s4, literal);
4282 // The literal has already been emitted, and is out of range of all of these
4285 __ Ldr(r1, literal);
4287 __ Ldrb(r2, literal);
4289 __ Ldrsb(r3, literal);
4291 __ Ldrh(r4, literal);
4293 __ Ldrsh(r5, literal);
4295 __ Ldrd(r6, r7, literal);
4297 __ Vldr(d0, literal);
4299 __ Vldr(s3, literal);
4324 Literal<uint64_t>* literal =
4328 // Refer to the literal so that it is emitted early.
4329 __ Ldr(r0, literal);
4347 // The literal has already been emitted, and is out of range of all of these
4349 __ Ldr(r1, literal);
4350 __ Ldrb(r2, literal);
4351 __ Ldrsb(r3, literal);
4352 __ Ldrh(r4, literal);
4353 __ Ldrsh(r5, literal);
4354 __ Ldrd(r6, r7, literal);
4355 __ Vldr(d0, literal);
4356 __ Vldr(s3, literal);
4361 __ Ldr(r1, literal);
4362 __ Ldrb(r2, literal);
4363 __ Ldrsb(r3, literal);
4364 __ Ldrh(r4, literal);
4365 __ Ldrsh(r5, literal);
4366 __ Ldrd(r6, r7, literal);
4373 __ Vldr(d0, literal);
4374 __ Vldr(s3, literal);
4940 // Create one literal pool entry.
4953 // literal pool.
5001 // Create one literal pool entry.
5015 // Generate nops up to the literal pool limit.
5023 // The literal pool needs to be generated.
5049 // Use a literal when we already have a veneer pool potential size greater than
5050 // the literal range => generate the literal immediately (not optimum but it
5068 // Create one literal pool entry.
5089 // Literal has to be generated sooner than veneers. However, as the literal
5104 Literal<uint32_t>* literal =
5109 __ Ldr(r11, literal);
5150 // Literal has to be generated sooner than veneers. However, as the literal
5187 // Emit the literal pool if it has not been emitted (it's the case for
5233 // At this point, the literal and the veneer pools are not emitted.
5285 Literal<uint64_t>* literal =
5289 __ Ldrd(r0, r1, literal);
5301 // This Ldrd will first generate the pool and then use literal which has just
5303 __ Ldrd(r2, r3, literal);
6135 // Create one literal pool entry.
6195 // Create one literal pool entry.
6294 // the literal load without emitting the veneers, which meant that we were
6329 // no problems. The Ldrd used to force emission of the literal pool, pushing
6368 // before the literal is emitted, hence pushing the Ldrd out of range.