added new tests, fixed some mappings

Author: leventeBajczi

xcfa-mapper/src/Mapper.cpp

@@ -340,7 +340,7 @@ std::string Mapper::mapTypeToC(mlir::Type t) const {
 
     // Check for CIR bool type
     if (typeStr.find("!cir.bool") != std::string::npos) {
-      return "int"; // C89 compatible, or "bool" for C99+
+      return "_Bool"; // Emit C99 _Bool for true boolean values
     }
 
     // Check for CIR integer types with size and signedness
@@ -425,7 +425,7 @@ std::string Mapper::mapTypeToC(mlir::Type t) const {
         } else if (elementTypeStr.find("!cir.double") != std::string::npos) {
           ctype = "double";
         } else if (elementTypeStr.find("!cir.bool") != std::string::npos) {
-          ctype = "int";
+          ctype = "_Bool";
         }
         return ctype + "[" + sizeStr + "]";
       }
@@ -629,6 +629,27 @@ bool Mapper::mapModule(ModuleOp module, std::ostream &out) {
   // collisions when demangling.
   prepareFunctionNames(module);
 
+  // Discover union record names from the textual IR so aliases (!rec_*)
+  // that denote unions can be recognized without heuristics.
+  std::set<std::string> unionRecordNames;
+  {
+    std::string irText;
+    llvm::raw_string_ostream rso(irText);
+    module.print(rso);
+    rso.flush();
+    const std::string needle = "!cir.record<union \"";
+    std::size_t pos = 0;
+    while ((pos = irText.find(needle, pos)) != std::string::npos) {
+      pos += needle.size();
+      auto end = irText.find("\"", pos);
+      if (end == std::string::npos) break;
+      std::string name = irText.substr(pos, end - pos);
+      std::replace(name.begin(), name.end(), '.', '_');
+      unionRecordNames.insert(name);
+      pos = end + 1;
+    }
+  }
+  
   // Auto-parse struct definitions by scanning member accesses.
   struct FieldInfo {
     std::string name;        // field name
@@ -801,10 +822,7 @@ bool Mapper::mapModule(ModuleOp module, std::ostream &out) {
       }
       info.name = fname;
 
-      // Heuristic: if we see a field named 'value' on a record, it's likely a union
-      if (fname == "value") {
-        isUnionContainer[structName] = true;
-      }
+      // Note: union detection is driven by IR-declared unions, not field names.
 
       // Avoid duplicate entries for the same field name
   auto &vec = structFields[structName];
@@ -817,6 +835,14 @@ bool Mapper::mapModule(ModuleOp module, std::ostream &out) {
   // Kick off collection for top-level operations
   for (auto &op : module.getOps()) collectFromOp(op);
 
+  // Mark union containers based on discovered union record names.
+  for (auto &kv : structFields) {
+    const auto &recName = kv.first;
+    if (unionRecordNames.count(recName)) {
+      isUnionContainer[recName] = true;
+    }
+  }
+
   // Order structs to satisfy dependencies: if a struct references another
   // struct in its fields, emit the dependency first. Simple fixed-point topo.
   auto getDeps = [&](const std::string &sname){

xcfa-mapper/src/handlers/Handlers.cpp

@@ -600,7 +600,19 @@ bool handleUnaryOp(cir::UnaryOp op, Mapper &m, std::ostream &out) {
       case cir::UnaryOpKind::Dec: opStr = "--"; opFound = true; isPrefix = true; break;
       case cir::UnaryOpKind::Plus: opStr = "+"; opFound = true; isPrefix = true; break;
       case cir::UnaryOpKind::Minus: opStr = "-"; opFound = true; isPrefix = true; break;
-      case cir::UnaryOpKind::Not: opStr = "!"; opFound = true; isPrefix = true; break;
+      case cir::UnaryOpKind::Not: {
+        // CIR 'not' may represent logical not when applied to !cir.bool,
+        // and bitwise complement otherwise. Inspect operand type.
+        std::string ty;
+        if (o->getNumOperands() > 0) {
+          llvm::SmallString<64> tbuf; llvm::raw_svector_ostream tos(tbuf);
+          o->getOperand(0).getType().print(tos);
+          ty = tos.str().str();
+        }
+        if (ty.find("!cir.bool") != std::string::npos) opStr = "!";
+        else opStr = "~";
+        opFound = true; isPrefix = true; break;
+      }
       default: opFound = false; break;
     }
   }
@@ -640,11 +652,22 @@ bool handleShiftOp(cir::ShiftOp op, Mapper &m, std::ostream &out) {
   std::string l = m.getOrCreateName(lhs);
   std::string r = m.getOrCreateName(rhs);
 
-  // ShiftOp doesn't have a kind attribute in the current CIR - it uses
-  // the 'is_left_shift' boolean attribute instead
-  std::string opStr = "<<"; // default to left shift
-  if (auto isLeftAttr = o->getAttrOfType<mlir::BoolAttr>("is_left_shift")) {
-    opStr = isLeftAttr.getValue() ? "<<" : ">>";
+  // Determine direction from textual form (left/right) to avoid relying on
+  // generated enum types across CIR versions.
+  std::string opStr = "<<"; // default to left
+  {
+    llvm::SmallString<128> sbuf;
+    llvm::raw_svector_ostream sos(sbuf);
+    o->print(sos);
+    std::string os = sos.str().str();
+    if (os.find("shift(right,") != std::string::npos) opStr = ">>";
+    else if (os.find("shift(left,") != std::string::npos) opStr = "<<";
+    else {
+      // Fallback: some older dumps may encode a boolean direction
+      if (auto isLeftAttr = o->getAttrOfType<mlir::BoolAttr>("is_left_shift")) {
+        opStr = isLeftAttr.getValue() ? "<<" : ">>";
+      }
+    }
   }
 
   std::string tmp = m.freshName("s");
@@ -947,6 +970,15 @@ bool handleGetGlobal(cir::GetGlobalOp op, Mapper &m, std::ostream &out) {
   // Sanitize the global name to be a valid C identifier
   globalName = Mapper::sanitizeIdentifier(globalName);
 
+  // If the result of get_global isn't used, don't emit a temporary.
+  if (o->getNumResults() > 0) {
+    mlir::Value res = o->getResult(0);
+    if (res.use_empty()) {
+      // No side effects, safe to elide.
+      return true;
+    }
+  }
+
   std::string tmp = m.freshName("g");
   std::string ctype = "int*";
   if (o->getNumResults() > 0) ctype = m.mapTypeToC(o->getResult(0).getType());