[llvm][Bitcode] Add bitcode reader/writer for DSOLocalEquivalent

[leonardchan]

Summary

This is necessary for compilation with [thin]lto.

[leonardchan]

*ping* Any comments for this patch? I believe these are mostly mechanical changes that were left out of the original DSOLocalEquivalent patch.

[rjmccall]

I've never patched the bitcode reader/writer before, I think, but from similar patches I've seen, this look good to me. Is there any sort of registration you're supposed to do of the new code?

[leonardchan]

In D96170#2561432, @rjmccall wrote:

I've never patched the bitcode reader/writer before, I think, but from similar patches I've seen, this look good to me. Is there any sort of registration you're supposed to do of the new code?

Hmm. By registration, do you mean making cmake aware of the new test? I don't *think* there's anything else I may need to change. I mainly just copied similar logic from how the other constant codes are handled.

Adding @rnk who may have more familiarity.

[rjmccall]

In D96170#2566975, @leonardchan wrote:

In D96170#2561432, @rjmccall wrote:

I've never patched the bitcode reader/writer before, I think, but from similar patches I've seen, this look good to me. Is there any sort of registration you're supposed to do of the new code?

Hmm. By registration, do you mean making cmake aware of the new test? I don't *think* there's anything else I may need to change. I mainly just copied similar logic from how the other constant codes are handled.

Adding @rnk who may have more familiarity.

Some of the other serializers using bitcode require some of the codes to be registered, either as abbreviations or just for incidental reasons. If there's nothing like that for similar record codes, though, it's probably not a thing for BC.

[leonardchan]

In D96170#2567026, @rjmccall wrote:

In D96170#2566975, @leonardchan wrote:

In D96170#2561432, @rjmccall wrote:

I've never patched the bitcode reader/writer before, I think, but from similar patches I've seen, this look good to me. Is there any sort of registration you're supposed to do of the new code?

Hmm. By registration, do you mean making cmake aware of the new test? I don't *think* there's anything else I may need to change. I mainly just copied similar logic from how the other constant codes are handled.

Adding @rnk who may have more familiarity.

Some of the other serializers using bitcode require some of the codes to be registered, either as abbreviations or just for incidental reasons. If there's nothing like that for similar record codes, though, it's probably not a thing for BC.

Ah I see. So something similar to:

Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING));

It seems there's a handful of other ConstantCode BCs that use this, but most of them don't seem to use it. I'm guessing this might also be a case where it's not required.

[phosek]

LGTM

llvm/include/llvm/Bitcode/LLVMBitCodes.h

CST_CODE_INLINEASM_OLD = 18,   // INLINEASM:     [sideeffect|alignstack,
                                  //                 asmstr,conststr]
   CST_CODE_CE_SHUFVEC_EX = 19,   // SHUFVEC_EX:    [opty, opval, opval, opval]
   CST_CODE_CE_INBOUNDS_GEP = 20, // INBOUNDS_GEP:  [n x operands]
   CST_CODE_BLOCKADDRESS = 21,    // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#]
   CST_CODE_DATA = 22,            // DATA:          [n x elements]
   CST_CODE_INLINEASM = 23,       // INLINEASM:     [sideeffect|alignstack|
                                  //                 asmdialect,asmstr,conststr]
   CST_CODE_CE_GEP_WITH_INRANGE_INDEX = 24, //      [opty, flags, n x operands]
-  CST_CODE_CE_UNOP = 25,         // CE_UNOP:      [opcode, opval]
-  CST_CODE_POISON = 26,          // POISON
+  CST_CODE_CE_UNOP = 25,                   // CE_UNOP:      [opcode, opval]
+  CST_CODE_POISON = 26,                    // POISON
+  CST_CODE_DSO_LOCAL_EQUIVALENT = 27,      // DSO_LOCAL_EQUIVALENT [gvty, gv]
 };
 
 /// CastOpcodes - These are values used in the bitcode files to encode which
 /// cast a CST_CODE_CE_CAST or a XXX refers to.  The values of these enums
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum CastOpcodes {
   CAST_TRUNC = 0,

llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp

default:
       STRINGIFY_CODE(CST_CODE, CE_SELECT)
       STRINGIFY_CODE(CST_CODE, CE_EXTRACTELT)
       STRINGIFY_CODE(CST_CODE, CE_INSERTELT)
       STRINGIFY_CODE(CST_CODE, CE_SHUFFLEVEC)
       STRINGIFY_CODE(CST_CODE, CE_CMP)
       STRINGIFY_CODE(CST_CODE, INLINEASM)
       STRINGIFY_CODE(CST_CODE, CE_SHUFVEC_EX)
       STRINGIFY_CODE(CST_CODE, CE_UNOP)
+      STRINGIFY_CODE(CST_CODE, DSO_LOCAL_EQUIVALENT)
     case bitc::CST_CODE_BLOCKADDRESS:
       return "CST_CODE_BLOCKADDRESS";
       STRINGIFY_CODE(CST_CODE, DATA)
     }
   case bitc::FUNCTION_BLOCK_ID:
     switch (CodeID) {
     default:
       return None;

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::CST_CODE_BLOCKADDRESS:{
           FwdBBs.resize(BBID + 1);
         if (!FwdBBs[BBID])
           FwdBBs[BBID] = BasicBlock::Create(Context);
         BB = FwdBBs[BBID];
       }
       V = BlockAddress::get(Fn, BB);
       break;
     }
