Fixed #72 (Memory used by fist/fld was wrongly adjusted).

src/app/test/asmjit_test_x86.cpp

@@ -2451,6 +2451,60 @@ struct X86Test_CallMisc1 : public X86Test {
   }
 };
 
+// ============================================================================
+// [X86Test_CallMisc2]
+// ============================================================================
+
+struct X86Test_CallMisc2 : public X86Test {
+  X86Test_CallMisc2() : X86Test("[Call] Misc #2") {}
+
+  static void add(PodVector<X86Test*>& tests) {
+    tests.append(new X86Test_CallMisc2());
+  }
+
+  virtual void compile(X86Compiler& c) {
+    X86FuncNode* func = c.addFunc(kFuncConvHost, FuncBuilder1<double, const double*>());
+
+    X86GpVar p(c, kVarTypeIntPtr, "p");
+    X86GpVar fn(c, kVarTypeIntPtr, "fn");
+
+    X86XmmVar arg(c, kX86VarTypeXmmSd, "arg");
+    X86XmmVar ret(c, kX86VarTypeXmmSd, "ret");
+
+    c.setArg(0, p);
+    c.movsd(arg, x86::ptr(p));
+    c.mov(fn, imm_ptr((void*)op));
+
+    X86CallNode* call = c.call(fn, kFuncConvHost, FuncBuilder1<double, double>());
+    call->setArg(0, arg);
+    call->setRet(0, ret);
+
+    c.ret(ret);
+    c.endFunc();
+  }
+
+  virtual bool run(void* _func, StringBuilder& result, StringBuilder& expect) {
+    typedef double (*Func)(const double*);
+    Func func = asmjit_cast<Func>(_func);
+
+    double arg = 2;
+
+    double resultRet = func(&arg);
+    double expectRet = op(arg);
+
+    result.setFormat("ret=%g", resultRet);
+    expect.setFormat("ret=%g", expectRet);
+
+    return resultRet == expectRet;
+  }
+
+  static double op(double a) { return a * a; }
+};
+
+void test() {
+}
+
+
 // ============================================================================
 // [X86Test_ConstPoolBase]
 // ============================================================================
@@ -2578,6 +2632,7 @@ X86TestSuite::X86TestSuite() :
   ADD_TEST(X86Test_CallMultiple);
   ADD_TEST(X86Test_CallRecursive);
   ADD_TEST(X86Test_CallMisc1);
+  ADD_TEST(X86Test_CallMisc2);
   ADD_TEST(X86Test_ConstPoolBase);
 }
 

src/asmjit/base/context.cpp

@@ -234,13 +234,13 @@ Error Context::resolveCellOffsets() {
     varCell = varCell->_next;
   }
 
-  // Stack - Allocated according to alignment and width.
+  // Stack - Allocated according to alignment/width.
   while (stackCell != NULL) {
     uint32_t size = stackCell->getSize();
     uint32_t alignment = stackCell->getAlignment();
     uint32_t offset;
 
-    // Try to fill the gap between variables / stack first.
+    // Try to fill the gap between variables/stack first.
     if (size <= gapSize && alignment <= gapAlignment) {
       offset = gapPos;
 

src/asmjit/x86/x86context.cpp

@@ -4562,7 +4562,7 @@ static Error X86Context_initFunc(X86Context* self, X86FuncNode* func) {
     // Get a memory cell where the original stack frame will be stored.
     MemCell* cell = self->_newStackCell(regSize, regSize);
     if (cell == NULL)
-      return self->getError();
+      return self->getError(); // The error has already been set.
 
     func->addFuncFlags(kFuncFlagIsStackAdjusted);
     self->_stackFrameCell = cell;
@@ -4738,16 +4738,14 @@ static Error X86Context_patchFuncMem(X86Context* self, X86FuncNode* func, Node*
 
           if (vd->isMemArg()) {
             m->_vmem.base = self->_argBaseReg;
-            m->_vmem.displacement += vd->getMemOffset();
-            m->_vmem.displacement += self->_argBaseOffset;
+            m->_vmem.displacement += self->_argBaseOffset + vd->getMemOffset();
           }
           else {
             MemCell* cell = vd->getMemCell();
             ASMJIT_ASSERT(cell != NULL);
 
             m->_vmem.base = self->_varBaseReg;
-            m->_vmem.displacement += cell->getOffset();
-            m->_vmem.displacement += self->_varBaseOffset;
+            m->_vmem.displacement += self->_varBaseOffset + cell->getOffset();
           }
         }
       }
@@ -4812,7 +4810,7 @@ static Error X86Context_translatePrologEpilog(X86Context* self, X86FuncNode* fun
   if (func->isNaked()) {
     if (func->isStackMisaligned()) {
       fpReg.setIndex(func->getStackFrameRegIndex());
-      fpOffset = x86::ptr(self->_zsp, static_cast<int32_t>(self->_stackFrameCell->getOffset()));
+      fpOffset = x86::ptr(self->_zsp, self->_varBaseOffset + static_cast<int32_t>(self->_stackFrameCell->getOffset()));
 
       earlyPushPop = func->hasFuncFlag(kX86FuncFlagPushPop);
       if (earlyPushPop)