Lines Matching full:addend
260 uint32_t Type, int64_t Addend,
269 Value += Addend;
278 Value += Addend;
289 Value + Addend;
290 LLVM_DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
296 Value += Addend;
309 int64_t RealOffset = Value + Addend - FinalAddress;
317 int64_t RealOffset = Value + Addend - FinalAddress;
326 int64_t RealOffset = Value + Addend - FinalAddress;
343 int64_t GOTOffset = Value - GOTBase + Addend;
359 Value + Addend;
366 int64_t RealValue = Value + Addend;
378 uint32_t Type, int32_t Addend) {
382 Value + Addend;
391 uint32_t RealOffset = Value + Addend - FinalAddress;
406 uint32_t Type, int64_t Addend) {
417 << format("%x", Type) << " Addend: 0x"
418 << format("%llx", Addend) << "\n");
427 uint64_t Result = Value + Addend;
434 uint64_t Result = Value + Addend;
441 write(isBE, TargetPtr, Value + Addend);
444 uint64_t Result = Value + Addend - FinalAddress;
451 uint64_t Result = Value + Addend - FinalAddress;
458 uint64_t Result = Value + Addend - FinalAddress;
465 write(isBE, TargetPtr, Value + Addend - FinalAddress);
468 uint64_t BranchImm = Value + Addend - FinalAddress;
477 uint64_t BranchImm = Value + Addend - FinalAddress;
492 uint64_t BranchImm = Value + Addend - FinalAddress;
500 or32le(TargetPtr, ((Value + Addend) & 0xFFFF000000000000) >> 43);
503 or32le(TargetPtr, ((Value + Addend) & 0xFFFF00000000) >> 27);
506 or32le(TargetPtr, ((Value + Addend) & 0xFFFF0000) >> 11);
509 or32le(TargetPtr, ((Value + Addend) & 0xFFFF) << 5);
514 ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
528 or32AArch64Imm(TargetPtr, Value + Addend);
534 or32AArch64Imm(TargetPtr, getBits(Value + Addend, 0, 11));
540 or32AArch64Imm(TargetPtr, getBits(Value + Addend, 1, 11));
546 or32AArch64Imm(TargetPtr, getBits(Value + Addend, 2, 11));
552 or32AArch64Imm(TargetPtr, getBits(Value + Addend, 3, 11));
558 or32AArch64Imm(TargetPtr, getBits(Value + Addend, 4, 11));
562 uint64_t Result = Value + Addend - FinalAddress;
575 uint64_t Result = Value + Addend - FinalAddress;
592 uint32_t Type, int32_t Addend) {
597 Value += Addend;
604 << " Addend: " << format("%x", Addend) << "\n");
665 if (!isInt<28>(Address + Value.Addend - SourceAddress))
668 Value.Addend);
699 ELF::R_LARCH_ABS_HI20, Value.Addend);
701 ELF::R_LARCH_ABS_LO12, Value.Addend);
703 ELF::R_LARCH_ABS64_LO20, Value.Addend);
705 ELF::R_LARCH_ABS64_HI12, Value.Addend);
733 int64_t Addend) {
741 << format("%x", Type) << " Addend: 0x"
742 << format("%llx", Addend) << "\n");
750 static_cast<uint32_t>(Value + Addend);
753 support::ulittle64_t::ref{TargetPtr} = Value + Addend;
757 static_cast<uint32_t>(Value + Addend - FinalAddress);
760 uint64_t B26 = (Value + Addend - FinalAddress) >> 2;
768 uint64_t Call36 = (Value + Addend - FinalAddress) >> 2;
780 uint64_t Target = Value + Addend;
792 uint64_t TargetOffset = (Value + Addend) & 0xfff;
799 uint64_t Target = Value + Addend;
806 uint64_t Target = Value + Addend;
813 uint64_t Target = Value + Addend;
820 uint64_t Target = Value + Addend;
829 static_cast<uint32_t>(Value + Addend));
834 static_cast<uint32_t>(Value + Addend));
838 (support::ulittle64_t::ref{TargetPtr} + Value + Addend);
842 (support::ulittle64_t::ref{TargetPtr} - Value - Addend);
898 Rel.Addend = 0x8000;
942 int64_t Addend;
944 Addend = *AddendOrErr;
960 if (Rel.Addend != (int64_t)TargetSymbolOffset)
976 Rel.Addend = (intptr_t)Addend;
1016 uint32_t Type, int64_t Addend) {
1023 writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
1026 writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
1029 writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
1036 uint32_t Type, int64_t Addend) {
1043 writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
1046 writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
1049 writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
1052 writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
1056 writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
1060 writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
1063 writeInt16BE(LocalAddress, applyPPChigher(Value + Addend));
1066 writeInt16BE(LocalAddress, applyPPChighera(Value + Addend));
1069 writeInt16BE(LocalAddress, applyPPChighest(Value + Addend));
1072 writeInt16BE(LocalAddress, applyPPChighesta(Value + Addend));
1075 assert(((Value + Addend) & 3) == 0);
1078 writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc));
1082 uint64_t Delta = Value - FinalAddress + Addend;
1087 uint64_t Delta = Value - FinalAddress + Addend;
1092 uint64_t Delta = Value - FinalAddress + Addend;
1096 int64_t Result = static_cast<int64_t>(Value + Addend);
1103 int64_t delta = static_cast<int64_t>(Value - FinalAddress + Addend);
1112 int64_t delta = static_cast<int64_t>(Value - FinalAddress + Addend);
1119 uint64_t Delta = Value - FinalAddress + Addend;
1123 writeInt64BE(LocalAddress, Value + Addend);
1130 uint32_t Type, int64_t Addend) {
1138 int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
1145 int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
1151 int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
1157 int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
1163 int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
1168 *LocalAddress = (uint8_t)(Value + Addend);
1171 writeInt16BE(LocalAddress, Value + Addend);
1174 writeInt32BE(LocalAddress, Value + Addend);
1177 writeInt64BE(LocalAddress, Value + Addend);
1184 uint32_t Type, int64_t Addend) {
1197 write(isBE, Section.getAddressWithOffset(Offset), Value + Addend);
1198 LLVM_DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
1203 Value += Addend;
1227 uint32_t Type, int64_t Addend,
1240 uint64_t PCOffset = Value + Addend - P;
1247 uint64_t PCOffset = Value + Addend;
1253 uint64_t PCOffset = Value + Addend;
1261 uint64_t PCOffset = Value + Addend - P;
1279 if (Value + Addend == HIRelocPC) {
1281 MatchingValue.Addend;
1293 int64_t RealOffset = Value + Addend - FinalAddress;
1301 Ref = Value + Addend;
1306 Ref = Value + Addend;
1311 Ref = Ref + Value + Addend;
1316 Ref = Ref + Value + Addend;
1321 Ref = Ref + Value + Addend;
1326 Ref = Ref - Value - Addend;
1331 Ref = Ref - Value - Addend;
1336 Ref = Ref - Value - Addend;
1359 // the symbol resides (RE.Addend provides additional information about the
1365 return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
1371 uint32_t Type, int64_t Addend,
1375 resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
1379 (uint32_t)(Addend & 0xffffffffL));
1383 resolveAArch64Relocation(Section, Offset, Value, Type, Addend);
1390 (uint32_t)(Addend & 0xffffffffL));
1393 resolveLoongArch64Relocation(Section, Offset, Value, Type, Addend);
1397 resolvePPC32Relocation(Section, Offset, Value, Type, Addend);
1401 resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
1404 resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
1408 resolveBPFRelocation(Section, Offset, Value, Type, Addend);
1412 resolveRISCVRelocation(Section, Offset, Value, Type, Addend, SectionID);
1425 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, Value.Offset);
1495 if (!isInt<28>(TargetOffset + Value.Addend - SourceOffset))
1498 RelocationEntry RE(SectionID, SourceOffset, RelI->getType(), Value.Addend);
1531 ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend);
1534 ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend);
1537 ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend);
1540 ELF::R_AARCH64_MOVW_UABS_G0_NC, Value.Addend);
1566 int64_t Addend = 0;
1568 Addend = *AddendOrErr;
1581 LLVM_DEBUG(dbgs() << "\t\tRelType: " << RelType << " Addend: " << Addend
1604 Value.Addend = SymInfo.getOffset() + Addend;
1628 Value.Addend = Addend;
1636 Value.Addend = Addend;
1665 resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1670 resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1696 ELF::R_ARM_ABS32, Value.Addend);
1713 Value.Addend += *Placeholder;
1716 Value.Addend += (int16_t)((*Placeholder & 0xFFF) | (((*Placeholder >> 16) & 0xF) << 12));
1726 resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1740 // Extract the addend from the instruction.
1743 uint32_t Addend = (Opcode & 0x03ffffff) << 2;
1745 Value.Addend += Addend;
1765 ELF::R_MIPS_HI16, Value.Addend);
1768 ELF::R_MIPS_LO16, Value.Addend);
1783 int64_t Addend = (Opcode & 0x0000ffff) << 16;
1784 RelocationEntry RE(SectionID, Offset, RelType, Addend);
1787 int64_t Addend = Value.Addend + SignExtend32<16>(Opcode & 0x0000ffff);
1794 Reloc.Addend += Addend;
1803 RelocationEntry RE(SectionID, Offset, RelType, Addend);
1810 Value.Addend += Opcode;
1812 Value.Addend += SignExtend32<18>((Opcode & 0x0000ffff) << 2);
1814 Value.Addend += SignExtend32<21>((Opcode & 0x0007ffff) << 2);
1816 Value.Addend += SignExtend32<23>((Opcode & 0x001fffff) << 2);
1818 Value.Addend += SignExtend32<28>((Opcode & 0x03ffffff) << 2);
1823 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1858 ELF::R_MIPS_HI16, Value.Addend);
1861 ELF::R_MIPS_LO16, Value.Addend);
1874 ELF::R_MIPS_HIGHEST, Value.Addend);
1877 ELF::R_MIPS_HIGHER, Value.Addend);
1880 ELF::R_MIPS_HI16, Value.Addend);
1883 ELF::R_MIPS_LO16, Value.Addend);
1929 Value.Addend += ELF::decodePPC64LocalEntryOffset(SymOther);
1933 Sections[Value.SectionID].getAddressWithOffset(Value.Addend);
1940 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1963 ELF::R_PPC64_ADDR64, Value.Addend);
1974 ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
1976 ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
1978 ELF::R_PPC64_ADDR16_HI, Value.Addend);
1980 ELF::R_PPC64_ADDR16_LO, Value.Addend);
2039 Value.Addend -= TOCValue.Addend;
2040 resolveRelocation(Sections[SectionID], Offset, Value.Addend, RelType, 0);
2043 // via a ELF::R_PPC64_TOC relocation (where both symbol and addend are
2045 // symbols (in which case the addend is respected).
2053 Value.Addend += Addend;
2056 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
2105 Addend);
2107 resolveRelocation(Section, Offset, StubAddress, RelType, Addend);
2155 // The load of the GOT address has an addend of -4
2167 Addend);
2169 Value.Addend += support::ulittle32_t::ref(
2177 resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
2205 resolveGOTOffsetRelocation(SectionID, Offset, Addend, ELF::R_X86_64_PC32);
2208 resolveGOTOffsetRelocation(SectionID, Offset, Addend, ELF::R_X86_64_PC64);
2214 Value.Addend += support::ulittle32_t::ref(computePlaceholderAddress(SectionID, Offset));
2217 Value.Addend += support::ulittle64_t::ref(
2221 processX86_64GOTTPOFFRelocation(SectionID, Offset, Value, Addend);
2227 processX86_64TLSRelocation(SectionID, Offset, RelType, Value, Addend,
2241 RelocationEntry RE(SectionID, Offset, RelType, Addend);
2247 Value.Addend += support::ulittle32_t::ref(
2258 int64_t Addend) {
2341 // The original GOTTPOFF relocation has an addend as it is PC relative,
2343 // absolute value (which is an offset from %fs:0), so remove the addend
2347 ELF::R_X86_64_TPOFF32, Value.Addend - Addend);
2363 resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
2376 RelocationValueRef Value, int64_t Addend,
2484 // The TLSGD/TLSLD relocations are PC-relative, so they have an addend.
2486 // %fs:0, so remove the TLSGD/TLSLD addend again.
2488 ELF::R_X86_64_TPOFF32, Value.Addend - Addend);
2879 // instruction, so the addend is -4.