fix: lab8 no angr

Author: YingMuo

.github/workflows/lab-autograding.yml

@@ -56,4 +56,7 @@ jobs:
                   if [ ${{ steps.lab.outputs.result }} -eq 6 ]; then
                     sudo apt install -y llvm-14
                   fi
+                  if [ ${{ steps.lab.outputs.result }} -eq 8 ]; then
+                    python3 -m pip install angr
+                  fi
                   ./validate.sh

lab3/main_test.js

@@ -1,96 +1,5 @@
-const { describe, it, beforeEach } = require('node:test');
+const {describe, it} = require('node:test');
 const assert = require('assert');
 const { Calculator } = require('./main');
 
-describe('Calculator', () => {
-    let calculator;
-    beforeEach(() => {
-        calculator = new Calculator();
-    });
-
-    describe('exp method', () => {
-        it('unsupported operand type', () => {
-            const testcases = [
-                { param: [Infinity], expected: 'unsupported operand type' },
-                { param: [-Infinity], expected: 'unsupported operand type' },
-                { param: [NaN], expected: 'unsupported operand type' },
-            ];
-
-            for (const tc of testcases) {
-                assert.throws(() => calculator.exp(...tc.param), new RegExp(tc.expected));
-            }
-        });
-
-        it('overflow', () => {
-            const testcases = [
-                { param: [710], expected: 'overflow' },
-            ];
-
-            for (const tc of testcases) {
-                assert.throws(() => calculator.exp(...tc.param), new RegExp(tc.expected));
-            }
-        });
-
-        it('normal', () => {
-            const testcases = [
-                { param: [0], expected: Math.exp(0) },
-                { param: [1], expected: Math.exp(1) },
-                { param: [2], expected: Math.exp(2) },
-                { param: [-1], expected: Math.exp(-1) },
-                { param: [-2], expected: Math.exp(-2) },
-            ];
-
-            for (const tc of testcases) {
-                const result = calculator.exp(...tc.param);
-                assert.strictEqual(result, tc.expected);
-            }
-        });
-    });
-
-    describe('log method', () => {
-        it('unsupported operand type', () => {
-            const testcases = [
-                { param: [Infinity], expected: 'unsupported operand type' },
-                { param: [-Infinity], expected: 'unsupported operand type' },
-                { param: [NaN], expected: 'unsupported operand type' },
-            ];
-
-            for (const tc of testcases) {
-                assert.throws(() => calculator.log(...tc.param), new RegExp(tc.expected));
-            }
-        });
-
-        it('math domain error (1)', () => {
-            const testcases = [
-                { param: [0], expected: 'math domain error \\(1\\)' },
-            ];
-
-            for (const tc of testcases) {
-                assert.throws(() => calculator.log(...tc.param), new RegExp(tc.expected));
-            }
-        });
-
-        it('math domain error (2)', () => {
-            const testcases = [
-                { param: [-1], expected: 'math domain error \\(2\\)' },
-                { param: [-2], expected: 'math domain error \\(2\\)' },
-            ];
-
-            for (const tc of testcases) {
-                assert.throws(() => calculator.log(...tc.param), new RegExp(tc.expected));
-            }
-        });
-
-        it('normal', () => {
-            const testcases = [
-                { param: [1], expected: Math.log(1) },
-                { param: [2], expected: Math.log(2) },
-            ];
-
-            for (const tc of testcases) {
-                const result = calculator.log(...tc.param);
-                assert.strictEqual(result, tc.expected);
-            }
-        });
-    });
-});
+// TODO: write your tests here

lab6/llvm-pass.so.cc

@@ -10,34 +10,13 @@ struct LLVMPass : public PassInfoMixin<LLVMPass> {
 
 PreservedAnalyses LLVMPass::run(Module &M, ModuleAnalysisManager &MAM) {
   LLVMContext &Ctx = M.getContext();
-  IRBuilder<> Builder(Ctx);
-
   IntegerType *Int32Ty = IntegerType::getInt32Ty(Ctx);
-  PointerType *I8PtrTy  = Type::getInt8PtrTy(Ctx); // for argv
-
   FunctionCallee debug_func = M.getOrInsertFunction("debug", Int32Ty);
   ConstantInt *debug_arg = ConstantInt::get(Int32Ty, 48763);
-  Constant *StrGlobal = Builder.CreateGlobalStringPtr("hayaku... motohayaku!", "",
-    0, &M); // for argv
 
   for (auto &F : M) {
-    if (F.getName() == "main"){
-      // insert debug
-      BasicBlock &Entry = F.getEntryBlock();
-      Builder.SetInsertPoint(&*Entry.getFirstInsertionPt());
-      Builder.CreateCall(debug_func, {debug_arg});
+    errs() << "func: " << F.getName() << "\n";
 
-      // insert argc, argv
-      auto ArgIter = F.arg_begin();
-      Argument *Argc = &*ArgIter++;
-      Argument *Argv = &*ArgIter; 
-      // replace argc -> i8, hayaku... motohayaku!
-      Value *Idx1    = Builder.getInt32(1);
-      Value *Argv1Ptr= Builder.CreateGEP(I8PtrTy, Argv, Idx1);
-      Builder.CreateStore(StrGlobal, Argv1Ptr);
-      // replace argv -> debug_arg 48763
-      if (!Argc->use_empty()) Argc->replaceAllUsesWith(debug_arg);
-    }
   }
   return PreservedAnalyses::none();
 }