[ELF][RISCV] Use .got rather than .captable for CHERI-RISC-V

Author: jrtc27

lld/ELF/Arch/RISCV.cpp

@@ -143,7 +143,10 @@ RISCV::RISCV(Ctx &ctx) : TargetInfo(ctx) {
     tlsOffsetRel = R_RISCV_TLS_DTPREL32;
     tlsGotRel = R_RISCV_TLS_TPREL32;
   }
-  gotRel = symbolicRel;
+  if (ctx.arg.isCheriAbi)
+    gotRel = *cheriCapRel;
+  else
+    gotRel = symbolicRel;
   tlsDescRel = R_RISCV_TLSDESC;
 
   // .got[0] = _DYNAMIC
@@ -307,9 +310,8 @@ void RISCV::writePlt(uint8_t *buf, const Symbol &sym,
   // nop
   uint32_t ptrload = ctx.arg.isCheriAbi ? ctx.arg.is64 ? CLC_128 : CLC_64
                                         : ctx.arg.is64 ? LD : LW;
-  uint32_t entryva = ctx.arg.isCheriAbi
-                         ? sym.getCapTableVA(ctx, ctx.in.plt.get(), 0)
-                         : sym.getGotPltVA(ctx);
+  uint32_t entryva =
+      ctx.arg.isCheriAbi ? sym.getGotVA(ctx) : sym.getGotPltVA(ctx);
   uint32_t offset = entryva - pltEntryAddr;
   write32le(buf + 0, utype(AUIPC, X_T3, hi20(offset)));
   write32le(buf + 4, itype(ptrload, X_T3, X_T3, lo12(offset)));
@@ -393,25 +395,27 @@ RelExpr RISCV::getRelExpr(const RelType type, const Symbol &s,
     return RE_RISCV_LEB128;
     case R_RISCV_CHERI_CAPABILITY:
     return R_CHERI_CAPABILITY;
-  case R_RISCV_CHERI_CAPTAB_PCREL_HI20:
-    return R_CHERI_CAPABILITY_TABLE_ENTRY_PC;
-  case R_RISCV_CHERI_TLS_IE_CAPTAB_PCREL_HI20:
-    return R_CHERI_CAPABILITY_TABLE_TLSIE_ENTRY_PC;
-  case R_RISCV_CHERI_TLS_GD_CAPTAB_PCREL_HI20:
-    return R_CHERI_CAPABILITY_TABLE_TLSGD_ENTRY_PC;
-  case R_RISCV_CHERIOT_COMPARTMENT_HI:
-    return isPCCRelative(ctx, loc, &s) ? R_PC : R_CHERIOT_COMPARTMENT_CGPREL_HI;
-  case R_RISCV_CHERIOT_COMPARTMENT_LO_I:
-    return R_CHERIOT_COMPARTMENT_CGPREL_LO_I;
-  case R_RISCV_CHERIOT_COMPARTMENT_LO_S:
-    return R_CHERIOT_COMPARTMENT_CGPREL_LO_S;
-  case R_RISCV_CHERIOT_COMPARTMENT_SIZE:
-    return R_CHERIOT_COMPARTMENT_SIZE;
-  default:
-    Err(ctx) << getErrorLoc(ctx, loc) << "unknown relocation (" << type.v
-             << ") against symbol " << &s;
-    return R_NONE;
-  }
+    // TODO: Deprecate and eventually remove these
+    case R_RISCV_CHERI_CAPTAB_PCREL_HI20:
+      return R_GOT_PC;
+    case R_RISCV_CHERI_TLS_IE_CAPTAB_PCREL_HI20:
+      return R_GOT_PC;
+    case R_RISCV_CHERI_TLS_GD_CAPTAB_PCREL_HI20:
+      return R_TLSGD_PC;
+    case R_RISCV_CHERIOT_COMPARTMENT_HI:
+      return isPCCRelative(ctx, loc, &s) ? R_PC
+                                         : R_CHERIOT_COMPARTMENT_CGPREL_HI;
+    case R_RISCV_CHERIOT_COMPARTMENT_LO_I:
+      return R_CHERIOT_COMPARTMENT_CGPREL_LO_I;
+    case R_RISCV_CHERIOT_COMPARTMENT_LO_S:
+      return R_CHERIOT_COMPARTMENT_CGPREL_LO_S;
+    case R_RISCV_CHERIOT_COMPARTMENT_SIZE:
+      return R_CHERIOT_COMPARTMENT_SIZE;
+    default:
+      Err(ctx) << getErrorLoc(ctx, loc) << "unknown relocation (" << type.v
+               << ") against symbol " << &s;
+      return R_NONE;
+    }
 }
 
 void RISCV::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {

lld/ELF/InputSection.cpp

@@ -1020,20 +1020,6 @@ uint64_t InputSectionBase::getRelocTargetVA(Ctx &ctx, const Relocation &r,
   case R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE:
     assert(a == 0 && "capability table index relocs should not have addends");
     return r.sym->getCapTableOffset(ctx, this, r.offset);
-  case R_CHERI_CAPABILITY_TABLE_ENTRY_PC: {
-    assert(a == 0 && "capability table entry relocs should not have addends");
-    return r.sym->getCapTableVA(ctx, this, r.offset) - p;
-  }
-  case R_CHERI_CAPABILITY_TABLE_TLSGD_ENTRY_PC: {
-    assert(a == 0 && "capability table index relocs should not have addends");
-    uint64_t capTableOffset = ctx.in.cheriCapTable->getDynTlsOffset(*r.sym);
-    return ctx.sym.cheriCapabilityTable->getVA(ctx) + capTableOffset - p;
-  }
-  case R_CHERI_CAPABILITY_TABLE_TLSIE_ENTRY_PC: {
-    assert(a == 0 && "capability table index relocs should not have addends");
-    uint64_t capTableOffset = ctx.in.cheriCapTable->getTlsOffset(*r.sym);
-    return ctx.sym.cheriCapabilityTable->getVA(ctx) + capTableOffset - p;
-  }
   case R_CHERI_CAPABILITY_TABLE_REL:
     if (!ctx.sym.cheriCapabilityTable) {
       error("cannot compute difference between non-existent "

lld/ELF/Relocations.cpp

@@ -923,20 +923,21 @@ template <class PltSection, class GotPltSection>
 static void addPltEntry(Ctx &ctx, PltSection &plt, GotPltSection &gotPlt,
                         RelocationBaseSection &rel, RelType type, Symbol &sym) {
   plt.addEntry(sym);
-  if (ctx.arg.isCheriAbi) {
-    // TODO: More normal .got.plt rather than piggy-backing on .captable. We
-    // pass R_CHERI_CAPABILITY_TABLE_INDEX rather than the more obvious
-    // R_CHERI_CAPABILITY_TABLE_INDEX_CALL to force dynamic relocations into
-    // .rela.dyn rather than .rela.plt so no rtld changes are needed, as the
-    // latter doesn't really achieve anything without lazy binding.
-    ctx.in.cheriCapTable->addEntry(sym, R_CHERI_CAPABILITY_TABLE_INDEX, &plt, 0);
-  } else {
-    gotPlt.addEntry(sym);
-    rel.addReloc({type, &gotPlt, sym.getGotPltOffset(ctx),
-                  sym.isPreemptible ? DynamicReloc::AgainstSymbol
-                                    : DynamicReloc::AddendOnlyWithTargetVA,
-                  sym, 0, R_ABS});
-  }
+
+  // For CHERI-RISC-V we mark the symbol NEEDS_GOT so it will end up in .got as
+  // a function pointer, and uses .rela.dyn rather than .rela.plt, so no rtld
+  // changes are needed.
+  //
+  // TODO: More normal .got.plt with lazy-binding rather than piggy-backing on
+  // .got once rtld supports it.
+  if (ctx.arg.emachine == EM_RISCV && ctx.arg.isCheriAbi)
+    return;
+
+  gotPlt.addEntry(sym);
+  rel.addReloc({type, &gotPlt, sym.getGotPltOffset(ctx),
+                sym.isPreemptible ? DynamicReloc::AgainstSymbol
+                                  : DynamicReloc::AddendOnlyWithTargetVA,
+                sym, 0, R_ABS});
 }
 
 void elf::addGotEntry(Ctx &ctx, Symbol &sym) {
@@ -952,8 +953,12 @@ void elf::addGotEntry(Ctx &ctx, Symbol &sym) {
   }
 
   // Otherwise, the value is either a link-time constant or the load base
-  // plus a constant.
-  if (!ctx.arg.isPic || isAbsolute(sym))
+  // plus a constant. For CHERI it always requires run-time initialisation.
+  if (ctx.arg.isCheriAbi) {
+    invokeELFT(addCapabilityRelocation, ctx, &sym, *ctx.target->cheriCapRel,
+               ctx.in.got.get(), off, R_CHERI_CAPABILITY, 0, false,
+               [] { return ""; });
+  } else if (!ctx.arg.isPic || isAbsolute(sym))
     ctx.in.got->addConstant({R_ABS, ctx.target->symbolicRel, off, 0, &sym});
   else
     addRelativeReloc(ctx, *ctx.in.got, off, sym, 0, R_ABS,
@@ -1023,25 +1028,22 @@ bool RelocationScanner::isStaticLinkTimeConstant(RelExpr e, RelType type,
                                                  const Symbol &sym,
                                                  uint64_t relOff) const {
   // These expressions always compute a constant
-  if (oneof<
-          R_GOTPLT, R_GOT_OFF, R_RELAX_HINT, RE_MIPS_GOT_LOCAL_PAGE,
-          RE_MIPS_GOTREL, RE_MIPS_GOT_OFF, RE_MIPS_GOT_OFF32, RE_MIPS_GOT_GP_PC,
-          RE_AARCH64_GOT_PAGE_PC, RE_AARCH64_AUTH_GOT_PAGE_PC, R_GOT_PC,
-          R_GOTONLY_PC, R_GOTPLTONLY_PC, R_PLT_PC, R_PLT_GOTREL, R_PLT_GOTPLT,
-          R_GOTPLT_GOTREL, R_GOTPLT_PC, RE_PPC32_PLTREL, RE_PPC64_CALL_PLT,
-          RE_PPC64_RELAX_TOC, RE_RISCV_ADD, RE_AARCH64_GOT_PAGE,
-          RE_AARCH64_AUTH_GOT, RE_AARCH64_AUTH_GOT_PC, RE_LOONGARCH_PLT_PAGE_PC,
-          RE_LOONGARCH_GOT, RE_LOONGARCH_GOT_PAGE_PC,
-            R_CHERI_CAPABILITY_TABLE_INDEX,
+  if (oneof<R_GOTPLT, R_GOT_OFF, R_RELAX_HINT, RE_MIPS_GOT_LOCAL_PAGE,
+            RE_MIPS_GOTREL, RE_MIPS_GOT_OFF, RE_MIPS_GOT_OFF32,
+            RE_MIPS_GOT_GP_PC, RE_AARCH64_GOT_PAGE_PC,
+            RE_AARCH64_AUTH_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC,
+            R_GOTPLTONLY_PC, R_PLT_PC, R_PLT_GOTREL, R_PLT_GOTPLT,
+            R_GOTPLT_GOTREL, R_GOTPLT_PC, RE_PPC32_PLTREL, RE_PPC64_CALL_PLT,
+            RE_PPC64_RELAX_TOC, RE_RISCV_ADD, RE_AARCH64_GOT_PAGE,
+            RE_AARCH64_AUTH_GOT, RE_AARCH64_AUTH_GOT_PC,
+            RE_LOONGARCH_PLT_PAGE_PC, RE_LOONGARCH_GOT,
+            RE_LOONGARCH_GOT_PAGE_PC, R_CHERI_CAPABILITY_TABLE_INDEX,
             R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE,
             R_CHERI_CAPABILITY_TABLE_INDEX_CALL,
             R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE,
-            R_CHERI_CAPABILITY_TABLE_ENTRY_PC,
-            R_CHERI_CAPABILITY_TABLE_REL,
-            R_CHERIOT_COMPARTMENT_CGPREL_HI,
+            R_CHERI_CAPABILITY_TABLE_REL, R_CHERIOT_COMPARTMENT_CGPREL_HI,
             R_CHERIOT_COMPARTMENT_CGPREL_LO_I,
-            R_CHERIOT_COMPARTMENT_CGPREL_LO_S,
-            R_CHERIOT_COMPARTMENT_SIZE>(e))
+            R_CHERIOT_COMPARTMENT_CGPREL_LO_S, R_CHERIOT_COMPARTMENT_SIZE>(e))
     return true;
 
   // Cheri capability relocations are never static link time constants since
@@ -1161,20 +1163,7 @@ void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,
   if (oneof<R_CHERI_CAPABILITY_TABLE_INDEX,
             R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE,
             R_CHERI_CAPABILITY_TABLE_INDEX_CALL,
-            R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE,
-            R_CHERI_CAPABILITY_TABLE_ENTRY_PC>(expr)) {
-    std::lock_guard<std::mutex> lock(ctx.relocMutex);
-    ctx.in.cheriCapTable->addEntry(sym, expr, sec, offset);
-    // Write out the index into the instruction
-    sec->relocations.push_back({expr, type, offset, addend, &sym});
-    return;
-  }
-
-  if (oneof<R_CHERI_CAPABILITY_TABLE_INDEX,
-            R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE,
-            R_CHERI_CAPABILITY_TABLE_INDEX_CALL,
-            R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE,
-            R_CHERI_CAPABILITY_TABLE_ENTRY_PC>(expr)) {
+            R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE>(expr)) {
     std::lock_guard<std::mutex> lock(ctx.relocMutex);
     ctx.in.cheriCapTable->addEntry(sym, expr, sec, offset);
     // Write out the index into the instruction
@@ -1203,6 +1192,9 @@ void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,
     }
   } else if (needsPlt(expr)) {
     sym.setFlags(NEEDS_PLT);
+    // See addPltEntry
+    if (ctx.arg.emachine == EM_RISCV && ctx.arg.isCheriAbi)
+      sym.setFlags(NEEDS_GOT);
   } else if (LLVM_UNLIKELY(isIfunc)) {
     sym.setFlags(HAS_DIRECT_RELOC);
   }
@@ -1359,6 +1351,9 @@ void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,
         printLocation(diag, *sec, sym, offset);
       }
       sym.setFlags(NEEDS_COPY | NEEDS_PLT);
+      // See addPltEntry
+      if (ctx.arg.emachine == EM_RISCV && ctx.arg.isCheriAbi)
+        sym.setFlags(NEEDS_GOT);
       sec->addReloc({expr, type, offset, addend, &sym});
       return;
     }
@@ -1501,36 +1496,6 @@ unsigned RelocationScanner::handleTlsRelocation(RelExpr expr, RelType type,
       !(isRISCV && expr != R_TLSDESC_PC && expr != R_TLSDESC_CALL) &&
       !sec->file->ppc64DisableTLSRelax;
 
-  // No targets currently support TLS relaxation, so we can avoid duplicating
-  // much of the logic below for the captable.
-  if (expr == R_CHERI_CAPABILITY_TABLE_TLSGD_ENTRY_PC) {
-    std::lock_guard<std::mutex> lock(ctx.relocMutex);
-    ctx.in.cheriCapTable->addDynTlsEntry(sym);
-    sec->relocations.push_back({expr, type, offset, addend, &sym});
-    return 1;
-  }
-  if (expr == R_CHERI_CAPABILITY_TABLE_TLSIE_ENTRY_PC) {
-    std::lock_guard<std::mutex> lock(ctx.relocMutex);
-    ctx.in.cheriCapTable->addTlsEntry(sym);
-    sec->relocations.push_back({expr, type, offset, addend, &sym});
-    return 1;
-  }
-
-  // No targets currently support TLS relaxation, so we can avoid duplicating
-  // much of the logic below for the captable.
-  if (expr == R_CHERI_CAPABILITY_TABLE_TLSGD_ENTRY_PC) {
-    std::lock_guard<std::mutex> lock(ctx.relocMutex);
-    ctx.in.cheriCapTable->addDynTlsEntry(sym);
-    sec->relocations.push_back({expr, type, offset, addend, &sym});
-    return 1;
-  }
-  if (expr == R_CHERI_CAPABILITY_TABLE_TLSIE_ENTRY_PC) {
-    std::lock_guard<std::mutex> lock(ctx.relocMutex);
-    ctx.in.cheriCapTable->addTlsEntry(sym);
-    sec->relocations.push_back({expr, type, offset, addend, &sym});
-    return 1;
-  }
-
   // If we are producing an executable and the symbol is non-preemptable, it
   // must be defined and the code sequence can be optimized to use
   // Local-Exesec->

lld/ELF/Relocations.h

@@ -126,9 +126,6 @@ enum RelExpr {
   R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE,
   R_CHERI_CAPABILITY_TABLE_INDEX_CALL,
   R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE,
-  R_CHERI_CAPABILITY_TABLE_ENTRY_PC,
-  R_CHERI_CAPABILITY_TABLE_TLSGD_ENTRY_PC,
-  R_CHERI_CAPABILITY_TABLE_TLSIE_ENTRY_PC,
   R_CHERI_CAPABILITY_TABLE_REL, // relative offset to _CHERI_CAPABILITY_TABLE_
   R_MIPS_CHERI_CAPTAB_TLSGD,
   R_MIPS_CHERI_CAPTAB_TLSLD,

lld/ELF/SyntheticSections.cpp

@@ -686,6 +686,9 @@ GotSection::GotSection(Ctx &ctx)
 
 void GotSection::addConstant(const Relocation &r) { relocations.push_back(r); }
 void GotSection::addEntry(const Symbol &sym) {
+  // TODO: Separate out TLS IE entries for CHERI so we can pack them more
+  // efficiently rather than consuming a whole capability-sized slot for an
+  // integer.
   assert(sym.auxIdx == ctx.symAux.size() - 1);
   ctx.symAux.back().gotIdx = numEntries++;
 }
@@ -710,8 +713,12 @@ void GotSection::addTlsDescAuthEntry() {
 bool GotSection::addDynTlsEntry(const Symbol &sym) {
   assert(sym.auxIdx == ctx.symAux.size() - 1);
   ctx.symAux.back().tlsGdIdx = numEntries;
-  // Global Dynamic TLS entries take two GOT slots.
-  numEntries += 2;
+  // Global Dynamic TLS entries take two GOT slots, except on CHERI where they
+  // can be packed into one GOT slot.
+  if (ctx.arg.isCheriAbi)
+    ++numEntries;
+  else
+    numEntries += 2;
   return true;
 }
 

lld/test/ELF/cheri/riscv/plt.s

@@ -7,7 +7,7 @@
 # RUN: ld.lld %t.32.o %t1.32.so -z separate-code -o %t.32
 # RUN: llvm-readelf -S -s %t.32 | FileCheck --check-prefixes=SEC,NM %s
 # RUN: llvm-readobj -r %t.32 | FileCheck --check-prefix=RELOC32 %s
-# RUN: llvm-readelf -x .captable %t.32 | FileCheck --check-prefix=CAPTAB32 %s
+# RUN: llvm-readelf -x .got %t.32 | FileCheck --check-prefix=GOT32 %s
 # RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex=false %t.32 | FileCheck --check-prefixes=DIS,DIS32 %s
 
 # RUN: %riscv64_cheri_purecap_llvm-mc -filetype=obj %t1.s -o %t1.64.o
@@ -16,7 +16,7 @@
 # RUN: ld.lld %t.64.o %t1.64.so -z separate-code -o %t.64
 # RUN: llvm-readelf -S -s %t.64 | FileCheck --check-prefixes=SEC,NM %s
 # RUN: llvm-readobj -r %t.64 | FileCheck --check-prefix=RELOC64 %s
-# RUN: llvm-readelf -x .captable %t.64 | FileCheck --check-prefix=CAPTAB64 %s
+# RUN: llvm-readelf -x .got %t.64 | FileCheck --check-prefix=GOT64 %s
 # RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex=false %t.64 | FileCheck --check-prefixes=DIS,DIS64 %s
 
 # SEC: .plt PROGBITS {{0*}}00011030
@@ -27,19 +27,21 @@
 # NM: {{0*}}00000000 0 FUNC WEAK   DEFAULT UND weak
 
 # RELOC32:      .rela.dyn {
-# RELOC32-NEXT:   0x12000 R_RISCV_CHERI_CAPABILITY bar 0x0
-# RELOC32-NEXT:   0x12008 R_RISCV_CHERI_CAPABILITY weak 0x0
+# RELOC32-NEXT:   0x12068 R_RISCV_CHERI_CAPABILITY bar 0x0
+# RELOC32-NEXT:   0x12070 R_RISCV_CHERI_CAPABILITY weak 0x0
 # RELOC32-NEXT: }
-# CAPTAB32:      section '.captable'
-# CAPTAB32-NEXT: 0x00012000 00000000 00000000 00000000 00000000
+# GOT32:      section '.got'
+# GOT32-NEXT: 0x00012060 00200100 00000000 00000000 00000000
+# GOT32-NEXT: 0x00012070 00000000 00000000
 
 # RELOC64:      .rela.dyn {
-# RELOC64-NEXT:   0x12000 R_RISCV_CHERI_CAPABILITY bar 0x0
-# RELOC64-NEXT:   0x12010 R_RISCV_CHERI_CAPABILITY weak 0x0
+# RELOC64-NEXT:   0x120D0 R_RISCV_CHERI_CAPABILITY bar 0x0
+# RELOC64-NEXT:   0x120E0 R_RISCV_CHERI_CAPABILITY weak 0x0
 # RELOC64-NEXT: }
-# CAPTAB64:      section '.captable'
-# CAPTAB64-NEXT: 0x00012000 00000000 00000000 00000000 00000000
-# CAPTAB64-NEXT: 0x00012010 00000000 00000000 00000000 00000000
+# GOT64:      section '.got'
+# GOT64-NEXT: 0x000120c0 00200100 00000000 00000000 00000000
+# GOT64-NEXT: 0x000120d0 00000000 00000000 00000000 00000000
+# GOT64-NEXT: 0x000120e0 00000000 00000000 00000000 00000000
 
 # DIS:      <_start>:
 ## Direct call
@@ -62,17 +64,19 @@
 # DIS:      <.plt>:
 # DIS-NEXT:     ...
 
-## 32-bit: &.captable[bar]-. = 0x12000-0x11050 = 4096*1-80
+## 32-bit: &.got[bar]-. = 0x12068-0x11050 = 4096*1+24
+## 64-bit: &.got[bar]-. = 0x120d0-0x11050 = 4096*1+128
 # DIS:        11050: auipcc t3, 1
-# DIS32-NEXT:   clc t3, -80(t3)
-# DIS64-NEXT:   clc t3, -80(t3)
+# DIS32-NEXT:   clc t3, 24(t3)
+# DIS64-NEXT:   clc t3, 128(t3)
 # DIS-NEXT:     cjalr t1, t3
 # DIS-NEXT:     nop
 
-## 32-bit: &.captable[weak]-. = 0x12008-0x11060 = 4096*1-88
+## 32-bit: &.got[weak]-. = 0x12070-0x11060 = 4096*1+16
+## 64-bit: &.got[weak]-. = 0x120e0-0x11060 = 4096*1+128
 # DIS:        11060: auipcc t3, 1
-# DIS32-NEXT:   clc t3, -88(t3)
-# DIS64-NEXT:   clc t3, -80(t3)
+# DIS32-NEXT:   clc t3, 16(t3)
+# DIS64-NEXT:   clc t3, 128(t3)
 # DIS-NEXT:     cjalr t1, t3
 # DIS-NEXT:     nop