Merge remote-tracking branch 'ykjit/main'

Author: ptersilie

.buildbot.sh

@@ -9,9 +9,9 @@ cd build
 # Disabling default PIE due to:
 # https://github.com/llvm/llvm-project/issues/57085
 cmake -DCMAKE_INSTALL_PREFIX=${INST_DIR} \
-    -DLLVM_INSTALL_UTILS=On \
+    -DLLVM_INSTALL_UTILS=ON \
     -DCMAKE_BUILD_TYPE=release \
-    -DLLVM_ENABLE_ASSERTIONS=On \
+    -DLLVM_ENABLE_ASSERTIONS=ON \
     -DLLVM_ENABLE_PROJECTS="lld;clang" \
     -DCLANG_DEFAULT_PIE_ON_LINUX=OFF \
     -DBUILD_SHARED_LIBS=ON \
@@ -51,3 +51,24 @@ cmake --build build --target check-all
 #	../test-suite
 #make -j `nproc`
 #llvm-lit -v -j 1 -o results.json .
+
+# Check ykllvm builds with assertions disabled.
+#
+# In the past things like `Value::dump()` have slipped in to the repo and these
+# are not available if LLVM is built without assertions (you'd get a linker
+# error).
+rm -rf build
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=${INST_DIR} \
+    -DLLVM_INSTALL_UTILS=ON \
+    -DCMAKE_BUILD_TYPE=release \
+    -DLLVM_ENABLE_ASSERTIONS=OFF \
+    -DLLVM_ENABLE_PROJECTS="lld;clang" \
+    -DCLANG_DEFAULT_PIE_ON_LINUX=OFF \
+    -DBUILD_SHARED_LIBS=ON \
+    -DCMAKE_C_COMPILER=/usr/bin/clang \
+    -DCMAKE_CXX_COMPILER=/usr/bin/clang++ \
+    -GNinja \
+    ../llvm
+cmake --build .

llvm/lib/YkIR/YkIRWriter.cpp

@@ -54,13 +54,15 @@ enum OperandKind {
   Type,
   Function,
   Block,
+  Arg,
   UnimplementedOperand = 255,
 };
 
 enum TypeKind {
   Void = 0,
   Integer,
   Ptr,
+  FunctionTy,
   UnimplementedType = 255, // YKFIXME: Will eventually be deleted.
 };
 
@@ -132,8 +134,17 @@ class YkIRWriter {
     if (Found != Types.end()) {
       return std::distance(Types.begin(), Found);
     }
+
+    // Not found. Assign it a type index.
     size_t Idx = Types.size();
     Types.push_back(Ty);
+
+    // If the newly-registered type is an aggregate type that contains other
+    // types, then assign them type indices now too.
+    for (llvm::Type *STy : Ty->subtypes()) {
+      typeIndex(STy);
+    }
+
     return Idx;
   }
 
@@ -205,12 +216,20 @@ class YkIRWriter {
     serialiseString(toString(V));
   }
 
+  void serialiseArgOperand(ValueLoweringMap &VLMap, Argument *A) {
+    // This assumes that the argument indices match in both IRs.
+    OutStreamer.emitInt8(OperandKind::Arg);
+    OutStreamer.emitSizeT(A->getArgNo());
+  }
+
   void serialiseOperand(Instruction *Parent, ValueLoweringMap &VLMap,
                         Value *V) {
     if (llvm::Function *F = dyn_cast<llvm::Function>(V)) {
       serialiseFunctionOperand(F);
     } else if (llvm::Constant *C = dyn_cast<llvm::Constant>(V)) {
       serialiseConstantOperand(Parent, C);
+    } else if (llvm::Argument *A = dyn_cast<llvm::Argument>(V)) {
+      serialiseArgOperand(VLMap, A);
     } else if (Instruction *I = dyn_cast<Instruction>(V)) {
       // If an instruction defines the operand, it's a local variable.
       serialiseLocalVariableOperand(I, VLMap);
@@ -371,9 +390,16 @@ class YkIRWriter {
     BBIdx++;
   }
 
+  void serialiseArg(Argument *A) {
+    // type_index:
+    OutStreamer.emitSizeT(typeIndex(A->getType()));
+  }
+
   void serialiseFunc(llvm::Function &F) {
     // name:
     serialiseString(F.getName());
+    // type_idx:
+    OutStreamer.emitSizeT(typeIndex(F.getFunctionType()));
     // num_blocks:
     OutStreamer.emitSizeT(F.size());
     // blocks:
@@ -384,6 +410,20 @@ class YkIRWriter {
     }
   }
 
+  void serialiseFunctionType(FunctionType *Ty) {
+    OutStreamer.emitInt8(TypeKind::FunctionTy);
+    // num_args:
+    OutStreamer.emitSizeT(Ty->getNumParams());
+    // arg_tys:
+    for (llvm::Type *SubTy : Ty->params()) {
+      OutStreamer.emitSizeT(typeIndex(SubTy));
+    }
+    // ret_ty:
+    OutStreamer.emitSizeT(typeIndex(Ty->getReturnType()));
+    // is_vararg:
+    OutStreamer.emitInt8(Ty->isVarArg());
+  }
+
   void serialiseType(llvm::Type *Ty) {
     if (Ty->isVoidTy()) {
       OutStreamer.emitInt8(TypeKind::Void);
@@ -392,6 +432,8 @@ class YkIRWriter {
     } else if (IntegerType *ITy = dyn_cast<IntegerType>(Ty)) {
       OutStreamer.emitInt8(TypeKind::Integer);
       OutStreamer.emitInt32(ITy->getBitWidth());
+    } else if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
+      serialiseFunctionType(FTy);
     } else {
       OutStreamer.emitInt8(TypeKind::UnimplementedType);
       serialiseString(toString(Ty));