+    case bitc::CST_CODE_DSO_LOCAL_EQUIVALENT: {
+      if (Record.size() < 2)
+        return error("Invalid record");
+      Type *GVTy = getTypeByID(Record[0]);
+      if (!GVTy)
+        return error("Invalid record");
+      GlobalValue *GV = dyn_cast_or_null<GlobalValue>(
+          ValueList.getConstantFwdRef(Record[1], GVTy));
+      if (!GV)
+        return error("Invalid record");
+
+      V = DSOLocalEquivalent::get(GV);
+      break;
+    }
     }
 
     assert(V->getType() == flattenPointerTypes(CurFullTy) &&
            "Incorrect fully structured type provided for Constant");
     ValueList.assignValue(V, NextCstNo, CurFullTy);
     ++NextCstNo;
   }
 }

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

if (C->isNullValue()) {
         Record.push_back(CE->getPredicate());
         break;
       }
     } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
       Code = bitc::CST_CODE_BLOCKADDRESS;
       Record.push_back(VE.getTypeID(BA->getFunction()->getType()));
       Record.push_back(VE.getValueID(BA->getFunction()));
       Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));
+    } else if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(C)) {
+      Code = bitc::CST_CODE_DSO_LOCAL_EQUIVALENT;
+      Record.push_back(VE.getTypeID(Equiv->getGlobalValue()->getType()));
+      Record.push_back(VE.getValueID(Equiv->getGlobalValue()));
     } else {
 #ifndef NDEBUG
       C->dump();
 #endif
       llvm_unreachable("Unknown constant!");
     }
     Stream.EmitRecord(Code, Record, AbbrevToUse);
     Record.clear();

llvm/test/Bitcode/dso_local_equivalent.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+; RUN: verify-uselistorder < %s
+
+declare void @extern_func()
+
+define void @call_extern_func() {
+; CHECK: call void dso_local_equivalent @extern_func()
+  call void dso_local_equivalent @extern_func()
+  ret void
+}
+
+declare hidden void @hidden_func()
+declare protected void @protected_func()
+declare dso_local void @dso_local_func()
+define internal void @internal_func() {
+entry:
+  ret void
+}
+define private void @private_func() {
+entry:
+  ret void
+}
+
+; CHECK: call void dso_local_equivalent @hidden_func()
+define void @call_hidden_func() {
+  call void dso_local_equivalent @hidden_func()
+  ret void
+}
+
+define void @call_protected_func() {
+; CHECK: call void dso_local_equivalent @protected_func()
+  call void dso_local_equivalent @protected_func()
+  ret void
+}
+
+define void @call_dso_local_func() {
+; CHECK: call void dso_local_equivalent @dso_local_func()
+  call void dso_local_equivalent @dso_local_func()
+  ret void
+}
+
+define void @call_internal_func() {
+; CHECK: call void dso_local_equivalent @internal_func()
+  call void dso_local_equivalent @internal_func()
+  ret void
+}
+
+define void @aliasee_func() {
+entry:
+  ret void
+}
+
+@alias_func = alias void (), void ()* @aliasee_func
+@dso_local_alias_func = dso_local alias void (), void ()* @aliasee_func
+
+define void @call_alias_func() {
+; CHECK: call void dso_local_equivalent @alias_func()
+  call void dso_local_equivalent @alias_func()
+  ret void
+}
+
+define void @call_dso_local_alias_func() {
+; CHECK: call void dso_local_equivalent @dso_local_alias_func()
+  call void dso_local_equivalent @dso_local_alias_func()
+  ret void
+}
+
+@ifunc_func = ifunc void (), i64 ()* @resolver
+@dso_local_ifunc_func = dso_local ifunc void (), i64 ()* @resolver
+
+define internal i64 @resolver() {
+entry:
+  ret i64 0
+}
+
+define void @call_ifunc_func() {
+; CHECK: call void dso_local_equivalent @ifunc_func()
+  call void dso_local_equivalent @ifunc_func()
+  ret void
+}
+
+define void @call_dso_local_ifunc_func() {
+; CHECK: call void dso_local_equivalent @dso_local_ifunc_func()
+  call void dso_local_equivalent @dso_local_ifunc_func()
+  ret void
+}